Category

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

Compress-Decompress algrithms

Development Platform:

Visual C++

il_endian.h：Code Content
  1. //-----------------------------------------------------------------------------
  2. //
  3. // ImageLib Sources
  4. // Copyright (C) 2000-2009 by Denton Woods
  5. // Last modified: 01/29/2009
  6. //
  7. // Filename: src-IL/include/il_endian.h
  8. //
  9. // Description: Handles Endian-ness
  10. //
  11. //-----------------------------------------------------------------------------
  13. #ifndef IL_ENDIAN_H
  14. #define IL_ENDIAN_H
  16. #include "il_internal.h"
  18. #ifdef WORDS_BIGENDIAN  // This is defined by ./configure.
  19. #ifndef __BIG_ENDIAN__
  20. #define __BIG_ENDIAN__ 1
  21. #endif
  22. #endif
  24. #if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __BIG_ENDIAN__) 
  25.   || (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__))
  26.   #undef __LITTLE_ENDIAN__
  27. #define Short(s) iSwapShort(s)
  28. #define UShort(s) iSwapUShort(s)
  29. #define Int(i) iSwapInt(i)
  30. #define UInt(i) iSwapUInt(i)
  31. #define Float(f) iSwapFloat(f)
  32. #define Double(d) iSwapDouble(d)
  33.  
  34. #define BigShort(s)  
  35. #define BigUShort(s)  
  36. #define BigInt(i)  
  37. #define BigUInt(i)  
  38. #define BigFloat(f)  
  39. #define BigDouble(d)  
  40. #else
  41. #undef __BIG_ENDIAN__
  42. #undef __LITTLE_ENDIAN__  // Not sure if it's defined by any compiler...
  43. #define __LITTLE_ENDIAN__
  44. #define Short(s)  
  45. #define UShort(s)  
  46. #define Int(i)  
  47. #define UInt(i)  
  48. #define Float(f)  
  49. #define Double(d)  
  51. #define BigShort(s) iSwapShort(s)
  52. #define BigUShort(s) iSwapUShort(s)
  53. #define BigInt(i) iSwapInt(i)
  54. #define BigUInt(i) iSwapUInt(i)
  55. #define BigFloat(f) iSwapFloat(f)
  56. #define BigDouble(d) iSwapDouble(d)
  57. #endif
  59. void   iSwapUShort(ILushort *s);
  60. void   iSwapShort(ILshort *s);
  61. void   iSwapUInt(ILuint *i);
  62. void   iSwapInt(ILint *i);
  63. void   iSwapFloat(ILfloat *f);
  64. void   iSwapDouble(ILdouble *d);
  65. ILushort GetLittleUShort();
  66. ILshort  GetLittleShort();
  67. ILuint   GetLittleUInt();
  68. ILint    GetLittleInt();
  69. ILfloat  GetLittleFloat();
  70. ILdouble GetLittleDouble();
  71. ILushort GetBigUShort();
  72. ILshort  GetBigShort();
  73. ILuint   GetBigUInt();
  74. ILint    GetBigInt();
  75. ILfloat  GetBigFloat();
  76. ILdouble GetBigDouble();
  77. ILubyte SaveLittleUShort(ILushort s);
  78. ILubyte SaveLittleShort(ILshort s);
  79. ILubyte SaveLittleUInt(ILuint i);
  80. ILubyte SaveLittleInt(ILint i);
  81. ILubyte SaveLittleFloat(ILfloat f);
  82. ILubyte SaveLittleDouble(ILdouble d);
  83. ILubyte SaveBigUShort(ILushort s);
  84. ILubyte SaveBigShort(ILshort s);
  85. ILubyte SaveBigUInt(ILuint i);
  86. ILubyte SaveBigInt(ILint i);
  87. ILubyte SaveBigFloat(ILfloat f);
  88. ILubyte SaveBigDouble(ILdouble d);
  90. #ifdef IL_ENDIAN_C
  91. #undef NOINLINE
  92. #undef INLINE
  93. #define INLINE
  94. #endif
  96. #ifndef NOINLINE
  97. INLINE void iSwapUShort(ILushort *s)  {
  98. #ifdef USE_WIN32_ASM
  99. __asm {
  100. mov ebx, s
  101. mov al, [ebx+1]
  102. mov ah, [ebx  ]
  103. mov [ebx], ax
  104. }
  105. #else
  106. #ifdef GCC_X86_ASM
  107. asm("ror $8,%0"
  108. : "=r" (*s)
  109. : "0" (*s));
  110. #else
  111. *s = ((*s)>>8) | ((*s)<<8);
  112. #endif //GCC_X86_ASM
  113. #endif //USE_WIN32_ASM
  114. }
  116. INLINE void iSwapShort(ILshort *s) {
  117. iSwapUShort((ILushort*)s);
  118. }
  120. INLINE void iSwapUInt(ILuint *i) {
  121. #ifdef USE_WIN32_ASM
  122. __asm {
  123. mov ebx, i
  124. mov eax, [ebx]
  125. bswap eax
  126. mov [ebx], eax
  127. }
  128. #else
  129. #ifdef GCC_X86_ASM
  130. asm("bswap %0;"
  131. : "+r" (*i));
  132. #else
  133. *i = ((*i)>>24) | (((*i)>>8) & 0xff00) | (((*i)<<8) & 0xff0000) | ((*i)<<24);
  134. #endif //GCC_X86_ASM
  135. #endif //USE_WIN32_ASM
  136. }
  138. INLINE void iSwapInt(ILint *i) {
  139. iSwapUInt((ILuint*)i);
  140. }
  142. INLINE void iSwapFloat(ILfloat *f) {
  143. iSwapUInt((ILuint*)f);
  144. }
  146. INLINE void iSwapDouble(ILdouble *d) {
  147. #ifdef GCC_X86_ASM
  148. int *t = (int*)d;
  149. asm("bswap %2    n"
  150. "bswap %3    n"
  151. "movl  %2,%1 n"
  152. "movl  %3,%0 n"
  153. : "=g" (t[0]), "=g" (t[1])
  154. : "r"  (t[0]), "r"  (t[1]));
  155. #else
  156. ILubyte t,*b = (ILubyte*)d;
  157. #define dswap(x,y) t=b[x];b[x]=b[y];b[y]=b[x];
  158. dswap(0,7);
  159. dswap(1,6);
  160. dswap(2,5);
  161. dswap(3,4);
  162. #undef dswap
  163. #endif
  164. }
  167. INLINE ILushort GetLittleUShort() {
  168. ILushort s;
  169. iread(&s, sizeof(ILushort), 1);
  170. #ifdef __BIG_ENDIAN__
  171. iSwapUShort(&s);
  172. #endif
  173. return s;
  174. }
  176. INLINE ILshort GetLittleShort() {
  177. ILshort s;
  178. iread(&s, sizeof(ILshort), 1);
  179. #ifdef __BIG_ENDIAN__
  180. iSwapShort(&s);
  181. #endif
  182. return s;
  183. }
  185. INLINE ILuint GetLittleUInt() {
  186. ILuint i;
  187. iread(&i, sizeof(ILuint), 1);
  188. #ifdef __BIG_ENDIAN__
  189. iSwapUInt(&i);
  190. #endif
  191. return i;
  192. }
  194. INLINE ILint GetLittleInt() {
  195. ILint i;
  196. iread(&i, sizeof(ILint), 1);
  197. #ifdef __BIG_ENDIAN__
  198. iSwapInt(&i);
  199. #endif
  200. return i;
  201. }
  203. INLINE ILfloat GetLittleFloat() {
  204. ILfloat f;
  205. iread(&f, sizeof(ILfloat), 1);
  206. #ifdef __BIG_ENDIAN__
  207. iSwapFloat(&f);
  208. #endif
  209. return f;
  210. }
  212. INLINE ILdouble GetLittleDouble() {
  213. ILdouble d;
  214. iread(&d, sizeof(ILdouble), 1);
  215. #ifdef __BIG_ENDIAN__
  216. iSwapDouble(&d);
  217. #endif
  218. return d;
  219. }
  222. INLINE ILushort GetBigUShort() {
  223. ILushort s;
  224. iread(&s, sizeof(ILushort), 1);
  225. #ifdef __LITTLE_ENDIAN__
  226. iSwapUShort(&s);
  227. #endif
  228. return s;
  229. }
  232. INLINE ILshort GetBigShort() {
  233. ILshort s;
  234. iread(&s, sizeof(ILshort), 1);
  235. #ifdef __LITTLE_ENDIAN__
  236. iSwapShort(&s);
  237. #endif
  238. return s;
  239. }
  242. INLINE ILuint GetBigUInt() {
  243. ILuint i;
  244. iread(&i, sizeof(ILuint), 1);
  245. #ifdef __LITTLE_ENDIAN__
  246. iSwapUInt(&i);
  247. #endif
  248. return i;
  249. }
  252. INLINE ILint GetBigInt() {
  253. ILint i;
  254. iread(&i, sizeof(ILint), 1);
  255. #ifdef __LITTLE_ENDIAN__
  256. iSwapInt(&i);
  257. #endif
  258. return i;
  259. }
  262. INLINE ILfloat GetBigFloat() {
  263. ILfloat f;
  264. iread(&f, sizeof(ILfloat), 1);
  265. #ifdef __LITTLE_ENDIAN__
  266. iSwapFloat(&f);
  267. #endif
  268. return f;
  269. }
  272. INLINE ILdouble GetBigDouble() {
  273. ILdouble d;
  274. iread(&d, sizeof(ILdouble), 1);
  275. #ifdef __LITTLE_ENDIAN__
  276. iSwapDouble(&d);
  277. #endif
  278. return d;
  279. }
  281. INLINE ILubyte SaveLittleUShort(ILushort s) {
  282. #ifdef __BIG_ENDIAN__
  283. iSwapUShort(&s);
  284. #endif
  285. return iwrite(&s, sizeof(ILushort), 1);
  286. }
  288. INLINE ILubyte SaveLittleShort(ILshort s) {
  289. #ifdef __BIG_ENDIAN__
  290. iSwapShort(&s);
  291. #endif
  292. return iwrite(&s, sizeof(ILshort), 1);
  293. }
  296. INLINE ILubyte SaveLittleUInt(ILuint i) {
  297. #ifdef __BIG_ENDIAN__
  298. iSwapUInt(&i);
  299. #endif
  300. return iwrite(&i, sizeof(ILuint), 1);
  301. }
  304. INLINE ILubyte SaveLittleInt(ILint i) {
  305. #ifdef __BIG_ENDIAN__
  306. iSwapInt(&i);
  307. #endif
  308. return iwrite(&i, sizeof(ILint), 1);
  309. }
  311. INLINE ILubyte SaveLittleFloat(ILfloat f) {
  312. #ifdef __BIG_ENDIAN__
  313. iSwapFloat(&f);
  314. #endif
  315. return iwrite(&f, sizeof(ILfloat), 1);
  316. }
  319. INLINE ILubyte SaveLittleDouble(ILdouble d) {
  320. #ifdef __BIG_ENDIAN__
  321. iSwapDouble(&d);
  322. #endif
  323. return iwrite(&d, sizeof(ILdouble), 1);
  324. }
  327. INLINE ILubyte SaveBigUShort(ILushort s) {
  328. #ifdef __LITTLE_ENDIAN__
  329. iSwapUShort(&s);
  330. #endif
  331. return iwrite(&s, sizeof(ILushort), 1);
  332. }
  335. INLINE ILubyte SaveBigShort(ILshort s) {
  336. #ifdef __LITTLE_ENDIAN__
  337. iSwapShort(&s);
  338. #endif
  339. return iwrite(&s, sizeof(ILshort), 1);
  340. }
  343. INLINE ILubyte SaveBigUInt(ILuint i) {
  344. #ifdef __LITTLE_ENDIAN__
  345. iSwapUInt(&i);
  346. #endif
  347. return iwrite(&i, sizeof(ILuint), 1);
  348. }
  351. INLINE ILubyte SaveBigInt(ILint i) {
  352. #ifdef __LITTLE_ENDIAN__
  353. iSwapInt(&i);
  354. #endif
  355. return iwrite(&i, sizeof(ILint), 1);
  356. }
  359. INLINE ILubyte SaveBigFloat(ILfloat f) {
  360. #ifdef __LITTLE_ENDIAN__
  361. iSwapFloat(&f);
  362. #endif
  363. return iwrite(&f, sizeof(ILfloat), 1);
  364. }
  367. INLINE ILubyte SaveBigDouble(ILdouble d) {
  368. #ifdef __LITTLE_ENDIAN__
  369. iSwapDouble(&d);
  370. #endif
  371. return iwrite(&d, sizeof(ILdouble), 1);
  372. }
  373. #endif//NOINLINE
  375. void EndianSwapData(void *_Image);
  377. #endif//ENDIAN_H