Category

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

Compress-Decompress algrithms

Development Platform:

Visual C++

il_dds.c：Code Content
  1. //-----------------------------------------------------------------------------
  2. //
  3. // ImageLib Sources
  4. // Copyright (C) 2000-2009 by Denton Woods
  5. // Last modified: 01/30/2009
  6. //
  7. // Filename: src-IL/src/il_dds.c
  8. //
  9. // Description: Reads from a DirectDraw Surface (.dds) file.
  10. //
  11. //-----------------------------------------------------------------------------
  14. //
  15. //
  16. // Note:  Almost all this code is from nVidia's DDS-loading example at
  17. // http://www.nvidia.com/view.asp?IO=dxtc_decompression_code
  18. // and from the specs at
  19. // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dx8_c/hh/dx8_c/graphics_using_0j03.asp
  20. // and
  21. // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dx8_c/directx_cpp/Graphics/ProgrammersGuide/Appendix/DDSFileFormat/ovwDDSFileFormat.asp
  22. // However, some not really valid .dds files are also read, for example
  23. // Volume Textures without the COMPLEX bit set, so the specs aren't taken
  24. // too strictly while reading.
  27. #include "il_internal.h"
  28. #ifndef IL_NO_DDS
  29. #include "il_dds.h"
  32. // Global variables
  33. static DDSHEAD Head; // Image header
  34. static ILubyte *CompData = NULL; // Compressed data
  35. static ILuint CompSize; // Compressed size
  36. //static ILuint CompFormat; // Compressed format
  37. static ILimage *Image;
  38. static ILint Width, Height, Depth;
  40. ILuint CubemapDirections[CUBEMAP_SIDES] = {
  41. DDS_CUBEMAP_POSITIVEX,
  42. DDS_CUBEMAP_NEGATIVEX,
  43. DDS_CUBEMAP_POSITIVEY,
  44. DDS_CUBEMAP_NEGATIVEY,
  45. DDS_CUBEMAP_POSITIVEZ,
  46. DDS_CUBEMAP_NEGATIVEZ
  47. };
  50. //! Checks if the file specified in FileName is a valid .dds file.
  51. ILboolean ilIsValid_DDS(ILconst_string FileName)
  52. {
  53. ILHANDLE DdsFile;
  54. ILboolean bDds = IL_FALSE;
  56. if (!iCheckExtension(FileName, IL_TEXT("dds"))) {
  57. ilSetError(IL_INVALID_EXTENSION);
  58. return bDds;
  59. }
  61. DdsFile = iopenr(FileName);
  62. if (DdsFile == NULL) {
  63. ilSetError(IL_COULD_NOT_OPEN_FILE);
  64. return bDds;
  65. }
  67. bDds = ilIsValidF_DDS(DdsFile);
  68. icloser(DdsFile);
  70. return bDds;
  71. }
  74. //! Checks if the ILHANDLE contains a valid .dds file at the current position.
  75. ILboolean ilIsValidF_DDS(ILHANDLE File)
  76. {
  77. ILuint FirstPos;
  78. ILboolean bRet;
  80. iSetInputFile(File);
  81. FirstPos = itell();
  82. bRet = iIsValidDds();
  83. iseek(FirstPos, IL_SEEK_SET);
  85. return bRet;
  86. }
  89. //! Checks if Lump is a valid .dds lump.
  90. ILboolean ilIsValidL_DDS(const void *Lump, ILuint Size)
  91. {
  92. iSetInputLump(Lump, Size);
  93. return iIsValidDds();
  94. }
  97. // Internal function used to get the .dds header from the current file.
  98. ILboolean iGetDdsHead(DDSHEAD *Header)
  99. {
  100. ILint i;
  102. iread(&Header->Signature, 1, 4);
  103. Header->Size1 = GetLittleUInt();
  104. Header->Flags1 = GetLittleUInt();
  105. Header->Height = GetLittleUInt();
  106. Header->Width = GetLittleUInt();
  107. Header->LinearSize = GetLittleUInt();
  108. Header->Depth = GetLittleUInt();
  109. Header->MipMapCount = GetLittleUInt();
  110. Header->AlphaBitDepth = GetLittleUInt();
  112. for (i = 0; i < 10; ++i)
  113. Header->NotUsed[i] = GetLittleUInt();
  115. Header->Size2 = GetLittleUInt();
  116. Header->Flags2 = GetLittleUInt();
  117. Header->FourCC = GetLittleUInt();
  118. Header->RGBBitCount = GetLittleUInt();
  119. Header->RBitMask = GetLittleUInt();
  120. Header->GBitMask = GetLittleUInt();
  121. Header->BBitMask = GetLittleUInt();
  122. Header->RGBAlphaBitMask = GetLittleUInt();
  123. Header->ddsCaps1 = GetLittleUInt();
  124. Header->ddsCaps2 = GetLittleUInt();
  125. Header->ddsCaps3 = GetLittleUInt();
  126. Header->ddsCaps4 = GetLittleUInt();
  127. Header->TextureStage = GetLittleUInt();
  129. if (Head.Depth == 0)
  130. Head.Depth = 1;
  132. return IL_TRUE;
  133. }
  136. // Internal function to get the header and check it.
  137. ILboolean iIsValidDds()
  138. {
  139. ILboolean IsValid;
  140. DDSHEAD Head;
  142. iGetDdsHead(&Head);
  143. iseek(-(ILint)sizeof(DDSHEAD), IL_SEEK_CUR);  // Go ahead and restore to previous state
  145. IsValid = iCheckDds(&Head);
  147. return IsValid;
  148. }
  151. // Internal function used to check if the HEADER is a valid .dds header.
  152. ILboolean iCheckDds(DDSHEAD *Head)
  153. {
  154. if (strncmp((const char*)Head->Signature, "DDS ", 4))
  155. return IL_FALSE;
  156. //note that if Size1 is "DDS " this is not a valid dds file according
  157. //to the file spec. Some broken tool out there seems to produce files
  158. //with this value in the size field, so we support reading them...
  159. if (Head->Size1 != 124 && Head->Size1 != IL_MAKEFOURCC('D', 'D', 'S', ' '))
  160. return IL_FALSE;
  161. if (Head->Size2 != 32)
  162. return IL_FALSE;
  163. if (Head->Width == 0 || Head->Height == 0)
  164. return IL_FALSE;
  165. return IL_TRUE;
  166. }
  169. //! Reads a .dds file
  170. ILboolean ilLoad_DDS(ILconst_string FileName)
  171. {
  172. ILHANDLE DdsFile;
  173. ILboolean bDds = IL_FALSE;
  175. DdsFile = iopenr(FileName);
  176. if (DdsFile == NULL) {
  177. ilSetError(IL_COULD_NOT_OPEN_FILE);
  178. return bDds;
  179. }
  181. bDds = ilLoadF_DDS(DdsFile);
  182. icloser(DdsFile);
  184. return bDds;
  185. }
  188. //! Reads an already-opened .dds file
  189. ILboolean ilLoadF_DDS(ILHANDLE File)
  190. {
  191. ILuint FirstPos;
  192. ILboolean bRet;
  194. iSetInputFile(File);
  195. FirstPos = itell();
  196. bRet = iLoadDdsInternal();
  197. iseek(FirstPos, IL_SEEK_SET);
  199. return bRet;
  200. }
  203. //! Reads from a memory "lump" that contains a .dds
  204. ILboolean ilLoadL_DDS(const void *Lump, ILuint Size)
  205. {
  206. iSetInputLump(Lump, Size);
  207. return iLoadDdsInternal();
  208. }
  211. ILubyte iCompFormatToBpp(ILenum Format)
  212. {
  213. //non-compressed (= non-FOURCC) codes
  214. if (Format == PF_LUMINANCE || Format == PF_LUMINANCE_ALPHA || Format == PF_ARGB)
  215. return Head.RGBBitCount/8;
  217. //fourcc formats
  218. else if (Format == PF_RGB || Format == PF_3DC || Format == PF_RXGB)
  219. return 3;
  220. else if (Format == PF_ATI1N)
  221. return 1;
  222. else if (Format == PF_R16F)
  223. return 2;
  224. else if (Format == PF_A16B16G16R16 || Format == PF_A16B16G16R16F
  225. || Format == PF_G32R32F)
  226. return 8;
  227. else if (Format == PF_A32B32G32R32F)
  228. return 16;
  229. else //if (Format == PF_G16R16F || Format == PF_R32F || dxt)
  230. return 4;
  231. }
  234. ILubyte iCompFormatToBpc(ILenum Format)
  235. {
  236. if (Format == PF_R16F || Format == PF_G16R16F || Format == PF_A16B16G16R16F)
  237. //DevIL has no internal half type, so these formats are converted to 32 bits
  238. return 4;
  239. else if (Format == PF_R32F || Format == PF_G32R32F || Format == PF_A32B32G32R32F)
  240. return 4;
  241. else if(Format == PF_A16B16G16R16)
  242. return 2;
  243. else
  244. return 1;
  245. }
  248. ILubyte iCompFormatToChannelCount(ILenum Format)
  249. {
  250. if (Format == PF_RGB || Format == PF_3DC || Format == PF_RXGB)
  251. return 3;
  252. else if (Format == PF_LUMINANCE || Format == PF_R16F || Format == PF_R32F || Format == PF_ATI1N)
  253. return 1;
  254. else if (Format == PF_LUMINANCE_ALPHA || Format == PF_G16R16F || Format == PF_G32R32F)
  255. return 2;
  256. else //if(Format == PF_ARGB || dxt)
  257. return 4;
  258. }
  261. ILboolean iLoadDdsCubemapInternal(ILuint CompFormat)
  262. {
  263. ILuint i;
  264. ILubyte Bpp, Channels, Bpc;
  265. ILimage *startImage;
  267. CompData = NULL;
  269. Bpp = iCompFormatToBpp(CompFormat);
  270. Channels = iCompFormatToChannelCount(CompFormat);
  271. Bpc = iCompFormatToBpc(CompFormat);
  272. if (CompFormat == PF_LUMINANCE && Head.RGBBitCount == 16 && Head.RBitMask == 0xFFFF) { //@TODO: This is a HACK.
  273. Bpc = 2; Bpp = 2;
  274. }
  276. startImage = Image;
  277. // Run through cube map possibilities
  278. for (i = 0; i < CUBEMAP_SIDES; i++) {
  279. // Reset each time
  280. Width = Head.Width;
  281. Height = Head.Height;
  282. Depth = Head.Depth;
  283. if (Head.ddsCaps2 & CubemapDirections[i]) {
  284. if (i != 0) {
  285. Image->Faces = ilNewImage(Width, Height, Depth, Channels, Bpc);
  286. if (Image->Faces == NULL)
  287. return IL_FALSE;
  289. Image = Image->Faces;
  291. if (CompFormat == PF_R16F
  292. || CompFormat == PF_G16R16F
  293. || CompFormat == PF_A16B16G16R16F
  294. || CompFormat == PF_R32F
  295. || CompFormat == PF_G32R32F
  296. || CompFormat == PF_A32B32G32R32F) {
  297. // DevIL's format autodetection doesn't work for
  298. //  float images...correct this.
  299. Image->Type = IL_FLOAT;
  300. Image->Bpp = Channels;
  301. }
  303. ilBindImage(ilGetCurName()); // Set to parent image first.
  304. //ilActiveImage(i); //@TODO: now Image == iCurImage...globals SUCK, fix this!!!
  305. ilActiveFace(i);
  306. }
  308. if (!ReadData())
  309. return IL_FALSE;
  311. if (!AllocImage(CompFormat)) {
  312. if (CompData) {
  313. ifree(CompData);
  314. CompData = NULL;
  315. }
  316. return IL_FALSE;
  317. }
  319. Image->CubeFlags = CubemapDirections[i];
  321. if (!DdsDecompress(CompFormat)) {
  322. if (CompData) {
  323. ifree(CompData);
  324. CompData = NULL;
  325. }
  326. return IL_FALSE;
  327. }
  329. if (!ReadMipmaps(CompFormat)) {
  330. if (CompData) {
  331. ifree(CompData);
  332. CompData = NULL;
  333. }
  334. return IL_FALSE;
  335. }
  336. }
  337. }
  339. if (CompData) {
  340. ifree(CompData);
  341. CompData = NULL;
  342. }
  344. ilBindImage(ilGetCurName());  // Set to parent image first.
  345. return ilFixImage();
  346. }
  349. ILboolean iLoadDdsInternal()
  350. {
  351. ILuint BlockSize = 0;
  352. ILuint CompFormat;
  354. CompData = NULL;
  355. Image = NULL;
  357. if (iCurImage == NULL) {
  358. ilSetError(IL_ILLEGAL_OPERATION);
  359. return IL_FALSE;
  360. }
  362. if (!iGetDdsHead(&Head)) {
  363. ilSetError(IL_INVALID_FILE_HEADER);
  364. return IL_FALSE;
  365. }
  366. if (!iCheckDds(&Head)) {
  367. ilSetError(IL_INVALID_FILE_HEADER);
  368. return IL_FALSE;
  369. }
  371. BlockSize = DecodePixelFormat(&CompFormat);
  372. if (CompFormat == PF_UNKNOWN) {
  373. ilSetError(IL_INVALID_FILE_HEADER);
  374. return IL_FALSE;
  375. }
  377. // Microsoft bug, they're not following their own documentation.
  378. if (!(Head.Flags1 & (DDS_LINEARSIZE | DDS_PITCH))
  379. || Head.LinearSize == 0) {
  380. Head.Flags1 |= DDS_LINEARSIZE;
  381. Head.LinearSize = BlockSize;
  382. }
  384. Image = iCurImage;
  385. if (Head.ddsCaps1 & DDS_COMPLEX) {
  386. if (Head.ddsCaps2 & DDS_CUBEMAP) {
  387. if (!iLoadDdsCubemapInternal(CompFormat))
  388. return IL_FALSE;
  389. return IL_TRUE;
  390. }
  391. }
  393. Width = Head.Width;
  394. Height = Head.Height;
  395. Depth = Head.Depth;
  396. AdjustVolumeTexture(&Head, CompFormat);
  398. if (!ReadData())
  399. return IL_FALSE;
  400. if (!AllocImage(CompFormat)) {
  401. if (CompData) {
  402. ifree(CompData);
  403. CompData = NULL;
  404. }
  405. return IL_FALSE;
  406. }
  407. if (!DdsDecompress(CompFormat)) {
  408. if (CompData) {
  409. ifree(CompData);
  410. CompData = NULL;
  411. }
  412. return IL_FALSE;
  413. }
  415. if (!ReadMipmaps(CompFormat)) {
  416. if (CompData) {
  417. ifree(CompData);
  418. CompData = NULL;
  419. }
  420. return IL_FALSE;
  421. }
  423. if (CompData) {
  424. ifree(CompData);
  425. CompData = NULL;
  426. }
  428. ilBindImage(ilGetCurName());  // Set to parent image first.
  429. return ilFixImage();
  430. }
  433. ILuint DecodePixelFormat(ILuint *CompFormat)
  434. {
  435. ILuint BlockSize;
  437. if (Head.Flags2 & DDS_FOURCC) {
  438. BlockSize = ((Head.Width + 3)/4) * ((Head.Height + 3)/4) * Head.Depth;
  439. switch (Head.FourCC)
  440. {
  441. case IL_MAKEFOURCC('D','X','T','1'):
  442. *CompFormat = PF_DXT1;
  443. BlockSize *= 8;
  444. break;
  446. case IL_MAKEFOURCC('D','X','T','2'):
  447. *CompFormat = PF_DXT2;
  448. BlockSize *= 16;
  449. break;
  451. case IL_MAKEFOURCC('D','X','T','3'):
  452. *CompFormat = PF_DXT3;
  453. BlockSize *= 16;
  454. break;
  456. case IL_MAKEFOURCC('D','X','T','4'):
  457. *CompFormat = PF_DXT4;
  458. BlockSize *= 16;
  459. break;
  461. case IL_MAKEFOURCC('D','X','T','5'):
  462. *CompFormat = PF_DXT5;
  463. BlockSize *= 16;
  464. break;
  466. case IL_MAKEFOURCC('A', 'T', 'I', '1'):
  467. *CompFormat = PF_ATI1N;
  468. BlockSize *= 8;
  469. break;
  471. case IL_MAKEFOURCC('A', 'T', 'I', '2'):
  472. *CompFormat = PF_3DC;
  473. BlockSize *= 16;
  474. break;
  476. case IL_MAKEFOURCC('R', 'X', 'G', 'B'):
  477. *CompFormat = PF_RXGB;
  478. BlockSize *= 16;
  479. break;
  481. case IL_MAKEFOURCC('$', '', '', ''):
  482. *CompFormat = PF_A16B16G16R16;
  483. BlockSize = Head.Width * Head.Height * Head.Depth * 8;
  484. break;
  486. case IL_MAKEFOURCC('o', '', '', ''):
  487. *CompFormat = PF_R16F;
  488. BlockSize = Head.Width * Head.Height * Head.Depth * 2;
  489. break;
  491. case IL_MAKEFOURCC('p', '', '', ''):
  492. *CompFormat = PF_G16R16F;
  493. BlockSize = Head.Width * Head.Height * Head.Depth * 4;
  494. break;
  496. case IL_MAKEFOURCC('q', '', '', ''):
  497. *CompFormat = PF_A16B16G16R16F;
  498. BlockSize = Head.Width * Head.Height * Head.Depth * 8;
  499. break;
  501. case IL_MAKEFOURCC('r', '', '', ''):
  502. *CompFormat = PF_R32F;
  503. BlockSize = Head.Width * Head.Height * Head.Depth * 4;
  504. break;
  506. case IL_MAKEFOURCC('s', '', '', ''):
  507. *CompFormat = PF_G32R32F;
  508. BlockSize = Head.Width * Head.Height * Head.Depth * 8;
  509. break;
  511. case IL_MAKEFOURCC('t', '', '', ''):
  512. *CompFormat = PF_A32B32G32R32F;
  513. BlockSize = Head.Width * Head.Height * Head.Depth * 16;
  514. break;
  516. default:
  517. *CompFormat = PF_UNKNOWN;
  518. BlockSize *= 16;
  519. break;
  520. }
  521. } else {
  522. // This dds texture isn't compressed so write out ARGB or luminance format
  523. if (Head.Flags2 & DDS_LUMINANCE) {
  524. if (Head.Flags2 & DDS_ALPHAPIXELS) {
  525. *CompFormat = PF_LUMINANCE_ALPHA;
  526. } else {
  527. *CompFormat = PF_LUMINANCE;
  528. }
  529. }
  530. else {
  531. if (Head.Flags2 & DDS_ALPHAPIXELS) {
  532. *CompFormat = PF_ARGB;
  533. } else {
  534. *CompFormat = PF_RGB;
  535. }
  536. }
  537. BlockSize = (Head.Width * Head.Height * Head.Depth * (Head.RGBBitCount >> 3));
  538. }
  540. return BlockSize;
  541. }
  544. // The few volume textures that I have don't have consistent LinearSize
  545. // entries, even though the DDS_LINEARSIZE flag is set.
  546. void AdjustVolumeTexture(DDSHEAD *Head, ILuint CompFormat)
  547. {
  548. if (Head->Depth <= 1)
  549. return;
  551. // All volume textures I've seem so far didn't have the DDS_COMPLEX flag set,
  552. // even though this is normally required. But because noone does set it,
  553. // also read images without it (TODO: check file size for 3d texture?)
  554. if (/*!(Head->ddsCaps1 & DDS_COMPLEX) ||*/ !(Head->ddsCaps2 & DDS_VOLUME)) {
  555. Head->Depth = 1;
  556. Depth = 1;
  557. }
  559. switch (CompFormat)
  560. {
  561. case PF_ARGB:
  562. case PF_RGB:
  563. case PF_LUMINANCE:
  564. case PF_LUMINANCE_ALPHA:
  565. //don't use the iCompFormatToBpp() function because this way
  566. //argb images with only 8 bits (eg. a1r2g3b2) work as well
  567. Head->LinearSize = IL_MAX(1,Head->Width) * IL_MAX(1,Head->Height) *
  568. (Head->RGBBitCount / 8);
  569. break;
  571. case PF_DXT1:
  573. case PF_ATI1N:
  574. Head->LinearSize = ((Head->Width+3)/4) * ((Head->Height+3)/4) * 8;
  575. break;
  577. case PF_DXT2:
  578. case PF_DXT3:
  579. case PF_DXT4:
  580. case PF_DXT5:
  581. case PF_3DC:
  582. case PF_RXGB:
  583. Head->LinearSize = ((Head->Width+3)/4) * ((Head->Height+3)/4) * 16;
  584. break;
  586. case PF_A16B16G16R16:
  587. case PF_R16F:
  588. case PF_G16R16F:
  589. case PF_A16B16G16R16F:
  590. case PF_R32F:
  591. case PF_G32R32F:
  592. case PF_A32B32G32R32F:
  593. Head->LinearSize = IL_MAX(1,Head->Width) * IL_MAX(1,Head->Height) *
  594. iCompFormatToBpp(CompFormat);
  595. break;
  596. }
  598. Head->Flags1 |= DDS_LINEARSIZE;
  599. Head->LinearSize *= Head->Depth;
  601. return;
  602. }
  605. // Reads the compressed data
  606. ILboolean ReadData()
  607. {
  608. ILuint Bps;
  609. ILint y, z;
  610. ILubyte *Temp;
  612. if (CompData) {
  613. ifree(CompData);
  614. CompData = NULL;
  615. }
  617. if (Head.Flags1 & DDS_LINEARSIZE) {
  618. //Head.LinearSize = Head.LinearSize * Depth;
  620. CompData = (ILubyte*)ialloc(Head.LinearSize);
  621. if (CompData == NULL) {
  622. return IL_FALSE;
  623. }
  625. if (iread(CompData, 1, Head.LinearSize) != (ILuint)Head.LinearSize) {
  626. ifree(CompData);
  627. CompData = NULL;
  628. return IL_FALSE;
  629. }
  630. }
  631. else {
  632. Bps = Width * Head.RGBBitCount / 8;
  633. CompSize = Bps * Height * Depth;
  635. CompData = (ILubyte*)ialloc(CompSize);
  636. if (CompData == NULL) {
  637. return IL_FALSE;
  638. }
  640. Temp = CompData;
  641. for (z = 0; z < Depth; z++) {
  642. for (y = 0; y < Height; y++) {
  643. if (iread(Temp, 1, Bps) != Bps) {
  644. ifree(CompData);
  645. CompData = NULL;
  646. return IL_FALSE;
  647. }
  648. Temp += Bps;
  649. }
  650. }
  651. }
  653. return IL_TRUE;
  654. }
  657. ILboolean AllocImage(ILuint CompFormat)
  658. {
  659. ILubyte channels = 4;
  660. ILenum format = IL_RGBA;
  662. switch (CompFormat)
  663. {
  664. case PF_RGB:
  665. if (!ilTexImage(Width, Height, Depth, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL))
  666. return IL_FALSE;
  667. break;
  668. case PF_ARGB:
  669. if (!ilTexImage(Width, Height, Depth, 4, IL_RGBA, IL_UNSIGNED_BYTE, NULL))
  670. return IL_FALSE;
  671. break;
  673. case PF_LUMINANCE:
  674. if(Head.RGBBitCount == 16 && Head.RBitMask == 0xFFFF) { //HACK
  675. if (!ilTexImage(Width, Height, Depth, 1, IL_LUMINANCE, IL_UNSIGNED_SHORT, NULL))
  676. return IL_FALSE;
  677. }
  678. else
  679. if (!ilTexImage(Width, Height, Depth, 1, IL_LUMINANCE, IL_UNSIGNED_BYTE, NULL))
  680. return IL_FALSE;
  681. break;
  683. case PF_LUMINANCE_ALPHA:
  684. if (!ilTexImage(Width, Height, Depth, 2, IL_LUMINANCE_ALPHA, IL_UNSIGNED_BYTE, NULL))
  685. return IL_FALSE;
  686. break;
  688. case PF_ATI1N:
  689. //right now there's no OpenGL api to use the compressed 3dc data, so
  690. //throw it away (I don't know how DirectX works, though)?
  691. if (!ilTexImage(Width, Height, Depth, 1, IL_LUMINANCE, IL_UNSIGNED_BYTE, NULL))
  692. return IL_FALSE;
  693. break;
  695. case PF_3DC:
  696. //right now there's no OpenGL api to use the compressed 3dc data, so
  697. //throw it away (I don't know how DirectX works, though)?
  698. if (!ilTexImage(Width, Height, Depth, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL))
  699. return IL_FALSE;
  700. break;
  702. case PF_A16B16G16R16:
  703. if (!ilTexImage(Width, Height, Depth, iCompFormatToChannelCount(CompFormat),
  704. ilGetFormatBpp(iCompFormatToChannelCount(CompFormat)), IL_UNSIGNED_SHORT, NULL))
  705. return IL_FALSE;
  706. break;
  708. case PF_R16F:
  709. case PF_G16R16F:
  710. case PF_A16B16G16R16F:
  711. case PF_R32F:
  712. case PF_G32R32F:
  713. case PF_A32B32G32R32F:
  714. if (!ilTexImage(Width, Height, Depth, iCompFormatToChannelCount(CompFormat),
  715. ilGetFormatBpp(iCompFormatToChannelCount(CompFormat)), IL_FLOAT, NULL))
  716. return IL_FALSE;
  717. break;
  719. default:
  720. if (CompFormat == PF_RXGB) {
  721. channels = 3; //normal map
  722. format = IL_RGB;
  723. }
  725. if (!ilTexImage(Width, Height, Depth, channels, format, IL_UNSIGNED_BYTE, NULL))
  726. return IL_FALSE;
  727. if (ilGetInteger(IL_KEEP_DXTC_DATA) == IL_TRUE && CompData) {
  728. iCurImage->DxtcData = (ILubyte*)ialloc(Head.LinearSize);
  729. if (iCurImage->DxtcData == NULL)
  730. return IL_FALSE;
  731. iCurImage->DxtcFormat = CompFormat - PF_DXT1 + IL_DXT1;
  732. iCurImage->DxtcSize = Head.LinearSize;
  733. memcpy(iCurImage->DxtcData, CompData, iCurImage->DxtcSize);
  734. }
  735. break;
  736. }
  738. Image->Origin = IL_ORIGIN_UPPER_LEFT;
  740. return IL_TRUE;
  741. }
  744. /*
  745.  * Assumes that the global variable CompFormat stores the format of the
  746.  * global pointer CompData (that's the pointer to the compressed data).
  747.  * Decompresses this data into Image->Data, returns if it was successful.
  748.  * It also uses the globals Width and Height.
  749.  *
  750.  * Assumes that iCurImage has valid Width, Height, Depth, Data, SizeOfData,
  751.  * Bpp, Bpc, Bps, SizeOfPlane, Format and Type fields. It is more or
  752.  * less assumed that the image has u8 rgba data (perhaps not for float
  753.  * images...)
  754.  *
  755.  *
  756.  * @TODO: don't use globals, clean this function (and this file) up
  757.  */
  758. ILboolean DdsDecompress(ILuint CompFormat)
  759. {
  760. switch (CompFormat)
  761. {
  762. case PF_ARGB:
  763. case PF_RGB:
  764. case PF_LUMINANCE:
  765. case PF_LUMINANCE_ALPHA:
  766. return DecompressARGB();
  768. case PF_DXT1:
  769. return DecompressDXT1(Image, CompData);
  771. case PF_DXT2:
  772. return DecompressDXT2(Image, CompData);
  774. case PF_DXT3:
  775. return DecompressDXT3(Image, CompData);
  777. case PF_DXT4:
  778. return DecompressDXT4(Image, CompData);
  780. case PF_DXT5:
  781. return DecompressDXT5(Image, CompData);
  783. case PF_ATI1N:
  784. return DecompressAti1n();
  786. case PF_3DC:
  787. return Decompress3Dc();
  789. case PF_RXGB:
  790. return DecompressRXGB();
  792. case PF_A16B16G16R16:
  793. memcpy(Image->Data, CompData, Image->SizeOfData);
  794. return IL_TRUE;
  796. case PF_R16F:
  797. case PF_G16R16F:
  798. case PF_A16B16G16R16F:
  799. case PF_R32F:
  800. case PF_G32R32F:
  801. case PF_A32B32G32R32F:
  802. return DecompressFloat(CompFormat);
  804. case PF_UNKNOWN:
  805. return IL_FALSE;
  806. }
  808. return IL_FALSE;
  809. }
  812. ILboolean ReadMipmaps(ILuint CompFormat)
  813. {
  814. ILuint i, CompFactor=0;
  815. ILubyte Bpp, Channels, Bpc;
  816. ILimage *StartImage, *TempImage;
  817. ILuint LastLinear;
  818. ILuint minW, minH;
  820. ILboolean isCompressed = IL_FALSE;
  822. Bpp = iCompFormatToBpp(CompFormat);
  823. Channels = iCompFormatToChannelCount(CompFormat);
  824. Bpc = iCompFormatToBpc(CompFormat);
  825. if (CompFormat == PF_LUMINANCE && Head.RGBBitCount == 16 && Head.RBitMask == 0xFFFF) { //HACK
  826. Bpc = 2; Bpp = 2;
  827. }
  829. //This doesn't work for images which first mipmap (= the image
  830. //itself) has width or height < 4
  831. //if (Head.Flags1 & DDS_LINEARSIZE) {
  832. // CompFactor = (Width * Height * Depth * Bpp) / Head.LinearSize;
  833. //}
  834. switch (CompFormat)
  835. {
  836. case PF_DXT1:
  837. //This is officially 6, we have 8 here because DXT1 may contain alpha
  838. CompFactor = 8;
  839. break;
  840. case PF_DXT2:
  841. case PF_DXT3:
  842. case PF_DXT4:
  843. case PF_DXT5:
  844. CompFactor = 4;
  845. break;
  846. case PF_RXGB:
  847. case PF_3DC:
  848. //This is officially 4 for 3dc, but that's bullshit :) There's no
  849. //alpha data in 3dc images
  850. CompFactor = 3;
  851. break;
  853. case PF_ATI1N:
  854. CompFactor = 2;
  855. break;
  856. default:
  857. CompFactor = 1;
  858. }
  860. StartImage = Image;
  862. if (!(Head.Flags1 & DDS_MIPMAPCOUNT) || Head.MipMapCount == 0) {
  863. //some .dds-files have their mipmap flag set,
  864. //but a mipmapcount of 0. Because mipMapCount is an uint, 0 - 1 gives
  865. //overflow - don't let this happen:
  866. Head.MipMapCount = 1;
  867. }
  869. LastLinear = Head.LinearSize;
  870. for (i = 0; i < Head.MipMapCount - 1; i++) {
  871. Depth = Depth / 2;
  872. Width = Width / 2;
  873. Height = Height / 2;
  875. if (Depth == 0) 
  876. Depth = 1;
  877. if (Width == 0) 
  878. Width = 1;
  879. if (Height == 0) 
  880. Height = 1;
  882. Image->Mipmaps = ilNewImage(Width, Height, Depth, Channels, Bpc);
  883. if (Image->Mipmaps == NULL)
  884. goto mip_fail;
  885. Image = Image->Mipmaps;
  886. Image->Origin = IL_ORIGIN_UPPER_LEFT;
  888. if (Head.Flags1 & DDS_LINEARSIZE) {
  889. if (CompFormat == PF_R16F
  890. || CompFormat == PF_G16R16F
  891. || CompFormat == PF_A16B16G16R16F
  892. || CompFormat == PF_R32F
  893. || CompFormat == PF_G32R32F
  894. || CompFormat == PF_A32B32G32R32F) {
  895. Head.LinearSize = Width * Height * Depth * Bpp;
  897. //DevIL's format autodetection doesn't work for
  898. //float images...correct this
  899. Image->Type = IL_FLOAT;
  900. Image->Bpp = Channels;
  901. }
  902. else if (CompFormat == PF_A16B16G16R16)
  903. Head.LinearSize = Width * Height * Depth * Bpp;
  904. else if (CompFormat != PF_RGB && CompFormat != PF_ARGB
  905. && CompFormat != PF_LUMINANCE
  906. && CompFormat != PF_LUMINANCE_ALPHA) {
  908. //compressed format
  909. minW = (((Width+3)/4))*4;
  910. minH = (((Height+3)/4))*4;
  911. Head.LinearSize = (minW * minH * Depth * Bpp) / CompFactor;
  913. isCompressed = IL_TRUE;
  914. }
  915. else {
  916. //don't use Bpp to support argb images with less than 32 bits
  917. Head.LinearSize = Width * Height * Depth * (Head.RGBBitCount >> 3);
  918. }
  919. }
  920. else {
  921. Head.LinearSize >>= 1;
  922. }
  924. if (!ReadData())
  925. goto mip_fail;
  927. if (ilGetInteger(IL_KEEP_DXTC_DATA) == IL_TRUE && isCompressed == IL_TRUE && CompData) {
  928. Image->DxtcData = (ILubyte*)ialloc(Head.LinearSize);
  929. if (Image->DxtcData == NULL)
  930. return IL_FALSE;
  931. Image->DxtcFormat = CompFormat - PF_DXT1 + IL_DXT1;
  932. Image->DxtcSize = Head.LinearSize;
  933. memcpy(Image->DxtcData, CompData, Image->DxtcSize);
  934. }
  936. if (!DdsDecompress(CompFormat))
  937. goto mip_fail;
  938. }
  940. Head.LinearSize = LastLinear;
  941. Image = StartImage;
  943. return IL_TRUE;
  945. mip_fail:
  946. Image = StartImage;
  947. StartImage = StartImage->Mipmaps;
  948. while (StartImage) {
  949. TempImage = StartImage;
  950. StartImage = StartImage->Mipmaps;
  951. ifree(TempImage);
  952. }
  954. Image->Mipmaps = NULL;
  955. return IL_FALSE;
  956. }
  959. void DxtcReadColors(const ILubyte* Data, Color8888* Out)
  960. {
  961. ILubyte r0, g0, b0, r1, g1, b1;
  963. b0 = Data[0] & 0x1F;
  964. g0 = ((Data[0] & 0xE0) >> 5) | ((Data[1] & 0x7) << 3);
  965. r0 = (Data[1] & 0xF8) >> 3;
  967. b1 = Data[2] & 0x1F;
  968. g1 = ((Data[2] & 0xE0) >> 5) | ((Data[3] & 0x7) << 3);
  969. r1 = (Data[3] & 0xF8) >> 3;
  971. Out[0].r = r0 << 3 | r0 >> 2;
  972. Out[0].g = g0 << 2 | g0 >> 3;
  973. Out[0].b = b0 << 3 | b0 >> 2;
  975. Out[1].r = r1 << 3 | r1 >> 2;
  976. Out[1].g = g1 << 2 | g1 >> 3;
  977. Out[1].b = b1 << 3 | b1 >> 2;
  978. }
  980. //@TODO: Probably not safe on Big Endian.
  981. void DxtcReadColor(ILushort Data, Color8888* Out)
  982. {
  983. ILubyte r, g, b;
  985. b = Data & 0x1f;
  986. g = (Data & 0x7E0) >> 5;
  987. r = (Data & 0xF800) >> 11;
  989. Out->r = r << 3 | r >> 2;
  990. Out->g = g << 2 | g >> 3;
  991. Out->b = b << 3 | r >> 2;
  992. }
  994. ILboolean DecompressDXT1(ILimage *lImage, ILubyte *lCompData)
  995. {
  996. ILuint x, y, z, i, j, k, Select;
  997. ILubyte *Temp;
  998. Color8888 colours[4], *col;
  999. ILushort color_0, color_1;
  1000. ILuint bitmask, Offset;
  1002. if (!lCompData)
  1003. return IL_FALSE;
  1005. Temp = lCompData;
  1006. colours[0].a = 0xFF;
  1007. colours[1].a = 0xFF;
  1008. colours[2].a = 0xFF;
  1009. //colours[3].a = 0xFF;
  1010. for (z = 0; z < lImage->Depth; z++) {
  1011. for (y = 0; y < lImage->Height; y += 4) {
  1012. for (x = 0; x < lImage->Width; x += 4) {
  1013. color_0 = *((ILushort*)Temp);
  1014. UShort(&color_0);
  1015. color_1 = *((ILushort*)(Temp + 2));
  1016. UShort(&color_1);
  1017. DxtcReadColor(color_0, colours);
  1018. DxtcReadColor(color_1, colours + 1);
  1019. bitmask = ((ILuint*)Temp)[1];
  1020. UInt(&bitmask);
  1021. Temp += 8;
  1023. if (color_0 > color_1) {
  1024. // Four-color block: derive the other two colors.
  1025. // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
  1026. // These 2-bit codes correspond to the 2-bit fields 
  1027. // stored in the 64-bit block.
  1028. colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
  1029. colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
  1030. colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
  1031. //colours[2].a = 0xFF;
  1033. colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
  1034. colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
  1035. colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
  1036. colours[3].a = 0xFF;
  1037. }
  1038. else { 
  1039. // Three-color block: derive the other color.
  1040. // 00 = color_0,  01 = color_1,  10 = color_2,
  1041. // 11 = transparent.
  1042. // These 2-bit codes correspond to the 2-bit fields 
  1043. // stored in the 64-bit block. 
  1044. colours[2].b = (colours[0].b + colours[1].b) / 2;
  1045. colours[2].g = (colours[0].g + colours[1].g) / 2;
  1046. colours[2].r = (colours[0].r + colours[1].r) / 2;
  1047. //colours[2].a = 0xFF;
  1049. colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
  1050. colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
  1051. colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
  1052. colours[3].a = 0x00;
  1053. }
  1055. for (j = 0, k = 0; j < 4; j++) {
  1056. for (i = 0; i < 4; i++, k++) {
  1057. Select = (bitmask & (0x03 << k*2)) >> k*2;
  1058. col = &colours[Select];
  1060. if (((x + i) < lImage->Width) && ((y + j) < lImage->Height)) {
  1061. Offset = z * lImage->SizeOfPlane + (y + j) * lImage->Bps + (x + i) * lImage->Bpp;
  1062. lImage->Data[Offset + 0] = col->r;
  1063. lImage->Data[Offset + 1] = col->g;
  1064. lImage->Data[Offset + 2] = col->b;
  1065. lImage->Data[Offset + 3] = col->a;
  1066. }
  1067. }
  1068. }
  1069. }
  1070. }
  1071. }
  1073. return IL_TRUE;
  1074. }
  1077. ILboolean DecompressDXT2(ILimage *lImage, ILubyte *lCompData)
  1078. {
  1079. // Can do color & alpha same as dxt3, but color is pre-multiplied 
  1080. //   so the result will be wrong unless corrected. 
  1081. if (!DecompressDXT3(Image, CompData))
  1082. return IL_FALSE;
  1083. CorrectPreMult();
  1085. return IL_TRUE;
  1086. }
  1089. ILboolean DecompressDXT3(ILimage *lImage, ILubyte *lCompData)
  1090. {
  1091. ILuint x, y, z, i, j, k, Select;
  1092. ILubyte *Temp;
  1093. //Color565 *color_0, *color_1;
  1094. Color8888 colours[4], *col;
  1095. ILuint bitmask, Offset;
  1096. ILushort word;
  1097. ILubyte *alpha;
  1099. if (!lCompData)
  1100. return IL_FALSE;
  1102. Temp = lCompData;
  1103. for (z = 0; z < lImage->Depth; z++) {
  1104. for (y = 0; y < lImage->Height; y += 4) {
  1105. for (x = 0; x < lImage->Width; x += 4) {
  1106. alpha = Temp;
  1107. Temp += 8;
  1108. DxtcReadColors(Temp, colours);
  1109. bitmask = ((ILuint*)Temp)[1];
  1110. UInt(&bitmask);
  1111. Temp += 8;
  1113. // Four-color block: derive the other two colors.    
  1114. // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
  1115. // These 2-bit codes correspond to the 2-bit fields 
  1116. // stored in the 64-bit block.
  1117. colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
  1118. colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
  1119. colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
  1120. //colours[2].a = 0xFF;
  1122. colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
  1123. colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
  1124. colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
  1125. //colours[3].a = 0xFF;
  1127. k = 0;
  1128. for (j = 0; j < 4; j++) {
  1129. for (i = 0; i < 4; i++, k++) {
  1130. Select = (bitmask & (0x03 << k*2)) >> k*2;
  1131. col = &colours[Select];
  1133. if (((x + i) < lImage->Width) && ((y + j) < lImage->Height)) {
  1134. Offset = z * lImage->SizeOfPlane + (y + j) * lImage->Bps + (x + i) * lImage->Bpp;
  1135. lImage->Data[Offset + 0] = col->r;
  1136. lImage->Data[Offset + 1] = col->g;
  1137. lImage->Data[Offset + 2] = col->b;
  1138. }
  1139. }
  1140. }
  1142. for (j = 0; j < 4; j++) {
  1143. word = alpha[2*j] + 256*alpha[2*j+1];
  1144. for (i = 0; i < 4; i++) {
  1145. if (((x + i) < lImage->Width) && ((y + j) < lImage->Height)) {
  1146. Offset = z * lImage->SizeOfPlane + (y + j) * lImage->Bps + (x + i) * lImage->Bpp + 3;
  1147. lImage->Data[Offset] = word & 0x0F;
  1148. lImage->Data[Offset] = lImage->Data[Offset] | (lImage->Data[Offset] << 4);
  1149. }
  1150. word >>= 4;
  1151. }
  1152. }
  1154. }
  1155. }
  1156. }
  1158. return IL_TRUE;
  1159. }
  1162. ILboolean DecompressDXT4(ILimage *lImage, ILubyte *lCompData)
  1163. {
  1164. // Can do color & alpha same as dxt5, but color is pre-multiplied 
  1165. //   so the result will be wrong unless corrected. 
  1166. if (!DecompressDXT5(Image, CompData))
  1167. return IL_FALSE;
  1168. CorrectPreMult();
  1170. return IL_FALSE;
  1171. }
  1174. ILboolean DecompressDXT5(ILimage *lImage, ILubyte *lCompData)
  1175. {
  1176. ILuint x, y, z, i, j, k, Select;
  1177. ILubyte *Temp; //, r0, g0, b0, r1, g1, b1;
  1178. Color8888 colours[4], *col;
  1179. ILuint bitmask, Offset;
  1180. ILubyte alphas[8], *alphamask;
  1181. ILuint bits;
  1183. if (!lCompData)
  1184. return IL_FALSE;
  1186. Temp = lCompData;
  1187. for (z = 0; z < lImage->Depth; z++) {
  1188. for (y = 0; y < lImage->Height; y += 4) {
  1189. for (x = 0; x < lImage->Width; x += 4) {
  1190. if (y >= lImage->Height || x >= lImage->Width)
  1191. break;
  1192. alphas[0] = Temp[0];
  1193. alphas[1] = Temp[1];
  1194. alphamask = Temp + 2;
  1195. Temp += 8;
  1197. DxtcReadColors(Temp, colours);
  1198. bitmask = ((ILuint*)Temp)[1];
  1199. UInt(&bitmask);
  1200. Temp += 8;
  1202. // Four-color block: derive the other two colors.    
  1203. // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
  1204. // These 2-bit codes correspond to the 2-bit fields 
  1205. // stored in the 64-bit block.
  1206. colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
  1207. colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
  1208. colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
  1209. //colours[2].a = 0xFF;
  1211. colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
  1212. colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
  1213. colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
  1214. //colours[3].a = 0xFF;
  1216. k = 0;
  1217. for (j = 0; j < 4; j++) {
  1218. for (i = 0; i < 4; i++, k++) {
  1220. Select = (bitmask & (0x03 << k*2)) >> k*2;
  1221. col = &colours[Select];
  1223. // only put pixels out < width or height
  1224. if (((x + i) < lImage->Width) && ((y + j) < lImage->Height)) {
  1225. Offset = z * lImage->SizeOfPlane + (y + j) * lImage->Bps + (x + i) * lImage->Bpp;
  1226. lImage->Data[Offset + 0] = col->r;
  1227. lImage->Data[Offset + 1] = col->g;
  1228. lImage->Data[Offset + 2] = col->b;
  1229. }
  1230. }
  1231. }
  1233. // 8-alpha or 6-alpha block?    
  1234. if (alphas[0] > alphas[1]) {    
  1235. // 8-alpha block:  derive the other six alphas.    
  1236. // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
  1237. alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010
  1238. alphas[3] = (5 * alphas[0] + 2 * alphas[1] + 3) / 7; // bit code 011
  1239. alphas[4] = (4 * alphas[0] + 3 * alphas[1] + 3) / 7; // bit code 100
  1240. alphas[5] = (3 * alphas[0] + 4 * alphas[1] + 3) / 7; // bit code 101
  1241. alphas[6] = (2 * alphas[0] + 5 * alphas[1] + 3) / 7; // bit code 110
  1242. alphas[7] = (1 * alphas[0] + 6 * alphas[1] + 3) / 7; // bit code 111
  1243. }
  1244. else {
  1245. // 6-alpha block.
  1246. // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
  1247. alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // Bit code 010
  1248. alphas[3] = (3 * alphas[0] + 2 * alphas[1] + 2) / 5; // Bit code 011
  1249. alphas[4] = (2 * alphas[0] + 3 * alphas[1] + 2) / 5; // Bit code 100
  1250. alphas[5] = (1 * alphas[0] + 4 * alphas[1] + 2) / 5; // Bit code 101
  1251. alphas[6] = 0x00; // Bit code 110
  1252. alphas[7] = 0xFF; // Bit code 111
  1253. }
  1255. // Note: Have to separate the next two loops,
  1256. // it operates on a 6-byte system.
  1258. // First three bytes
  1259. //bits = *((ILint*)alphamask);
  1260. bits = (alphamask[0]) | (alphamask[1] << 8) | (alphamask[2] << 16);
  1261. for (j = 0; j < 2; j++) {
  1262. for (i = 0; i < 4; i++) {
  1263. // only put pixels out < width or height
  1264. if (((x + i) < lImage->Width) && ((y + j) < lImage->Height)) {
  1265. Offset = z * lImage->SizeOfPlane + (y + j) * lImage->Bps + (x + i) * lImage->Bpp + 3;
  1266. lImage->Data[Offset] = alphas[bits & 0x07];
  1267. }
  1268. bits >>= 3;
  1269. }
  1270. }
  1272. // Last three bytes
  1273. //bits = *((ILint*)&alphamask[3]);
  1274. bits = (alphamask[3]) | (alphamask[4] << 8) | (alphamask[5] << 16);
  1275. for (j = 2; j < 4; j++) {
  1276. for (i = 0; i < 4; i++) {
  1277. // only put pixels out < width or height
  1278. if (((x + i) < lImage->Width) && ((y + j) < lImage->Height)) {
  1279. Offset = z * lImage->SizeOfPlane + (y + j) * lImage->Bps + (x + i) * lImage->Bpp + 3;
  1280. lImage->Data[Offset] = alphas[bits & 0x07];
  1281. }
  1282. bits >>= 3;
  1283. }
  1284. }
  1285. }
  1286. }
  1287. }
  1289. return IL_TRUE;
  1290. }
  1293. ILboolean Decompress3Dc()
  1294. {
  1295. int x, y, z, i, j, k, t1, t2;
  1296. ILubyte *Temp, *Temp2;
  1297. ILubyte XColours[8], YColours[8];
  1298. ILuint bitmask, bitmask2, Offset, CurrOffset;
  1300. if (!CompData)
  1301. return IL_FALSE;
  1303. Temp = CompData;
  1304. Offset = 0;
  1305. for (z = 0; z < Depth; z++) {
  1306. for (y = 0; y < Height; y += 4) {
  1307. for (x = 0; x < Width; x += 4) {
  1308. Temp2 = Temp + 8;
  1310. //Read Y palette
  1311. t1 = YColours[0] = Temp[0];
  1312. t2 = YColours[1] = Temp[1];
  1313. Temp += 2;
  1314. if (t1 > t2)
  1315. for (i = 2; i < 8; ++i)
  1316. YColours[i] = t1 + ((t2 - t1)*(i - 1))/7;
  1317. else {
  1318. for (i = 2; i < 6; ++i)
  1319. YColours[i] = t1 + ((t2 - t1)*(i - 1))/5;
  1320. YColours[6] = 0;
  1321. YColours[7] = 255;
  1322. }
  1324. // Read X palette
  1325. t1 = XColours[0] = Temp2[0];
  1326. t2 = XColours[1] = Temp2[1];
  1327. Temp2 += 2;
  1328. if (t1 > t2)
  1329. for (i = 2; i < 8; ++i)
  1330. XColours[i] = t1 + ((t2 - t1)*(i - 1))/7;
  1331. else {
  1332. for (i = 2; i < 6; ++i)
  1333. XColours[i] = t1 + ((t2 - t1)*(i - 1))/5;
  1334. XColours[6] = 0;
  1335. XColours[7] = 255;
  1336. }
  1338. //decompress pixel data
  1339. CurrOffset = Offset;
  1340. for (k = 0; k < 4; k += 2) {
  1341. // First three bytes
  1342. bitmask = ((ILuint)(Temp[0]) << 0) | ((ILuint)(Temp[1]) << 8) | ((ILuint)(Temp[2]) << 16);
  1343. bitmask2 = ((ILuint)(Temp2[0]) << 0) | ((ILuint)(Temp2[1]) << 8) | ((ILuint)(Temp2[2]) << 16);
  1344. for (j = 0; j < 2; j++) {
  1345. // only put pixels out < height
  1346. if ((y + k + j) < Height) {
  1347. for (i = 0; i < 4; i++) {
  1348. // only put pixels out < width
  1349. if (((x + i) < Width)) {
  1350. ILint t, tx, ty;
  1352. t1 = CurrOffset + (x + i)*3;
  1353. Image->Data[t1 + 1] = ty = YColours[bitmask & 0x07];
  1354. Image->Data[t1 + 0] = tx = XColours[bitmask2 & 0x07];
  1356. //calculate b (z) component ((r/255)^2 + (g/255)^2 + (b/255)^2 = 1
  1357. t = 127*128 - (tx - 127)*(tx - 128) - (ty - 127)*(ty - 128);
  1358. if (t > 0)
  1359. Image->Data[t1 + 2] = (ILubyte)(iSqrt(t) + 128);
  1360. else
  1361. Image->Data[t1 + 2] = 0x7F;
  1362. }
  1363. bitmask >>= 3;
  1364. bitmask2 >>= 3;
  1365. }
  1366. CurrOffset += Image->Bps;
  1367. }
  1368. }
  1369. Temp += 3;
  1370. Temp2 += 3;
  1371. }
  1373. //skip bytes that were read via Temp2
  1374. Temp += 8;
  1375. }
  1376. Offset += Image->Bps*4;
  1377. }
  1378. }
  1380. return IL_TRUE;
  1381. }
  1384. ILboolean DecompressAti1n()
  1385. {
  1386. int x, y, z, i, j, k, t1, t2;
  1387. ILubyte *Temp;
  1388. ILubyte Colours[8];
  1389. ILuint bitmask, Offset, CurrOffset;
  1391. if (!CompData)
  1392. return IL_FALSE;
  1394. Temp = CompData;
  1395. Offset = 0;
  1396. for (z = 0; z < Depth; z++) {
  1397. for (y = 0; y < Height; y += 4) {
  1398. for (x = 0; x < Width; x += 4) {
  1399. //Read palette
  1400. t1 = Colours[0] = Temp[0];
  1401. t2 = Colours[1] = Temp[1];
  1402. Temp += 2;
  1403. if (t1 > t2)
  1404. for (i = 2; i < 8; ++i)
  1405. Colours[i] = t1 + ((t2 - t1)*(i - 1))/7;
  1406. else {
  1407. for (i = 2; i < 6; ++i)
  1408. Colours[i] = t1 + ((t2 - t1)*(i - 1))/5;
  1409. Colours[6] = 0;
  1410. Colours[7] = 255;
  1411. }
  1413. //decompress pixel data
  1414. CurrOffset = Offset;
  1415. for (k = 0; k < 4; k += 2) {
  1416. // First three bytes
  1417. bitmask = ((ILuint)(Temp[0]) << 0) | ((ILuint)(Temp[1]) << 8) | ((ILuint)(Temp[2]) << 16);
  1418. for (j = 0; j < 2; j++) {
  1419. // only put pixels out < height
  1420. if ((y + k + j) < Height) {
  1421. for (i = 0; i < 4; i++) {
  1422. // only put pixels out < width
  1423. if (((x + i) < Width)) {
  1424. t1 = CurrOffset + (x + i);
  1425. Image->Data[t1] = Colours[bitmask & 0x07];
  1426. }
  1427. bitmask >>= 3;
  1428. }
  1429. CurrOffset += Image->Bps;
  1430. }
  1431. }
  1432. Temp += 3;
  1433. }
  1434. }
  1435. Offset += Image->Bps*4;
  1436. }
  1437. }
  1439. return IL_TRUE;
  1440. }
  1443. //This is nearly exactly the same as DecompressDXT5...
  1444. //I have to clean up this file (put common code in
  1445. //helper functions etc)
  1446. ILboolean DecompressRXGB()
  1447. {
  1448. int x, y, z, i, j, k, Select;
  1449. ILubyte *Temp;
  1450. Color565 *color_0, *color_1;
  1451. Color8888 colours[4], *col;
  1452. ILuint bitmask, Offset;
  1453. ILubyte alphas[8], *alphamask;
  1454. ILuint bits;
  1456. if (!CompData)
  1457. return IL_FALSE;
  1459. Temp = CompData;
  1460. for (z = 0; z < Depth; z++) {
  1461. for (y = 0; y < Height; y += 4) {
  1462. for (x = 0; x < Width; x += 4) {
  1463. if (y >= Height || x >= Width)
  1464. break;
  1465. alphas[0] = Temp[0];
  1466. alphas[1] = Temp[1];
  1467. alphamask = Temp + 2;
  1468. Temp += 8;
  1469. color_0 = ((Color565*)Temp);
  1470. color_1 = ((Color565*)(Temp+2));
  1471. bitmask = ((ILuint*)Temp)[1];
  1472. Temp += 8;
  1474. colours[0].r = color_0->nRed << 3;
  1475. colours[0].g = color_0->nGreen << 2;
  1476. colours[0].b = color_0->nBlue << 3;
  1477. colours[0].a = 0xFF;
  1479. colours[1].r = color_1->nRed << 3;
  1480. colours[1].g = color_1->nGreen << 2;
  1481. colours[1].b = color_1->nBlue << 3;
  1482. colours[1].a = 0xFF;
  1484. // Four-color block: derive the other two colors.    
  1485. // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
  1486. // These 2-bit codes correspond to the 2-bit fields 
  1487. // stored in the 64-bit block.
  1488. colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
  1489. colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
  1490. colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
  1491. colours[2].a = 0xFF;
  1493. colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
  1494. colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
  1495. colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
  1496. colours[3].a = 0xFF;
  1498. k = 0;
  1499. for (j = 0; j < 4; j++) {
  1500. for (i = 0; i < 4; i++, k++) {
  1502. Select = (bitmask & (0x03 << k*2)) >> k*2;
  1503. col = &colours[Select];
  1505. // only put pixels out < width or height
  1506. if (((x + i) < Width) && ((y + j) < Height)) {
  1507. Offset = z * Image->SizeOfPlane + (y + j) * Image->Bps + (x + i) * Image->Bpp;
  1508. Image->Data[Offset + 0] = col->r;
  1509. Image->Data[Offset + 1] = col->g;
  1510. Image->Data[Offset + 2] = col->b;
  1511. }
  1512. }
  1513. }
  1515. // 8-alpha or 6-alpha block?    
  1516. if (alphas[0] > alphas[1]) {    
  1517. // 8-alpha block:  derive the other six alphas.    
  1518. // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
  1519. alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010
  1520. alphas[3] = (5 * alphas[0] + 2 * alphas[1] + 3) / 7; // bit code 011
  1521. alphas[4] = (4 * alphas[0] + 3 * alphas[1] + 3) / 7; // bit code 100
  1522. alphas[5] = (3 * alphas[0] + 4 * alphas[1] + 3) / 7; // bit code 101
  1523. alphas[6] = (2 * alphas[0] + 5 * alphas[1] + 3) / 7; // bit code 110
  1524. alphas[7] = (1 * alphas[0] + 6 * alphas[1] + 3) / 7; // bit code 111
  1525. }
  1526. else {
  1527. // 6-alpha block.
  1528. // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
  1529. alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // Bit code 010
  1530. alphas[3] = (3 * alphas[0] + 2 * alphas[1] + 2) / 5; // Bit code 011
  1531. alphas[4] = (2 * alphas[0] + 3 * alphas[1] + 2) / 5; // Bit code 100
  1532. alphas[5] = (1 * alphas[0] + 4 * alphas[1] + 2) / 5; // Bit code 101
  1533. alphas[6] = 0x00; // Bit code 110
  1534. alphas[7] = 0xFF; // Bit code 111
  1535. }
  1537. // Note: Have to separate the next two loops,
  1538. // it operates on a 6-byte system.
  1539. // First three bytes
  1540. bits = *((ILint*)alphamask);
  1541. for (j = 0; j < 2; j++) {
  1542. for (i = 0; i < 4; i++) {
  1543. // only put pixels out < width or height
  1544. if (((x + i) < Width) && ((y + j) < Height)) {
  1545. Offset = z * Image->SizeOfPlane + (y + j) * Image->Bps + (x + i) * Image->Bpp + 0;
  1546. Image->Data[Offset] = alphas[bits & 0x07];
  1547. }
  1548. bits >>= 3;
  1549. }
  1550. }
  1552. // Last three bytes
  1553. bits = *((ILint*)&alphamask[3]);
  1554. for (j = 2; j < 4; j++) {
  1555. for (i = 0; i < 4; i++) {
  1556. // only put pixels out < width or height
  1557. if (((x + i) < Width) && ((y + j) < Height)) {
  1558. Offset = z * Image->SizeOfPlane + (y + j) * Image->Bps + (x + i) * Image->Bpp + 0;
  1559. Image->Data[Offset] = alphas[bits & 0x07];
  1560. }
  1561. bits >>= 3;
  1562. }
  1563. }
  1564. }
  1565. }
  1566. }
  1568. return IL_TRUE;
  1569. }
  1572. //Taken from OpenEXR
  1573. unsigned int
  1574. halfToFloat (unsigned short y)
  1575. {
  1576. int s = (y >> 15) & 0x00000001;
  1577. int e = (y >> 10) & 0x0000001f;
  1578. int m =  y   & 0x000003ff;
  1580. if (e == 0)
  1581. {
  1582. if (m == 0)
  1583. {
  1584. //
  1585. // Plus or minus zero
  1586. //
  1587. return s << 31;
  1588. }
  1589. else
  1590. {
  1591. //
  1592. // Denormalized number -- renormalize it
  1593. //
  1594. while (!(m & 0x00000400))
  1595. {
  1596. m <<= 1;
  1597. e -=  1;
  1598. }
  1600. e += 1;
  1601. m &= ~0x00000400;
  1602. }
  1603. }
  1604. else if (e == 31)
  1605. {
  1606. if (m == 0)
  1607. {
  1608. //
  1609. // Positive or negative infinity
  1610. //
  1611. return (s << 31) | 0x7f800000;
  1612. }
  1613. else
  1614. {
  1615. //
  1616. // Nan -- preserve sign and significand bits
  1617. //
  1618. return (s << 31) | 0x7f800000 | (m << 13);
  1619. }
  1620. }
  1622. //
  1623. // Normalized number
  1624. //
  1625. e = e + (127 - 15);
  1626. m = m << 13;
  1628. //
  1629. // Assemble s, e and m.
  1630. //
  1631. return (s << 31) | (e << 23) | m;
  1632. }
  1635. ILboolean iConvFloat16ToFloat32(ILuint* dest, ILushort* src, ILuint size)
  1636. {
  1637. ILuint i;
  1638. for (i = 0; i < size; ++i, ++dest, ++src) {
  1639. //float: 1 sign bit, 8 exponent bits, 23 mantissa bits
  1640. //half: 1 sign bit, 5 exponent bits, 10 mantissa bits
  1641. *dest = halfToFloat(*src);
  1642. }
  1644. return IL_TRUE;
  1645. }
  1648. ILboolean DecompressFloat(ILuint lCompFormat)
  1649. {
  1650. switch (lCompFormat)
  1651. {
  1652. case PF_R32F:
  1653. case PF_G32R32F:
  1654. case PF_A32B32G32R32F:
  1655. memcpy(Image->Data, CompData, Image->SizeOfData);
  1656. return IL_TRUE;
  1657. case PF_R16F:
  1658. case PF_G16R16F:
  1659. case PF_A16B16G16R16F:
  1660. return iConvFloat16ToFloat32((ILuint*)Image->Data, (ILushort*)CompData,
  1661. Image->Width * Image->Height * Image->Depth * Image->Bpp);
  1662. default:
  1663. return IL_FALSE;
  1664. }
  1665. }
  1668. void CorrectPreMult()
  1669. {
  1670. ILuint i;
  1672. for (i = 0; i < Image->SizeOfData; i += 4) {
  1673. if (Image->Data[i+3] != 0) {  // Cannot divide by 0.
  1674. Image->Data[i]   = (ILubyte)(((ILuint)Image->Data[i]   << 8) / Image->Data[i+3]);
  1675. Image->Data[i+1] = (ILubyte)(((ILuint)Image->Data[i+1] << 8) / Image->Data[i+3]);
  1676. Image->Data[i+2] = (ILubyte)(((ILuint)Image->Data[i+2] << 8) / Image->Data[i+3]);
  1677. }
  1678. }
  1680. return;
  1681. }
  1684. ILboolean DecompressARGB(ILuint CompFormat) {
  1685. ILuint ReadI = 0, TempBpp, i;
  1686. ILuint RedL, RedR;
  1687. ILuint GreenL, GreenR;
  1688. ILuint BlueL, BlueR;
  1689. ILuint AlphaL, AlphaR;
  1690. ILubyte *Temp;
  1692. if (!CompData)
  1693. return IL_FALSE;
  1695. if (CompFormat == PF_LUMINANCE && Head.RGBBitCount == 16 && Head.RBitMask == 0xFFFF) { //HACK
  1696. memcpy(Image->Data, CompData, Image->SizeOfData);
  1697. return IL_TRUE;
  1698. }
  1700. GetBitsFromMask(Head.RBitMask, &RedL, &RedR);
  1701. GetBitsFromMask(Head.GBitMask, &GreenL, &GreenR);
  1702. GetBitsFromMask(Head.BBitMask, &BlueL, &BlueR);
  1703. GetBitsFromMask(Head.RGBAlphaBitMask, &AlphaL, &AlphaR);
  1704. Temp = CompData;
  1705. TempBpp = Head.RGBBitCount / 8;
  1707. for (i = 0; i < Image->SizeOfData; i += Image->Bpp) {
  1709. //@TODO: This is SLOOOW...
  1710. //but the old version crashed in release build under
  1711. //winxp (and xp is right to stop this code - I always
  1712. //wondered that it worked the old way at all)
  1713. if (Image->SizeOfData - i < 4) { //less than 4 byte to write?
  1714. if (TempBpp == 3) { //this branch is extra-SLOOOW
  1715. ReadI =
  1716. *Temp
  1717. | ((*(Temp + 1)) << 8)
  1718. | ((*(Temp + 2)) << 16);
  1719. }
  1720. else if (TempBpp == 1)
  1721. ReadI = *((ILubyte*)Temp);
  1722. else if (TempBpp == 2)
  1723. ReadI = Temp[0] | (Temp[1] << 8);
  1724. }
  1725. else
  1726. ReadI = Temp[0] | (Temp[1] << 8) | (Temp[2] << 16) | (Temp[3] << 24);
  1727. Temp += TempBpp;
  1729. Image->Data[i] = ((ReadI & Head.RBitMask) >> RedR) << RedL;
  1731. if(Image->Bpp >= 3) {
  1732. Image->Data[i+1] = ((ReadI & Head.GBitMask) >> GreenR) << GreenL;
  1733. Image->Data[i+2] = ((ReadI & Head.BBitMask) >> BlueR) << BlueL;
  1735. if (Image->Bpp == 4) {
  1736. Image->Data[i+3] = ((ReadI & Head.RGBAlphaBitMask) >> AlphaR) << AlphaL;
  1737. if (AlphaL >= 7) {
  1738. Image->Data[i+3] = Image->Data[i+3] ? 0xFF : 0x00;
  1739. }
  1740. else if (AlphaL >= 4) {
  1741. Image->Data[i+3] = Image->Data[i+3] | (Image->Data[i+3] >> 4);
  1742. }
  1743. }
  1744. }
  1745. else if (Image->Bpp == 2) {
  1746. Image->Data[i+1] = ((ReadI & Head.RGBAlphaBitMask) >> AlphaR) << AlphaL;
  1747. if (AlphaL >= 7) {
  1748. Image->Data[i+1] = Image->Data[i+1] ? 0xFF : 0x00;
  1749. }
  1750. else if (AlphaL >= 4) {
  1751. Image->Data[i+1] = Image->Data[i+1] | (Image->Data[i+3] >> 4);
  1752. }
  1753. }
  1754. }
  1756. return IL_TRUE;
  1757. }
  1760. // @TODO:  Look at using the BSF/BSR operands for inline ASM here.
  1761. void GetBitsFromMask(ILuint Mask, ILuint *ShiftLeft, ILuint *ShiftRight)
  1762. {
  1763. ILuint Temp, i;
  1765. if (Mask == 0) {
  1766. *ShiftLeft = *ShiftRight = 0;
  1767. return;
  1768. }
  1770. Temp = Mask;
  1771. for (i = 0; i < 32; i++, Temp >>= 1) {
  1772. if (Temp & 1)
  1773. break;
  1774. }
  1775. *ShiftRight = i;
  1777. // Temp is preserved, so use it again:
  1778. for (i = 0; i < 8; i++, Temp >>= 1) {
  1779. if (!(Temp & 1))
  1780. break;
  1781. }
  1782. *ShiftLeft = 8 - i;
  1784. return;
  1785. }
  1788. //
  1789. //
  1790. // DXT extension code
  1791. //
  1792. //
  1793. ILubyte* ILAPIENTRY ilGetDxtcData()
  1794. {
  1795. if (iCurImage == NULL) {
  1796. ilSetError(IL_INTERNAL_ERROR);
  1797. return NULL;
  1798. }
  1799. return iCurImage->DxtcData;
  1800. }
  1802. void ilFreeSurfaceDxtcData()
  1803. {
  1804. if (iCurImage != NULL && iCurImage->DxtcData != NULL) {
  1805. ifree(iCurImage->DxtcData);
  1806. iCurImage->DxtcData = NULL;
  1807. iCurImage->DxtcSize = 0;
  1808. iCurImage->DxtcFormat = IL_DXT_NO_COMP;
  1809. }
  1810. }
  1812. void ilFreeImageDxtcData()
  1813. {
  1814. ILint i, j;
  1815. ILuint ImgID = ilGetInteger(IL_CUR_IMAGE);
  1816. ILint ImgCount = ilGetInteger(IL_NUM_IMAGES);
  1817. ILint MipCount;
  1819. for(i = 0; i <= ImgCount; ++i) {
  1820. ilBindImage(ImgID);
  1821. ilActiveImage(i);
  1823. MipCount = ilGetInteger(IL_NUM_MIPMAPS);
  1824. for(j = 0; j <= MipCount; ++j) {
  1825. ilBindImage(ImgID);
  1826. ilActiveImage(i);
  1827. ilActiveMipmap(j);
  1829. ilFreeSurfaceDxtcData();
  1830. }
  1831. }
  1832. }
  1834. /*
  1835.  * This assumes DxtcData, DxtcFormat, width, height, and depth are valid
  1836.  */
  1837. ILAPI ILboolean ILAPIENTRY ilDxtcDataToSurface()
  1838. {
  1839. ILuint CompFormat;
  1841. if (iCurImage == NULL || iCurImage->DxtcData == NULL) {
  1842. ilSetError(IL_INVALID_PARAM);
  1843. return IL_FALSE;
  1844. }
  1846. if (!(iCurImage->DxtcFormat == IL_DXT1 || iCurImage->DxtcFormat == IL_DXT3
  1847. || iCurImage->DxtcFormat == IL_DXT5)) {
  1848. ilSetError(IL_INVALID_PARAM); //TODO
  1849. return IL_FALSE;
  1850. }
  1852. //@TODO: is this right for all dxt formats? works for
  1853. //  DXT1, 3, 5
  1854. iCurImage->Bpp = 4;
  1855. iCurImage->Bpc = 1;
  1856. iCurImage->Bps = iCurImage->Width*iCurImage->Bpp*iCurImage->Bpc;
  1857. iCurImage->SizeOfPlane = iCurImage->Height*iCurImage->Bps;
  1858. iCurImage->Format = IL_RGBA;
  1859. iCurImage->Type = IL_UNSIGNED_BYTE;
  1861. if (iCurImage->SizeOfData != iCurImage->SizeOfPlane*iCurImage->Depth) {
  1862. iCurImage->SizeOfData = iCurImage->Depth*iCurImage->SizeOfPlane;
  1863. if (iCurImage->Data != NULL)
  1864. ifree(iCurImage->Data);
  1865. iCurImage->Data = NULL;
  1866. }
  1868. if (iCurImage->Data == NULL) {
  1869. iCurImage->Data = ialloc(iCurImage->SizeOfData);
  1870. }
  1872. Image = iCurImage;
  1873. Width = iCurImage->Width;
  1874. Height = iCurImage->Height;
  1875. Depth = iCurImage->Depth;
  1876. switch(iCurImage->DxtcFormat)
  1877. {
  1878. case IL_DXT1: CompFormat = PF_DXT1; break;
  1879. case IL_DXT3: CompFormat = PF_DXT3; break;
  1880. case IL_DXT5: CompFormat = PF_DXT5; break;
  1881. }
  1882. CompData = iCurImage->DxtcData;
  1883. DdsDecompress(CompFormat); //globals suck...fix this
  1885. //@TODO: origin should be set in Decompress()...
  1886. iCurImage->Origin = IL_ORIGIN_UPPER_LEFT;
  1887. return ilFixCur();
  1888. }
  1891. ILAPI ILboolean ILAPIENTRY ilDxtcDataToImage()
  1892. {
  1893. ILint i, j;
  1894. ILuint ImgID = ilGetInteger(IL_CUR_IMAGE);
  1895. ILint ImgCount = ilGetInteger(IL_NUM_IMAGES);
  1896. ILint MipCount;
  1897. ILboolean ret = IL_TRUE;
  1899. for(i = 0; i <= ImgCount; ++i) {
  1900. ilBindImage(ImgID);
  1901. ilActiveImage(i);
  1903. MipCount = ilGetInteger(IL_NUM_MIPMAPS);
  1904. for(j = 0; j <= MipCount; ++j) {
  1905. ilBindImage(ImgID);
  1906. ilActiveImage(i);
  1907. ilActiveMipmap(j);
  1909. if (!ilDxtcDataToSurface())
  1910. ret = IL_FALSE;
  1911. }
  1912. }
  1913.     ilBindImage(ImgID);
  1915. return ret;
  1916. }
  1919. ILAPI ILboolean ILAPIENTRY ilSurfaceToDxtcData(ILenum Format)
  1920. {
  1921. ILuint Size;
  1922. void* Data;
  1923. ilFreeSurfaceDxtcData();
  1925. Size = ilGetDXTCData(NULL, 0, Format);
  1926. if (Size == 0) {
  1927. return IL_FALSE;
  1928. }
  1930. Data = ialloc(Size);
  1931.     
  1932. if (Data == NULL)
  1933. return IL_FALSE;
  1934.             
  1935. ilGetDXTCData(Data, Size, Format);
  1937. //These have to be after the call to ilGetDXTCData()
  1938. iCurImage->DxtcData = Data;
  1939. iCurImage->DxtcFormat = Format;
  1940. iCurImage->DxtcSize = Size;
  1942. return IL_TRUE;
  1943. }
  1946. ILAPI ILboolean ILAPIENTRY ilImageToDxtcData(ILenum Format)
  1947. {
  1948. ILint i, j;
  1949. ILuint ImgID = ilGetInteger(IL_CUR_IMAGE);
  1950. ILint ImgCount = ilGetInteger(IL_NUM_IMAGES);
  1951. ILint MipCount;
  1952. ILboolean ret = IL_TRUE;
  1954. for (i = 0; i <= ImgCount; ++i) {
  1955. ilBindImage(ImgID);
  1956. ilActiveImage(i);
  1958. MipCount = ilGetInteger(IL_NUM_MIPMAPS);
  1959. for(j = 0; j <= MipCount; ++j) {
  1960. ilBindImage(ImgID);
  1961. ilActiveImage(i);
  1962. ilActiveMipmap(j);
  1964. if (!ilSurfaceToDxtcData(Format))
  1965. ret = IL_FALSE;
  1966. }
  1967. }
  1969. return ret;
  1970. }
  1973. //works like ilTexImage(), ie. destroys mipmaps etc (which sucks, but
  1974. //is consistent. There should be a ilTexSurface() and ilTexSurfaceDxtc()
  1975. //functions as well, but for now this is sufficient)
  1976. ILAPI ILboolean ILAPIENTRY ilTexImageDxtc(ILint w, ILint h, ILint d, ILenum DxtFormat, const ILubyte* data)
  1977. {
  1978. ILimage* Image = iCurImage;
  1980. ILint xBlocks, yBlocks, BlockSize, LineSize, DataSize;
  1983. //The next few lines are copied from ilTexImage() and ilInitImage() -
  1984. //should be factored in more reusable functions...
  1985. if (Image == NULL) {
  1986. ilSetError(IL_ILLEGAL_OPERATION);
  1987. return IL_FALSE;
  1988. }
  1990. ////
  1992. // Not sure if we should be getting rid of the palette...
  1993. if (Image->Pal.Palette && Image->Pal.PalSize && Image->Pal.PalType != IL_PAL_NONE) {
  1994. ifree(Image->Pal.Palette);
  1995. }
  1997. // These are set NULL later by the memset call.
  1998. ilCloseImage(Image->Mipmaps);
  1999. ilCloseImage(Image->Next);
  2000. ilCloseImage(Image->Faces);
  2001. ilCloseImage(Image->Layers);
  2003. if (Image->AnimList) ifree(Image->AnimList);
  2004. if (Image->Profile)  ifree(Image->Profile);
  2005. if (Image->DxtcData) ifree(Image->DxtcData);
  2006. if (Image->Data)  ifree(Image->Data);
  2009. ////
  2011. memset(Image, 0, sizeof(ILimage));
  2012. Image->Width    = w;
  2013. Image->Height    = h;
  2014. Image->Depth    = d;
  2016. //TODO: What about origin with dxtc data?
  2017. Image->Origin    = IL_ORIGIN_LOWER_LEFT;
  2018. Image->Pal.PalType = IL_PAL_NONE;
  2020.     // Allocate DXT data buffer
  2021. xBlocks = (w + 3)/4;
  2022. yBlocks = (h + 3)/4;
  2023. if (DxtFormat == IL_DXT1)
  2024. BlockSize = 8;
  2025. else
  2026. BlockSize = 16;
  2028. LineSize = xBlocks * BlockSize;
  2030. DataSize = yBlocks * LineSize * d;
  2032. Image->DxtcFormat  = DxtFormat;
  2033.         Image->DxtcSize = DataSize;
  2034. Image->DxtcData    = ialloc(DataSize);
  2036. if (Image->DxtcData == NULL) {
  2037. return IL_FALSE;
  2038. }
  2040. if (data != NULL)
  2041. memcpy(Image->DxtcData, data, DataSize);
  2043. return IL_TRUE;
  2044. }
  2047. /* ------------------------------------------------------------------- */
  2049. void iFlipColorBlock(ILubyte *data)
  2050. {
  2051.     ILubyte tmp;
  2053.     tmp = data[4];
  2054.     data[4] = data[7];
  2055.     data[7] = tmp;
  2057.     tmp = data[5];
  2058.     data[5] = data[6];
  2059.     data[6] = tmp;
  2060. }
  2062. void iFlipSimpleAlphaBlock(ILushort *data)
  2063. {
  2064. ILushort tmp;
  2066. tmp = data[0];
  2067. data[0] = data[3];
  2068. data[3] = tmp;
  2070. tmp = data[1];
  2071. data[1] = data[2];
  2072. data[2] = tmp;
  2073. }
  2075. void iComplexAlphaHelper(ILubyte* Data)
  2076. {
  2077. ILushort tmp[2];
  2079. //one 4 pixel line is 12 bit, copy each line into
  2080. //a ushort, swap them and copy back
  2081. tmp[0] = (Data[0] | (Data[1] << 8)) & 0xfff;
  2082. tmp[1] = ((Data[1] >> 4) | (Data[2] << 4)) & 0xfff;
  2084. Data[0] = (ILubyte)tmp[1];
  2085. Data[1] = (tmp[1] >> 8) | (tmp[0] << 4);
  2086. Data[2] = tmp[0] >> 4;
  2087. }
  2089. void iFlipComplexAlphaBlock(ILubyte *Data)
  2090. {
  2091. ILubyte tmp[3];
  2092. Data += 2; //Skip 'palette'
  2094. //swap upper two rows with lower two rows
  2095. memcpy(tmp, Data, 3);
  2096. memcpy(Data, Data + 3, 3);
  2097. memcpy(Data + 3, tmp, 3);
  2099. //swap 1st with 2nd row, 3rd with 4th
  2100. iComplexAlphaHelper(Data);
  2101. iComplexAlphaHelper(Data + 3);
  2102. }
  2104. void iFlipDxt1(ILubyte* data, ILuint count)
  2105. {
  2106. ILuint i;
  2108. for (i = 0; i < count; ++i) {
  2109. iFlipColorBlock(data);
  2110. data += 8; //advance to next block
  2111. }
  2112. }
  2114. void iFlipDxt3(ILubyte* data, ILuint count)
  2115. {
  2116. ILuint i;
  2117. for (i = 0; i < count; ++i) {
  2118. iFlipSimpleAlphaBlock((ILushort*)data);
  2119. iFlipColorBlock(data + 8);
  2120. data += 16; //advance to next block
  2121. }
  2122. }
  2124. void iFlipDxt5(ILubyte* data, ILuint count)
  2125. {
  2126. ILuint i;
  2127. for (i = 0; i < count; ++i) {
  2128. iFlipComplexAlphaBlock(data);
  2129. iFlipColorBlock(data + 8);
  2130. data += 16; //advance to next block
  2131. }
  2132. }
  2134. void iFlip3dc(ILubyte* data, ILuint count)
  2135. {
  2136. ILuint i;
  2137. for (i = 0; i < count; ++i) {
  2138. iFlipComplexAlphaBlock(data);
  2139. iFlipComplexAlphaBlock(data + 8);
  2140. data += 16; //advance to next block
  2141. }
  2142. }
  2145. ILAPI void ILAPIENTRY ilFlipSurfaceDxtcData()
  2146. {
  2147. ILuint y, z;
  2148. ILuint BlockSize, LineSize;
  2149. ILubyte *Temp, *Runner, *Top, *Bottom;
  2150. ILuint numXBlocks, numYBlocks;
  2151. void (*FlipBlocks)(ILubyte* data, ILuint count);
  2153. if (iCurImage == NULL || iCurImage->DxtcData == NULL) {
  2154. ilSetError(IL_INVALID_PARAM);
  2155. return;
  2156. }
  2158. numXBlocks = (iCurImage->Width + 3)/4;
  2159. numYBlocks = (iCurImage->Height + 3)/4;
  2161. switch (iCurImage->DxtcFormat)
  2162. {
  2163. case IL_DXT1:
  2164. BlockSize = 8;
  2165. FlipBlocks = iFlipDxt1;
  2166. break;
  2167. case IL_DXT2:
  2168. case IL_DXT3:
  2169. BlockSize = 16;
  2170. FlipBlocks = iFlipDxt3;
  2171. break;
  2172. case IL_DXT4:
  2173. case IL_DXT5:
  2174. case IL_RXGB:
  2175. BlockSize = 16;
  2176. FlipBlocks = iFlipDxt5;
  2177. break;
  2178. case IL_3DC:
  2179. BlockSize = 16;
  2180. FlipBlocks = iFlip3dc;
  2181. break;
  2182. default:
  2183. ilSetError(IL_INVALID_PARAM);
  2184. return;
  2185. }
  2187. LineSize = numXBlocks * BlockSize;
  2188. Temp = ialloc(LineSize);
  2190. if (Temp == NULL)
  2191.     return;
  2193. Runner = iCurImage->DxtcData;
  2194. for (z = 0; z < iCurImage->Depth; ++z) {
  2195. Top = Runner;
  2196. Bottom = Runner + (numYBlocks - 1)*LineSize;
  2197.     
  2198. for (y = 0; y < numYBlocks/2; ++y) {
  2199. //swap block row
  2200. memcpy(Temp, Top, LineSize);
  2201. memcpy(Top, Bottom, LineSize);
  2202. memcpy(Bottom, Temp, LineSize);
  2205. //swap blocks
  2206. FlipBlocks(Top, numXBlocks);
  2207. FlipBlocks(Bottom, numXBlocks);
  2209. Top += LineSize;
  2210. Bottom -= LineSize;
  2211. }
  2213. //middle line
  2214. if (numYBlocks % 2 != 0)
  2215. FlipBlocks(Top, numXBlocks);
  2217. Runner += LineSize * numYBlocks;
  2218. }
  2220. ifree(Temp);
  2221. }
  2223. /**********************************************************************/
  2225. void iInvertDxt3Alpha(ILubyte *data)
  2226. {
  2227. ILint i;
  2229. for (i = 0; i < 8; ++i) {
  2230. /*
  2231. ILubyte b, t1, t2;
  2232. b = data[i];
  2234. t1 = b & 0xf;
  2235. t1 = 15 - t1;
  2236. t2 = b >> 4;
  2237. t2 = 15 - t2;
  2239. data[i] = (t2 << 4) | t1;
  2240. */
  2241. //simpler:
  2242. data[i] = ~data[i];
  2243. }
  2244. }
  2246. void iInvertDxt5Alpha(ILubyte *data)
  2247. {
  2248. ILubyte a0, a1;
  2249. ILint i, j;
  2250. const ILubyte map1[] = { 1, 0, 7, 6, 5, 4, 3, 2 };
  2251. const ILubyte map2[] = { 1, 0, 5, 4, 3, 2, 7, 6 };
  2254. a0 = data[0];
  2255. a1 = data[1];
  2257. //a0 > a1 <=> 255 - a0 < 255 - a1. Because of this,
  2258. //a1 and a2 have to be swapped, and the indices
  2259. //have to be changed as well.
  2261. //invert and swap alpha
  2262. data[0] = 255 - a1;
  2263. data[1] = 255 - a0;
  2264. data += 2;
  2266. //fix indices
  2267. for (i = 0; i < 6; i += 3) {
  2268. ILuint in = data[i] | (data[i+1] << 8) | (data[i+2] << 16);
  2269. ILuint out = 0;
  2271. for (j = 0; j < 24; j += 3) {
  2272. ILubyte b = (in >> j) & 0x7;
  2274. if (a0 > a1)
  2275. b = map1[b];
  2276. else
  2277. b = map2[b];
  2279. out |= b << j;
  2280. }
  2282. data[i] = out;
  2283. data[i+1] = out >> 8;
  2284. data[i+2] = out >> 16;
  2285. }
  2286. }
  2289. ILAPI ILboolean ILAPIENTRY ilInvertSurfaceDxtcDataAlpha()
  2290. {
  2291. ILint i;
  2292. ILuint BlockSize;
  2293. ILubyte *Runner;
  2294. ILint numXBlocks, numYBlocks, numBlocks;
  2295. void (*InvertAlpha)(ILubyte* data);
  2297. if (iCurImage == NULL || iCurImage->DxtcData == NULL) {
  2298. ilSetError(IL_INVALID_PARAM);
  2299. return IL_FALSE;
  2300. }
  2302. numXBlocks = (iCurImage->Width + 3)/4;
  2303. numYBlocks = (iCurImage->Height + 3)/4;
  2304. numBlocks = numXBlocks*numYBlocks*iCurImage->Depth;
  2305. BlockSize = 16;
  2307. switch (iCurImage->DxtcFormat)
  2308. {
  2309. case IL_DXT3:
  2310. InvertAlpha = iInvertDxt3Alpha;
  2311. break;
  2312. case IL_DXT5:
  2313. InvertAlpha = iInvertDxt5Alpha;
  2314. break;
  2315. default:
  2316. //DXT2/4 are not supported yet because nobody
  2317. //uses them anyway and I would have to change
  2318. //the color blocks as well...
  2319. //DXT1 is not supported because DXT1 alpha is
  2320. //seldom used and it's not easily invertable.
  2321. ilSetError(IL_INVALID_PARAM);
  2322. return IL_FALSE;
  2323. }
  2325. Runner = iCurImage->DxtcData;
  2326. for (i = 0; i < numBlocks; ++i, Runner += BlockSize) {
  2327. InvertAlpha(Runner);
  2328. }
  2330. return IL_TRUE;
  2331. }
  2336. #endif//IL_NO_DDS