Mercurial > mplayer.hg
annotate libfaad2/bits.h @ 11744:70b8047bc7df
sync, tested :-P
BTW, xml/pl fails to compile.
author | nauj27 |
---|---|
date | Mon, 05 Jan 2004 10:39:04 +0000 |
parents | 3185f64f6350 |
children | 4a370c80fe5c |
rev | line source |
---|---|
10725 | 1 /* |
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding | |
3 ** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com | |
4 ** | |
5 ** This program is free software; you can redistribute it and/or modify | |
6 ** it under the terms of the GNU General Public License as published by | |
7 ** the Free Software Foundation; either version 2 of the License, or | |
8 ** (at your option) any later version. | |
9 ** | |
10 ** This program is distributed in the hope that it will be useful, | |
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 ** GNU General Public License for more details. | |
14 ** | |
15 ** You should have received a copy of the GNU General Public License | |
16 ** along with this program; if not, write to the Free Software | |
17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
18 ** | |
19 ** Any non-GPL usage of this software or parts of this software is strictly | |
20 ** forbidden. | |
21 ** | |
22 ** Commercial non-GPL licensing of this software is possible. | |
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. | |
24 ** | |
25 ** $Id$ | |
26 **/ | |
27 | |
28 #ifndef __BITS_H__ | |
29 #define __BITS_H__ | |
30 | |
31 #ifdef __cplusplus | |
32 extern "C" { | |
33 #endif | |
34 | |
35 #include "analysis.h" | |
36 #ifdef ANALYSIS | |
37 #include <stdio.h> | |
38 #endif | |
39 | |
40 #define BYTE_NUMBIT 8 | |
41 #define bit2byte(a) ((a+7)/BYTE_NUMBIT) | |
42 | |
43 typedef struct _bitfile | |
44 { | |
45 /* bit input */ | |
46 uint32_t bufa; | |
47 uint32_t bufb; | |
48 uint32_t bits_left; | |
49 uint32_t buffer_size; /* size of the buffer in bytes */ | |
50 uint32_t bytes_used; | |
51 uint8_t no_more_reading; | |
52 uint8_t error; | |
53 uint32_t *tail; | |
54 uint32_t *start; | |
55 void *buffer; | |
56 } bitfile; | |
57 | |
58 | |
10805
125a35fc47a5
fixed win32 compile problems and broken bigendian support
alex
parents:
10725
diff
changeset
|
59 #if defined (_WIN32) && !defined(_WIN32_WCE) && !defined(__GNUC__) |
10725 | 60 #define BSWAP(a) __asm mov eax,a __asm bswap eax __asm mov a, eax |
10805
125a35fc47a5
fixed win32 compile problems and broken bigendian support
alex
parents:
10725
diff
changeset
|
61 #elif defined(ARCH_X86) && (defined(DJGPP) || defined(__GNUC__)) |
10725 | 62 #define BSWAP(a) __asm__ ( "bswapl %0\n" : "=r" (a) : "0" (a) ) |
63 #else | |
64 #define BSWAP(a) \ | |
65 ((a) = ( ((a)&0xff)<<24) | (((a)&0xff00)<<8) | (((a)>>8)&0xff00) | (((a)>>24)&0xff)) | |
66 #endif | |
67 | |
68 static uint32_t bitmask[] = { | |
69 0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, | |
70 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, | |
71 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, | |
72 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, | |
73 0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF | |
74 }; | |
75 | |
76 void faad_initbits(bitfile *ld, void *buffer, uint32_t buffer_size); | |
77 void faad_endbits(bitfile *ld); | |
78 void faad_initbits_rev(bitfile *ld, void *buffer, | |
79 uint32_t bits_in_buffer); | |
80 uint8_t faad_byte_align(bitfile *ld); | |
81 uint32_t faad_get_processed_bits(bitfile *ld); | |
10989 | 82 void faad_flushbits_ex(bitfile *ld, uint32_t bits); |
10725 | 83 void faad_rewindbits(bitfile *ld); |
84 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits | |
85 DEBUGDEC); | |
86 | |
87 /* circumvent memory alignment errors on ARM */ | |
88 static INLINE uint32_t getdword(void *mem) | |
89 { | |
90 #ifdef ARM | |
91 uint32_t tmp; | |
92 ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[0]; | |
93 ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[1]; | |
94 ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[2]; | |
95 ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[3]; | |
96 | |
97 return tmp; | |
98 #else | |
99 return *(uint32_t*)mem; | |
100 #endif | |
101 } | |
102 | |
103 static INLINE uint32_t faad_showbits(bitfile *ld, uint32_t bits) | |
104 { | |
105 if (bits <= ld->bits_left) | |
106 { | |
107 return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits]; | |
10989 | 108 } |
109 | |
10725 | 110 bits -= ld->bits_left; |
111 return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits)); | |
112 } | |
113 | |
114 static INLINE void faad_flushbits(bitfile *ld, uint32_t bits) | |
115 { | |
116 /* do nothing if error */ | |
117 if (ld->error != 0) | |
118 return; | |
119 | |
120 if (bits < ld->bits_left) | |
121 { | |
122 ld->bits_left -= bits; | |
123 } else { | |
10989 | 124 faad_flushbits_ex(ld, bits); |
10725 | 125 } |
126 } | |
127 | |
128 /* return next n bits (right adjusted) */ | |
129 static INLINE uint32_t faad_getbits(bitfile *ld, uint32_t n DEBUGDEC) | |
130 { | |
131 uint32_t ret; | |
132 | |
10989 | 133 if (ld->no_more_reading || n == 0) |
10725 | 134 return 0; |
135 | |
136 ret = faad_showbits(ld, n); | |
137 faad_flushbits(ld, n); | |
138 | |
139 #ifdef ANALYSIS | |
140 if (print) | |
141 fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); | |
142 #endif | |
143 | |
144 return ret; | |
145 } | |
146 | |
147 static INLINE uint8_t faad_get1bit(bitfile *ld DEBUGDEC) | |
148 { | |
149 uint8_t r; | |
150 | |
151 if (ld->bits_left == 0) | |
152 return (uint8_t)faad_getbits(ld, 1 DEBUGVAR(print,var,dbg)); | |
153 | |
154 ld->bits_left--; | |
155 r = (uint8_t)((ld->bufa >> ld->bits_left) & 1); | |
156 | |
157 return r; | |
158 } | |
159 | |
160 /* reversed bitreading routines */ | |
161 static INLINE uint32_t faad_showbits_rev(bitfile *ld, uint32_t bits) | |
162 { | |
163 uint8_t i; | |
164 uint32_t B = 0; | |
165 | |
166 if (bits <= ld->bits_left) | |
167 { | |
168 for (i = 0; i < bits; i++) | |
169 { | |
170 if (ld->bufa & (1 << (i + (32 - ld->bits_left)))) | |
171 B |= (1 << (bits - i - 1)); | |
172 } | |
173 return B; | |
174 } else { | |
175 for (i = 0; i < ld->bits_left; i++) | |
176 { | |
177 if (ld->bufa & (1 << (i + (32 - ld->bits_left)))) | |
178 B |= (1 << (bits - i - 1)); | |
179 } | |
180 for (i = 0; i < bits - ld->bits_left; i++) | |
181 { | |
182 if (ld->bufb & (1 << (i + (32-ld->bits_left)))) | |
183 B |= (1 << (bits - ld->bits_left - i - 1)); | |
184 } | |
185 return B; | |
186 } | |
187 } | |
188 | |
189 static INLINE void faad_flushbits_rev(bitfile *ld, uint32_t bits) | |
190 { | |
191 /* do nothing if error */ | |
192 if (ld->error != 0) | |
193 return; | |
194 | |
195 if (bits < ld->bits_left) | |
196 { | |
197 ld->bits_left -= bits; | |
198 } else { | |
199 uint32_t tmp; | |
200 | |
201 ld->bufa = ld->bufb; | |
202 tmp = getdword(ld->start); | |
203 #ifndef ARCH_IS_BIG_ENDIAN | |
204 BSWAP(tmp); | |
205 #endif | |
206 ld->bufb = tmp; | |
207 ld->start--; | |
208 ld->bits_left += (32 - bits); | |
209 | |
210 ld->bytes_used += 4; | |
211 if (ld->bytes_used == ld->buffer_size) | |
212 ld->no_more_reading = 1; | |
213 if (ld->bytes_used > ld->buffer_size) | |
214 ld->error = 1; | |
215 } | |
216 } | |
217 | |
218 static INLINE uint32_t faad_getbits_rev(bitfile *ld, uint32_t n | |
219 DEBUGDEC) | |
220 { | |
221 uint32_t ret; | |
222 | |
223 if (ld->no_more_reading) | |
224 return 0; | |
225 | |
226 if (n == 0) | |
227 return 0; | |
228 | |
229 ret = faad_showbits_rev(ld, n); | |
230 faad_flushbits_rev(ld, n); | |
231 | |
232 #ifdef ANALYSIS | |
233 if (print) | |
234 fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg); | |
235 #endif | |
236 | |
237 return ret; | |
238 } | |
239 | |
10989 | 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 | |
10725 | 355 |
356 #ifdef __cplusplus | |
357 } | |
358 #endif | |
359 #endif |