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 #ifndef __BITS_H__
00034 #define __BITS_H__
00035
00036 #ifdef __cplusplus
00037 extern "C" {
00038 #endif
00039
00040 #include "analysis.h"
00041 #ifdef ANALYSIS
00042 #include <stdio.h>
00043 #endif
00044
00045 #define BYTE_NUMBIT 8
00046 #define bit2byte(a) ((a+7)/BYTE_NUMBIT)
00047
00048 typedef struct _bitfile
00049 {
00050
00051 uint32_t bufa;
00052 uint32_t bufb;
00053 uint32_t bits_left;
00054 uint32_t buffer_size;
00055 uint32_t bytes_used;
00056 uint8_t no_more_reading;
00057 uint8_t error;
00058 uint32_t *tail;
00059 uint32_t *start;
00060 void *buffer;
00061 } bitfile;
00062
00063
00064 #if defined (_WIN32) && !defined(_WIN32_WCE) && !defined(__MINGW32__)
00065 #define BSWAP(a) __asm mov eax,a __asm bswap eax __asm mov a, eax
00066 #elif defined(LINUX) || defined(DJGPP) || defined(__MINGW32__)
00067 #define BSWAP(a) __asm__ ( "bswapl %0\n" : "=r" (a) : "0" (a) )
00068 #else
00069 #define BSWAP(a) \
00070 ((a) = ( ((a)&0xff)<<24) | (((a)&0xff00)<<8) | (((a)>>8)&0xff00) | (((a)>>24)&0xff))
00071 #endif
00072
00073 static uint32_t bitmask[] = {
00074 0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF,
00075 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF,
00076 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF,
00077 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF,
00078 0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF
00079
00080 , 0xFFFFFFFF
00081 };
00082
00083 void faad_initbits(bitfile *ld, const void *buffer, const uint32_t buffer_size);
00084 void faad_endbits(bitfile *ld);
00085 void faad_initbits_rev(bitfile *ld, void *buffer,
00086 uint32_t bits_in_buffer);
00087 uint8_t faad_byte_align(bitfile *ld);
00088 uint32_t faad_get_processed_bits(bitfile *ld);
00089 void faad_flushbits_ex(bitfile *ld, uint32_t bits);
00090 void faad_rewindbits(bitfile *ld);
00091 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits
00092 DEBUGDEC);
00093 #ifdef DRM
00094 void *faad_origbitbuffer(bitfile *ld);
00095 uint32_t faad_origbitbuffer_size(bitfile *ld);
00096 #endif
00097
00098
00099 static INLINE uint32_t getdword(void *mem)
00100 {
00101 #ifdef ARM
00102 uint32_t tmp;
00103 #ifndef ARCH_IS_BIG_ENDIAN
00104 ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[3];
00105 ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[2];
00106 ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[1];
00107 ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[0];
00108 #else
00109 ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[0];
00110 ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[1];
00111 ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[2];
00112 ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[3];
00113 #endif
00114
00115 return tmp;
00116 #else
00117 uint32_t tmp;
00118 tmp = *(uint32_t*)mem;
00119 #ifndef ARCH_IS_BIG_ENDIAN
00120 BSWAP(tmp);
00121 #endif
00122 return tmp;
00123 #endif
00124 }
00125
00126 static INLINE uint32_t faad_showbits(bitfile *ld, uint32_t bits)
00127 {
00128 if (bits <= ld->bits_left)
00129 {
00130 return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits];
00131 }
00132
00133 bits -= ld->bits_left;
00134 return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits));
00135 }
00136
00137 static INLINE void faad_flushbits(bitfile *ld, uint32_t bits)
00138 {
00139
00140 if (ld->error != 0)
00141 return;
00142
00143 if (bits < ld->bits_left)
00144 {
00145 ld->bits_left -= bits;
00146 } else {
00147 faad_flushbits_ex(ld, bits);
00148 }
00149 }
00150
00151
00152 static INLINE uint32_t faad_getbits(bitfile *ld, uint32_t n DEBUGDEC)
00153 {
00154 uint32_t ret;
00155
00156 if (ld->no_more_reading || n == 0)
00157 return 0;
00158
00159 ret = faad_showbits(ld, n);
00160 faad_flushbits(ld, n);
00161
00162 #ifdef ANALYSIS
00163 if (print)
00164 fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg);
00165 #endif
00166
00167 return ret;
00168 }
00169
00170 static INLINE uint8_t faad_get1bit(bitfile *ld DEBUGDEC)
00171 {
00172 uint8_t r;
00173
00174 if (ld->bits_left > 0)
00175 {
00176 ld->bits_left--;
00177 r = (uint8_t)((ld->bufa >> ld->bits_left) & 1);
00178 return r;
00179 }
00180
00181
00182 #if 0
00183 r = (uint8_t)(ld->bufb >> 31);
00184 faad_flushbits_ex(ld, 1);
00185 #else
00186 r = (uint8_t)faad_getbits(ld, 1);
00187 #endif
00188 return r;
00189 }
00190
00191
00192 static INLINE uint32_t faad_showbits_rev(bitfile *ld, uint32_t bits)
00193 {
00194 uint8_t i;
00195 uint32_t B = 0;
00196
00197 if (bits <= ld->bits_left)
00198 {
00199 for (i = 0; i < bits; i++)
00200 {
00201 if (ld->bufa & (1 << (i + (32 - ld->bits_left))))
00202 B |= (1 << (bits - i - 1));
00203 }
00204 return B;
00205 } else {
00206 for (i = 0; i < ld->bits_left; i++)
00207 {
00208 if (ld->bufa & (1 << (i + (32 - ld->bits_left))))
00209 B |= (1 << (bits - i - 1));
00210 }
00211 for (i = 0; i < bits - ld->bits_left; i++)
00212 {
00213 if (ld->bufb & (1 << (i + (32-ld->bits_left))))
00214 B |= (1 << (bits - ld->bits_left - i - 1));
00215 }
00216 return B;
00217 }
00218 }
00219
00220 static INLINE void faad_flushbits_rev(bitfile *ld, uint32_t bits)
00221 {
00222
00223 if (ld->error != 0)
00224 return;
00225
00226 if (bits < ld->bits_left)
00227 {
00228 ld->bits_left -= bits;
00229 } else {
00230 uint32_t tmp;
00231
00232 ld->bufa = ld->bufb;
00233 tmp = getdword(ld->start);
00234 ld->bufb = tmp;
00235 ld->start--;
00236 ld->bits_left += (32 - bits);
00237
00238 ld->bytes_used += 4;
00239 if (ld->bytes_used == ld->buffer_size)
00240 ld->no_more_reading = 1;
00241 if (ld->bytes_used > ld->buffer_size)
00242 ld->error = 1;
00243 }
00244 }
00245
00246 static INLINE uint32_t faad_getbits_rev(bitfile *ld, uint32_t n
00247 DEBUGDEC)
00248 {
00249 uint32_t ret;
00250
00251 if (ld->no_more_reading)
00252 return 0;
00253
00254 if (n == 0)
00255 return 0;
00256
00257 ret = faad_showbits_rev(ld, n);
00258 faad_flushbits_rev(ld, n);
00259
00260 #ifdef ANALYSIS
00261 if (print)
00262 fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg);
00263 #endif
00264
00265 return ret;
00266 }
00267
00268 #ifdef DRM
00269 static uint8_t faad_check_CRC(bitfile *ld, uint16_t len)
00270 {
00271 uint8_t CRC;
00272 uint16_t r=255;
00273
00274
00275 #define GPOLY 0435
00276
00277 faad_rewindbits(ld);
00278
00279 CRC = (uint8_t) ~faad_getbits(ld, 8
00280 DEBUGVAR(1,999,"faad_check_CRC(): CRC"));
00281
00282 for (; len>0; len--)
00283 {
00284 r = ( (r << 1) ^ (( ( faad_get1bit(ld
00285 DEBUGVAR(1,998,"")) & 1) ^ ((r >> 7) & 1)) * GPOLY )) & 0xFF;
00286 }
00287
00288 if (r != CRC)
00289
00290 {
00291 return 28;
00292 } else {
00293 return 0;
00294 }
00295 }
00296
00297 static uint8_t tabFlipbits[256] = {
00298 0,128,64,192,32,160,96,224,16,144,80,208,48,176,112,240,
00299 8,136,72,200,40,168,104,232,24,152,88,216,56,184,120,248,
00300 4,132,68,196,36,164,100,228,20,148,84,212,52,180,116,244,
00301 12,140,76,204,44,172,108,236,28,156,92,220,60,188,124,252,
00302 2,130,66,194,34,162,98,226,18,146,82,210,50,178,114,242,
00303 10,138,74,202,42,170,106,234,26,154,90,218,58,186,122,250,
00304 6,134,70,198,38,166,102,230,22,150,86,214,54,182,118,246,
00305 14,142,78,206,46,174,110,238,30,158,94,222,62,190,126,254,
00306 1,129,65,193,33,161,97,225,17,145,81,209,49,177,113,241,
00307 9,137,73,201,41,169,105,233,25,153,89,217,57,185,121,249,
00308 5,133,69,197,37,165,101,229,21,149,85,213,53,181,117,245,
00309 13,141,77,205,45,173,109,237,29,157,93,221,61,189,125,253,
00310 3,131,67,195,35,163,99,227,19,147,83,211,51,179,115,243,
00311 11,139,75,203,43,171,107,235,27,155,91,219,59,187,123,251,
00312 7,135,71,199,39,167,103,231,23,151,87,215,55,183,119,247,
00313 15,143,79,207,47,175,111,239,31,159,95,223,63,191,127,255
00314 };
00315 #endif
00316
00317 #ifdef ERROR_RESILIENCE
00318
00319
00320
00321 typedef struct
00322 {
00323
00324 uint32_t bufa;
00325 uint32_t bufb;
00326 int8_t len;
00327 } bits_t;
00328
00329
00330 static INLINE uint32_t showbits_hcr(bits_t *ld, uint8_t bits)
00331 {
00332 if (bits == 0) return 0;
00333 if (ld->len <= 32)
00334 {
00335
00336
00337 if (ld->len >= bits)
00338 return ((ld->bufa >> (ld->len - bits)) & (0xFFFFFFFF >> (32 - bits)));
00339 else
00340 return ((ld->bufa << (bits - ld->len)) & (0xFFFFFFFF >> (32 - bits)));
00341 } else {
00342 if ((ld->len - bits) < 32)
00343 {
00344 return ( (ld->bufb & (0xFFFFFFFF >> (64 - ld->len))) << (bits - ld->len + 32)) |
00345 (ld->bufa >> (ld->len - bits));
00346 } else {
00347 return ((ld->bufb >> (ld->len - bits - 32)) & (0xFFFFFFFF >> (32 - bits)));
00348 }
00349 }
00350 }
00351
00352
00353 static INLINE int8_t flushbits_hcr( bits_t *ld, uint8_t bits)
00354 {
00355 ld->len -= bits;
00356
00357 if (ld->len <0)
00358 {
00359 ld->len = 0;
00360 return 1;
00361 } else {
00362 return 0;
00363 }
00364 }
00365
00366 static INLINE int8_t getbits_hcr(bits_t *ld, uint8_t n, uint32_t *result)
00367 {
00368 *result = showbits_hcr(ld, n);
00369 return flushbits_hcr(ld, n);
00370 }
00371
00372 static INLINE int8_t get1bit_hcr(bits_t *ld, uint8_t *result)
00373 {
00374 uint32_t res;
00375 int8_t ret;
00376
00377 ret = getbits_hcr(ld, 1, &res);
00378 *result = (int8_t)(res & 1);
00379 return ret;
00380 }
00381
00382 #endif
00383
00384
00385 #ifdef __cplusplus
00386 }
00387 #endif
00388 #endif