DevIL: /home/dwoods/DevIL/src-IL/include/il_endian.h Source File

- Main Page
- Data Structures
- Files

# /home/dwoods/DevIL/src-IL/include/il_endian.h

    00001 //-----------------------------------------------------------------------------
    00002 //
    00003 // ImageLib Sources
    00004 // Copyright (C) 2000-2009 by Denton Woods
    00005 // Last modified: 01/29/2009
    00006 //
    00007 // Filename: src-IL/include/il_endian.h
    00008 //
    00009 // Description: Handles Endian-ness
    00010 //
    00011 //-----------------------------------------------------------------------------
    00012
    00013 #ifndef IL_ENDIAN_H
    00014 #define IL_ENDIAN_H
    00015
    00016 #include "il_internal.h"
    00017
    00018 #ifdef WORDS_BIGENDIAN  // This is defined by ./configure.
    00019         #ifndef __BIG_ENDIAN__
    00020         #define __BIG_ENDIAN__ 1
    00021         #endif
    00022 #endif
    00023
    00024 #if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __BIG_ENDIAN__) \
    00025   || (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__))
    00026         #undef __LITTLE_ENDIAN__
    00027         #define Short(s) iSwapShort(s)
    00028         #define UShort(s) iSwapUShort(s)
    00029         #define Int(i) iSwapInt(i)
    00030         #define UInt(i) iSwapUInt(i)
    00031         #define Float(f) iSwapFloat(f)
    00032         #define Double(d) iSwapDouble(d)
    00033
    00034         #define BigShort(s)
    00035         #define BigUShort(s)
    00036         #define BigInt(i)
    00037         #define BigUInt(i)
    00038         #define BigFloat(f)
    00039         #define BigDouble(d)
    00040 #else
    00041         #undef __BIG_ENDIAN__
    00042         #undef __LITTLE_ENDIAN__  // Not sure if it's defined by any compiler...
    00043         #define __LITTLE_ENDIAN__
    00044         #define Short(s)
    00045         #define UShort(s)
    00046         #define Int(i)
    00047         #define UInt(i)
    00048         #define Float(f)
    00049         #define Double(d)
    00050
    00051         #define BigShort(s) iSwapShort(s)
    00052         #define BigUShort(s) iSwapUShort(s)
    00053         #define BigInt(i) iSwapInt(i)
    00054         #define BigUInt(i) iSwapUInt(i)
    00055         #define BigFloat(f) iSwapFloat(f)
    00056         #define BigDouble(d) iSwapDouble(d)
    00057 #endif
    00058
    00059 void   iSwapUShort(ILushort *s);
    00060 void   iSwapShort(ILshort *s);
    00061 void   iSwapUInt(ILuint *i);
    00062 void   iSwapInt(ILint *i);
    00063 void   iSwapFloat(ILfloat *f);
    00064 void   iSwapDouble(ILdouble *d);
    00065 ILushort GetLittleUShort();
    00066 ILshort  GetLittleShort();
    00067 ILuint   GetLittleUInt();
    00068 ILint    GetLittleInt();
    00069 ILfloat  GetLittleFloat();
    00070 ILdouble GetLittleDouble();
    00071 ILushort GetBigUShort();
    00072 ILshort  GetBigShort();
    00073 ILuint   GetBigUInt();
    00074 ILint    GetBigInt();
    00075 ILfloat  GetBigFloat();
    00076 ILdouble GetBigDouble();
    00077 ILubyte SaveLittleUShort(ILushort s);
    00078 ILubyte SaveLittleShort(ILshort s);
    00079 ILubyte SaveLittleUInt(ILuint i);
    00080 ILubyte SaveLittleInt(ILint i);
    00081 ILubyte SaveLittleFloat(ILfloat f);
    00082 ILubyte SaveLittleDouble(ILdouble d);
    00083 ILubyte SaveBigUShort(ILushort s);
    00084 ILubyte SaveBigShort(ILshort s);
    00085 ILubyte SaveBigUInt(ILuint i);
    00086 ILubyte SaveBigInt(ILint i);
    00087 ILubyte SaveBigFloat(ILfloat f);
    00088 ILubyte SaveBigDouble(ILdouble d);
    00089
    00090 #ifdef IL_ENDIAN_C
    00091 #undef NOINLINE
    00092 #undef INLINE
    00093 #define INLINE
    00094 #endif
    00095
    00096 #ifndef NOINLINE
    00097 INLINE void iSwapUShort(ILushort *s)  {
    00098         #ifdef USE_WIN32_ASM
    00099                 __asm {
    00100                         mov ebx, s
    00101                         mov al, [ebx+1]
    00102                         mov ah, [ebx  ]
    00103                         mov [ebx], ax
    00104                 }
    00105         #else
    00106         #ifdef GCC_X86_ASM
    00107                 asm("ror $8,%0"
    00108                         : "=r" (*s)
    00109                         : "0" (*s));
    00110         #else
    00111                 *s = ((*s)>>8) | ((*s)<<8);
    00112         #endif //GCC_X86_ASM
    00113         #endif //USE_WIN32_ASM
    00114 }
    00115
    00116 INLINE void iSwapShort(ILshort *s) {
    00117         iSwapUShort((ILushort*)s);
    00118 }
    00119
    00120 INLINE void iSwapUInt(ILuint *i) {
    00121         #ifdef USE_WIN32_ASM
    00122                 __asm {
    00123                         mov ebx, i
    00124                         mov eax, [ebx]
    00125                         bswap eax
    00126                         mov [ebx], eax
    00127                 }
    00128         #else
    00129         #ifdef GCC_X86_ASM
    00130                         asm("bswap %0;"
    00131                                 : "+r" (*i));
    00132         #else
    00133                 *i = ((*i)>>24) | (((*i)>>8) & 0xff00) | (((*i)<<8) & 0xff0000) | ((*i)<<24);
    00134         #endif //GCC_X86_ASM
    00135         #endif //USE_WIN32_ASM
    00136 }
    00137
    00138 INLINE void iSwapInt(ILint *i) {
    00139         iSwapUInt((ILuint*)i);
    00140 }
    00141
    00142 INLINE void iSwapFloat(ILfloat *f) {
    00143         iSwapUInt((ILuint*)f);
    00144 }
    00145
    00146 INLINE void iSwapDouble(ILdouble *d) {
    00147         #ifdef GCC_X86_ASM
    00148         int *t = (int*)d;
    00149         asm("bswap %2    \n"
    00150                 "bswap %3    \n"
    00151                 "movl  %2,%1 \n"
    00152                 "movl  %3,%0 \n"
    00153                 : "=g" (t[0]), "=g" (t[1])
    00154                 : "r"  (t[0]), "r"  (t[1]));
    00155         #else
    00156         ILubyte t,*b = (ILubyte*)d;
    00157         #define dswap(x,y) t=b[x];b[x]=b[y];b[y]=b[x];
    00158         dswap(0,7);
    00159         dswap(1,6);
    00160         dswap(2,5);
    00161         dswap(3,4);
    00162         #undef dswap
    00163         #endif
    00164 }
    00165
    00166
    00167 INLINE ILushort GetLittleUShort() {
    00168         ILushort s;
    00169         iread(&s, sizeof(ILushort), 1);
    00170 #ifdef __BIG_ENDIAN__
    00171         iSwapUShort(&s);
    00172 #endif
    00173         return s;
    00174 }
    00175
    00176 INLINE ILshort GetLittleShort() {
    00177         ILshort s;
    00178         iread(&s, sizeof(ILshort), 1);
    00179 #ifdef __BIG_ENDIAN__
    00180         iSwapShort(&s);
    00181 #endif
    00182         return s;
    00183 }
    00184
    00185 INLINE ILuint GetLittleUInt() {
    00186         ILuint i;
    00187         iread(&i, sizeof(ILuint), 1);
    00188 #ifdef __BIG_ENDIAN__
    00189         iSwapUInt(&i);
    00190 #endif
    00191         return i;
    00192 }
    00193
    00194 INLINE ILint GetLittleInt() {
    00195         ILint i;
    00196         iread(&i, sizeof(ILint), 1);
    00197 #ifdef __BIG_ENDIAN__
    00198         iSwapInt(&i);
    00199 #endif
    00200         return i;
    00201 }
    00202
    00203 INLINE ILfloat GetLittleFloat() {
    00204         ILfloat f;
    00205         iread(&f, sizeof(ILfloat), 1);
    00206 #ifdef __BIG_ENDIAN__
    00207         iSwapFloat(&f);
    00208 #endif
    00209         return f;
    00210 }
    00211
    00212 INLINE ILdouble GetLittleDouble() {
    00213         ILdouble d;
    00214         iread(&d, sizeof(ILdouble), 1);
    00215 #ifdef __BIG_ENDIAN__
    00216         iSwapDouble(&d);
    00217 #endif
    00218         return d;
    00219 }
    00220
    00221
    00222 INLINE ILushort GetBigUShort() {
    00223         ILushort s;
    00224         iread(&s, sizeof(ILushort), 1);
    00225 #ifdef __LITTLE_ENDIAN__
    00226         iSwapUShort(&s);
    00227 #endif
    00228         return s;
    00229 }
    00230
    00231
    00232 INLINE ILshort GetBigShort() {
    00233         ILshort s;
    00234         iread(&s, sizeof(ILshort), 1);
    00235 #ifdef __LITTLE_ENDIAN__
    00236         iSwapShort(&s);
    00237 #endif
    00238         return s;
    00239 }
    00240
    00241
    00242 INLINE ILuint GetBigUInt() {
    00243         ILuint i;
    00244         iread(&i, sizeof(ILuint), 1);
    00245 #ifdef __LITTLE_ENDIAN__
    00246         iSwapUInt(&i);
    00247 #endif
    00248         return i;
    00249 }
    00250
    00251
    00252 INLINE ILint GetBigInt() {
    00253         ILint i;
    00254         iread(&i, sizeof(ILint), 1);
    00255 #ifdef __LITTLE_ENDIAN__
    00256         iSwapInt(&i);
    00257 #endif
    00258         return i;
    00259 }
    00260
    00261
    00262 INLINE ILfloat GetBigFloat() {
    00263         ILfloat f;
    00264         iread(&f, sizeof(ILfloat), 1);
    00265 #ifdef __LITTLE_ENDIAN__
    00266         iSwapFloat(&f);
    00267 #endif
    00268         return f;
    00269 }
    00270
    00271
    00272 INLINE ILdouble GetBigDouble() {
    00273         ILdouble d;
    00274         iread(&d, sizeof(ILdouble), 1);
    00275 #ifdef __LITTLE_ENDIAN__
    00276         iSwapDouble(&d);
    00277 #endif
    00278         return d;
    00279 }
    00280
    00281 INLINE ILubyte SaveLittleUShort(ILushort s) {
    00282 #ifdef __BIG_ENDIAN__
    00283         iSwapUShort(&s);
    00284 #endif
    00285         return iwrite(&s, sizeof(ILushort), 1);
    00286 }
    00287
    00288 INLINE ILubyte SaveLittleShort(ILshort s) {
    00289 #ifdef __BIG_ENDIAN__
    00290         iSwapShort(&s);
    00291 #endif
    00292         return iwrite(&s, sizeof(ILshort), 1);
    00293 }
    00294
    00295
    00296 INLINE ILubyte SaveLittleUInt(ILuint i) {
    00297 #ifdef __BIG_ENDIAN__
    00298         iSwapUInt(&i);
    00299 #endif
    00300         return iwrite(&i, sizeof(ILuint), 1);
    00301 }
    00302
    00303
    00304 INLINE ILubyte SaveLittleInt(ILint i) {
    00305 #ifdef __BIG_ENDIAN__
    00306         iSwapInt(&i);
    00307 #endif
    00308         return iwrite(&i, sizeof(ILint), 1);
    00309 }
    00310
    00311 INLINE ILubyte SaveLittleFloat(ILfloat f) {
    00312 #ifdef __BIG_ENDIAN__
    00313         iSwapFloat(&f);
    00314 #endif
    00315         return iwrite(&f, sizeof(ILfloat), 1);
    00316 }
    00317
    00318
    00319 INLINE ILubyte SaveLittleDouble(ILdouble d) {
    00320 #ifdef __BIG_ENDIAN__
    00321         iSwapDouble(&d);
    00322 #endif
    00323         return iwrite(&d, sizeof(ILdouble), 1);
    00324 }
    00325
    00326
    00327 INLINE ILubyte SaveBigUShort(ILushort s) {
    00328 #ifdef __LITTLE_ENDIAN__
    00329         iSwapUShort(&s);
    00330 #endif
    00331         return iwrite(&s, sizeof(ILushort), 1);
    00332 }
    00333
    00334
    00335 INLINE ILubyte SaveBigShort(ILshort s) {
    00336 #ifdef __LITTLE_ENDIAN__
    00337         iSwapShort(&s);
    00338 #endif
    00339         return iwrite(&s, sizeof(ILshort), 1);
    00340 }
    00341
    00342
    00343 INLINE ILubyte SaveBigUInt(ILuint i) {
    00344 #ifdef __LITTLE_ENDIAN__
    00345         iSwapUInt(&i);
    00346 #endif
    00347         return iwrite(&i, sizeof(ILuint), 1);
    00348 }
    00349
    00350
    00351 INLINE ILubyte SaveBigInt(ILint i) {
    00352 #ifdef __LITTLE_ENDIAN__
    00353         iSwapInt(&i);
    00354 #endif
    00355         return iwrite(&i, sizeof(ILint), 1);
    00356 }
    00357
    00358
    00359 INLINE ILubyte SaveBigFloat(ILfloat f) {
    00360 #ifdef __LITTLE_ENDIAN__
    00361         iSwapFloat(&f);
    00362 #endif
    00363         return iwrite(&f, sizeof(ILfloat), 1);
    00364 }
    00365
    00366
    00367 INLINE ILubyte SaveBigDouble(ILdouble d) {
    00368 #ifdef __LITTLE_ENDIAN__
    00369         iSwapDouble(&d);
    00370 #endif
    00371         return iwrite(&d, sizeof(ILdouble), 1);
    00372 }
    00373 #endif//NOINLINE
    00374
    00375 void            EndianSwapData(void *_Image);
    00376
    00377 #endif//ENDIAN_H