Mercurial > mplayer.hg
comparison libfaad2/bits.h @ 10989:3185f64f6350
synced with current cvs
author | alex |
---|---|
date | Fri, 03 Oct 2003 22:23:26 +0000 |
parents | 125a35fc47a5 |
children | 4a370c80fe5c |
comparison
equal
deleted
inserted
replaced
10988:c2bff70784d5 | 10989:3185f64f6350 |
---|---|
77 void faad_endbits(bitfile *ld); | 77 void faad_endbits(bitfile *ld); |
78 void faad_initbits_rev(bitfile *ld, void *buffer, | 78 void faad_initbits_rev(bitfile *ld, void *buffer, |
79 uint32_t bits_in_buffer); | 79 uint32_t bits_in_buffer); |
80 uint8_t faad_byte_align(bitfile *ld); | 80 uint8_t faad_byte_align(bitfile *ld); |
81 uint32_t faad_get_processed_bits(bitfile *ld); | 81 uint32_t faad_get_processed_bits(bitfile *ld); |
82 void faad_flushbits_ex(bitfile *ld, uint32_t bits); | |
82 void faad_rewindbits(bitfile *ld); | 83 void faad_rewindbits(bitfile *ld); |
83 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits | 84 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits |
84 DEBUGDEC); | 85 DEBUGDEC); |
85 | 86 |
86 /* circumvent memory alignment errors on ARM */ | 87 /* circumvent memory alignment errors on ARM */ |
102 static INLINE uint32_t faad_showbits(bitfile *ld, uint32_t bits) | 103 static INLINE uint32_t faad_showbits(bitfile *ld, uint32_t bits) |
103 { | 104 { |
104 if (bits <= ld->bits_left) | 105 if (bits <= ld->bits_left) |
105 { | 106 { |
106 return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; | 107 return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; |
107 } else { | 108 } |
109 | |
108 bits -= ld->bits_left; | 110 bits -= ld->bits_left; |
109 return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); | 111 return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); |
110 } | |
111 } | 112 } |
112 | 113 |
113 static INLINE void faad_flushbits(bitfile *ld, uint32_t bits) | 114 static INLINE void faad_flushbits(bitfile *ld, uint32_t bits) |
114 { | 115 { |
115 /* do nothing if error */ | 116 /* do nothing if error */ |
118 | 119 |
119 if (bits < ld->bits_left) | 120 if (bits < ld->bits_left) |
120 { | 121 { |
121 ld->bits_left -= bits; | 122 ld->bits_left -= bits; |
122 } else { | 123 } else { |
123 uint32_t tmp; | 124 faad_flushbits_ex(ld, bits); |
124 | |
125 ld->bufa = ld->bufb; | |
126 tmp = getdword(ld->tail); | |
127 ld->tail++; | |
128 #ifndef ARCH_IS_BIG_ENDIAN | |
129 BSWAP(tmp); | |
130 #endif | |
131 ld->bufb = tmp; | |
132 ld->bits_left += (32 - bits); | |
133 ld->bytes_used += 4; | |
134 if (ld->bytes_used == ld->buffer_size) | |
135 ld->no_more_reading = 1; | |
136 if (ld->bytes_used > ld->buffer_size) | |
137 ld->error = 1; | |
138 } | 125 } |
139 } | 126 } |
140 | 127 |
141 /* return next n bits (right adjusted) */ | 128 /* return next n bits (right adjusted) */ |
142 static INLINE uint32_t faad_getbits(bitfile *ld, uint32_t n DEBUGDEC) | 129 static INLINE uint32_t faad_getbits(bitfile *ld, uint32_t n DEBUGDEC) |
143 { | 130 { |
144 uint32_t ret; | 131 uint32_t ret; |
145 | 132 |
146 if (ld->no_more_reading) | 133 if (ld->no_more_reading || n == 0) |
147 return 0; | |
148 | |
149 if (n == 0) | |
150 return 0; | 134 return 0; |
151 | 135 |
152 ret = faad_showbits(ld, n); | 136 ret = faad_showbits(ld, n); |
153 faad_flushbits(ld, n); | 137 faad_flushbits(ld, n); |
154 | 138 |
251 #endif | 235 #endif |
252 | 236 |
253 return ret; | 237 return ret; |
254 } | 238 } |
255 | 239 |
240 #ifdef DRM | |
241 static uint8_t faad_check_CRC(bitfile *ld, uint16_t len) | |
242 { | |
243 uint8_t CRC; | |
244 uint16_t r=255; /* Initialize to all ones */ | |
245 | |
246 /* CRC polynome used x^8 + x^4 + x^3 + x^2 +1 */ | |
247 #define GPOLY 0435 | |
248 | |
249 faad_rewindbits(ld); | |
250 | |
251 CRC = ~faad_getbits(ld, 8 | |
252 DEBUGVAR(1,999,"faad_check_CRC(): CRC")); /* CRC is stored inverted */ | |
253 | |
254 for (; len>0; len--) | |
255 { | |
256 r = ( (r << 1) ^ (( ( faad_get1bit(ld | |
257 DEBUGVAR(1,998,"")) & 1) ^ ((r >> 7) & 1)) * GPOLY )) & 0xFF; | |
258 } | |
259 | |
260 if (r != CRC) | |
261 { | |
262 return 8; | |
263 } else { | |
264 return 0; | |
265 } | |
266 } | |
267 | |
268 static uint8_t tabFlipbits[256] = { | |
269 0,128,64,192,32,160,96,224,16,144,80,208,48,176,112,240, | |
270 8,136,72,200,40,168,104,232,24,152,88,216,56,184,120,248, | |
271 4,132,68,196,36,164,100,228,20,148,84,212,52,180,116,244, | |
272 12,140,76,204,44,172,108,236,28,156,92,220,60,188,124,252, | |
273 2,130,66,194,34,162,98,226,18,146,82,210,50,178,114,242, | |
274 10,138,74,202,42,170,106,234,26,154,90,218,58,186,122,250, | |
275 6,134,70,198,38,166,102,230,22,150,86,214,54,182,118,246, | |
276 14,142,78,206,46,174,110,238,30,158,94,222,62,190,126,254, | |
277 1,129,65,193,33,161,97,225,17,145,81,209,49,177,113,241, | |
278 9,137,73,201,41,169,105,233,25,153,89,217,57,185,121,249, | |
279 5,133,69,197,37,165,101,229,21,149,85,213,53,181,117,245, | |
280 13,141,77,205,45,173,109,237,29,157,93,221,61,189,125,253, | |
281 3,131,67,195,35,163,99,227,19,147,83,211,51,179,115,243, | |
282 11,139,75,203,43,171,107,235,27,155,91,219,59,187,123,251, | |
283 7,135,71,199,39,167,103,231,23,151,87,215,55,183,119,247, | |
284 15,143,79,207,47,175,111,239,31,159,95,223,63,191,127,255 | |
285 }; | |
286 #endif | |
287 | |
288 #ifdef ERROR_RESILIENCE | |
289 | |
290 /* Modified bit reading functions for HCR */ | |
291 | |
292 typedef struct | |
293 { | |
294 /* bit input */ | |
295 uint32_t bufa; | |
296 uint32_t bufb; | |
297 int8_t len; | |
298 } bits_t; | |
299 | |
300 | |
301 static INLINE uint32_t showbits_hcr(bits_t *ld, uint8_t bits) | |
302 { | |
303 if (bits == 0) return 0; | |
304 if (ld->len <= 32) | |
305 { | |
306 /* huffman_spectral_data_2 needs to read more than may be available, bits maybe | |
307 > ld->len, deliver 0 than */ | |
308 if (ld->len >= bits) | |
309 return ((ld->bufa >> (ld->len - bits)) & (0xFFFFFFFF >> (32 - bits))); | |
310 else | |
311 return ((ld->bufa << (bits - ld->len)) & (0xFFFFFFFF >> (32 - bits))); | |
312 } else { | |
313 if ((ld->len - bits) < 32) | |
314 { | |
315 return ( (ld->bufb & (0xFFFFFFFF >> (64 - ld->len))) << (bits - ld->len + 32)) | | |
316 (ld->bufa >> (ld->len - bits)); | |
317 } else { | |
318 return ((ld->bufb >> (ld->len - bits - 32)) & (0xFFFFFFFF >> (32 - bits))); | |
319 } | |
320 } | |
321 } | |
322 | |
323 /* return 1 if position is outside of buffer, 0 otherwise */ | |
324 static INLINE int8_t flushbits_hcr( bits_t *ld, uint8_t bits) | |
325 { | |
326 ld->len -= bits; | |
327 | |
328 if (ld->len <0) | |
329 { | |
330 ld->len = 0; | |
331 return 1; | |
332 } else { | |
333 return 0; | |
334 } | |
335 } | |
336 | |
337 static INLINE int8_t getbits_hcr(bits_t *ld, uint8_t n, uint32_t *result) | |
338 { | |
339 *result = showbits_hcr(ld, n); | |
340 return flushbits_hcr(ld, n); | |
341 } | |
342 | |
343 static INLINE int8_t get1bit_hcr(bits_t *ld, uint8_t *result) | |
344 { | |
345 uint32_t res; | |
346 int8_t ret; | |
347 | |
348 ret = getbits_hcr(ld, 1, &res); | |
349 *result = (int8_t)(res & 1); | |
350 return ret; | |
351 } | |
352 | |
353 #endif | |
354 | |
256 | 355 |
257 #ifdef __cplusplus | 356 #ifdef __cplusplus |
258 } | 357 } |
259 #endif | 358 #endif |
260 #endif | 359 #endif |