00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056 #ifndef _ASSEMBLY_H
00057 #define _ASSEMBLY_H
00058
00059 #if (defined _WIN32 && !defined _WIN32_WCE) || (defined __WINS__ && defined _SYMBIAN) || defined(_OPENWAVE_SIMULATOR) || defined(WINCE_EMULATOR)
00060
00061 #pragma warning( disable : 4035 )
00062
00063 static __inline int MULSHIFT32(int x, int y)
00064 {
00065 __asm {
00066 mov eax, x
00067 imul y
00068 mov eax, edx
00069 }
00070 }
00071
00072 static __inline int FASTABS(int x)
00073 {
00074 int sign;
00075
00076 sign = x >> (sizeof(int) * 8 - 1);
00077 x ^= sign;
00078 x -= sign;
00079
00080 return x;
00081 }
00082
00083 static __inline int CLZ(int x)
00084 {
00085 int numZeros;
00086
00087 if (!x)
00088 return (sizeof(int) * 8);
00089
00090 numZeros = 0;
00091 while (!(x & 0x80000000)) {
00092 numZeros++;
00093 x <<= 1;
00094 }
00095
00096 return numZeros;
00097 }
00098
00099
00100
00101
00102
00103
00104 static __inline __int64 MADD64(__int64 sum, int x, int y)
00105 {
00106 unsigned int sumLo = ((unsigned int *)&sum)[0];
00107 int sumHi = ((int *)&sum)[1];
00108
00109 __asm {
00110 mov eax, x
00111 imul y
00112 add eax, sumLo
00113 adc edx, sumHi
00114 }
00115
00116
00117 }
00118
00119 static __inline __int64 SHL64(__int64 x, int n)
00120 {
00121 unsigned int xLo = ((unsigned int *)&x)[0];
00122 int xHi = ((int *)&x)[1];
00123 unsigned char nb = (unsigned char)n;
00124
00125 if (n < 32) {
00126 __asm {
00127 mov edx, xHi
00128 mov eax, xLo
00129 mov cl, nb
00130 shld edx, eax, cl
00131 shl eax, cl
00132 }
00133 } else if (n < 64) {
00134
00135 __asm {
00136 mov edx, xLo
00137 mov cl, nb
00138 xor eax, eax
00139 shl edx, cl
00140 }
00141 } else {
00142 __asm {
00143 xor edx, edx
00144 xor eax, eax
00145 }
00146 }
00147 }
00148
00149 static __inline __int64 SAR64(__int64 x, int n)
00150 {
00151 unsigned int xLo = ((unsigned int *)&x)[0];
00152 int xHi = ((int *)&x)[1];
00153 unsigned char nb = (unsigned char)n;
00154
00155 if (n < 32) {
00156 __asm {
00157 mov edx, xHi
00158 mov eax, xLo
00159 mov cl, nb
00160 shrd eax, edx, cl
00161 sar edx, cl
00162 }
00163 } else if (n < 64) {
00164
00165 __asm {
00166 mov edx, xHi
00167 mov eax, xHi
00168 mov cl, nb
00169 sar edx, 31
00170 sar eax, cl
00171 }
00172 } else {
00173 __asm {
00174 sar xHi, 31
00175 mov eax, xHi
00176 mov edx, xHi
00177 }
00178 }
00179 }
00180
00181 #elif (defined _WIN32) && (defined _WIN32_WCE)
00182
00183
00184 #define MULSHIFT32 xmp3_MULSHIFT32
00185 int MULSHIFT32(int x, int y);
00186
00187 static __inline int FASTABS(int x)
00188 {
00189 int sign;
00190
00191 sign = x >> (sizeof(int) * 8 - 1);
00192 x ^= sign;
00193 x -= sign;
00194
00195 return x;
00196 }
00197
00198 static __inline int CLZ(int x)
00199 {
00200 int numZeros;
00201
00202 if (!x)
00203 return (sizeof(int) * 8);
00204
00205 numZeros = 0;
00206 while (!(x & 0x80000000)) {
00207 numZeros++;
00208 x <<= 1;
00209 }
00210
00211 return numZeros;
00212 }
00213
00214 #elif defined ARM_ADS
00215
00216 static __inline int MULSHIFT32(int x, int y)
00217 {
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228 int zlow;
00229 __asm {
00230 smull zlow,y,x,y
00231 }
00232
00233 return y;
00234 }
00235
00236 static __inline int FASTABS(int x)
00237 {
00238 int t;
00239
00240 __asm {
00241 eor t, x, x, asr #31
00242 sub t, t, x, asr #31
00243 }
00244
00245 return t;
00246 }
00247
00248 static __inline int CLZ(int x)
00249 {
00250 int numZeros;
00251
00252 if (!x)
00253 return (sizeof(int) * 8);
00254
00255 numZeros = 0;
00256 while (!(x & 0x80000000)) {
00257 numZeros++;
00258 x <<= 1;
00259 }
00260
00261 return numZeros;
00262 }
00263
00264 #elif defined(__GNUC__) && defined(__arm__)
00265
00266 static __inline int MULSHIFT32(int x, int y)
00267 {
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278 int zlow;
00279 __asm__ volatile ("smull %0,%1,%2,%3" : "=&r" (zlow), "=r" (y) : "r" (x), "1" (y)) ;
00280
00281 return y;
00282 }
00283
00284 static __inline int FASTABS(int x)
00285 {
00286 int t = 0;
00287
00288 __asm__ volatile (
00289 "eor %0,%2,%2, asr #31;"
00290 "sub %0,%1,%2, asr #31;"
00291 : "=&r" (t)
00292 : "0" (t), "r" (x)
00293 );
00294
00295 return t;
00296 }
00297
00298 static __inline int CLZ(int x)
00299 {
00300 int numZeros;
00301
00302 if (!x)
00303 return (sizeof(int) * 8);
00304
00305 numZeros = 0;
00306 while (!(x & 0x80000000)) {
00307 numZeros++;
00308 x <<= 1;
00309 }
00310
00311 return numZeros;
00312 }
00313
00314 #else
00315
00316 #error Unsupported platform in assembly.h
00317
00318 #endif
00319
00320 #endif