1 /*
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2005 M. Bakker, Nero 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 ** The "appropriate copyright message" mentioned in section 2c of the GPLv2
23 ** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
24 **
25 ** Commercial non-GPL licensing of this software is possible.
26 ** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
27 **
28 ** $Id: bits.h,v 1.45 2007/11/01 12:33:29 menno Exp $
29 **/
30
31 #ifndef __BITS_H__
32 #define __BITS_H__
33
34 #ifdef __cplusplus
35 extern "C" {
36 #endif
37
38 #include "analysis.h"
39 #ifdef ANALYSIS
40 #include <stdio.h>
41 #endif
42
43 #define BYTE_NUMBIT 8
44 #define BYTE_NUMBIT_LD 3
45 //#define bit2byte(a) ((a+7)/BYTE_NUMBIT)
46 #define bit2byte(a) ((a+7)>>BYTE_NUMBIT_LD)
47
48 typedef struct _bitfile
49 {
50 /* bit input */
51 uint32_t bufa;
52 uint32_t bufb;
53 uint32_t bits_left;
54 uint32_t buffer_size; /* size of the buffer in bytes */
55 uint32_t bytes_left;
56 uint8_t error;
57 uint32_t *tail;
58 uint32_t *start;
59 const void *buffer;
60 } bitfile;
61
62
63 #if 0
64 static uint32_t const bitmask[] = {
65 0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF,
66 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF,
67 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF,
68 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF,
69 0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF
70 /* added bitmask 32, correct?!?!?! */
71 , 0xFFFFFFFF
72 };
73 #endif
74
75 void faad_initbits(bitfile *ld, const void *buffer, const uint32_t buffer_size);
76 void faad_endbits(bitfile *ld);
77 void faad_initbits_rev(bitfile *ld, void *buffer,
78 uint32_t bits_in_buffer);
79 uint8_t faad_byte_align(bitfile *ld);
80 uint32_t faad_get_processed_bits(bitfile *ld);
81 void faad_flushbits_ex(bitfile *ld, uint32_t bits);
82 void faad_rewindbits(bitfile *ld);
83 void faad_resetbits(bitfile *ld, int bits);
84 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits
85 DEBUGDEC);
86 #ifdef DRM
87 void *faad_origbitbuffer(bitfile *ld);
88 uint32_t faad_origbitbuffer_size(bitfile *ld);
89 #endif
90
91 /* circumvent memory alignment errors on ARM */
getdword(void * mem)92 static INLINE uint32_t getdword(void *mem)
93 {
94 uint32_t tmp;
95 #ifndef ARCH_IS_BIG_ENDIAN
96 ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[3];
97 ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[2];
98 ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[1];
99 ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[0];
100 #else
101 ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[0];
102 ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[1];
103 ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[2];
104 ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[3];
105 #endif
106
107 return tmp;
108 }
109
110 /* reads only n bytes from the stream instead of the standard 4 */
getdword_n(void * mem,int n)111 static /*INLINE*/ uint32_t getdword_n(void *mem, int n)
112 {
113 uint32_t tmp = 0;
114 #ifndef ARCH_IS_BIG_ENDIAN
115 switch (n)
116 {
117 case 3:
118 ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[2];
119 case 2:
120 ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[1];
121 case 1:
122 ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[0];
123 default:
124 break;
125 }
126 #else
127 switch (n)
128 {
129 case 3:
130 ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[2];
131 case 2:
132 ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[1];
133 case 1:
134 ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[0];
135 default:
136 break;
137 }
138 #endif
139
140 return tmp;
141 }
142
faad_showbits(bitfile * ld,uint32_t bits)143 static INLINE uint32_t faad_showbits(bitfile *ld, uint32_t bits)
144 {
145 if (bits <= ld->bits_left)
146 {
147 //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits];
148 return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits);
149 }
150
151 bits -= ld->bits_left;
152 //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits));
153 return ((ld->bufa & ((1<<ld->bits_left)-1)) << bits) | (ld->bufb >> (32 - bits));
154 }
155
faad_flushbits(bitfile * ld,uint32_t bits)156 static INLINE void faad_flushbits(bitfile *ld, uint32_t bits)
157 {
158 /* do nothing if error */
159 if (ld->error != 0)
160 return;
161
162 if (bits < ld->bits_left)
163 {
164 ld->bits_left -= bits;
165 } else {
166 faad_flushbits_ex(ld, bits);
167 }
168 }
169
170 /* return next n bits (right adjusted) */
faad_getbits(bitfile * ld,uint32_t n DEBUGDEC)171 static /*INLINE*/ uint32_t faad_getbits(bitfile *ld, uint32_t n DEBUGDEC)
172 {
173 uint32_t ret;
174
175 if (n == 0)
176 return 0;
177
178 ret = faad_showbits(ld, n);
179 faad_flushbits(ld, n);
180
181 #ifdef ANALYSIS
182 if (print)
183 fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg);
184 #endif
185
186 return ret;
187 }
188
faad_get1bit(bitfile * ld DEBUGDEC)189 static INLINE uint8_t faad_get1bit(bitfile *ld DEBUGDEC)
190 {
191 uint8_t r;
192
193 if (ld->bits_left > 0)
194 {
195 ld->bits_left--;
196 r = (uint8_t)((ld->bufa >> ld->bits_left) & 1);
197 return r;
198 }
199
200 /* bits_left == 0 */
201 #if 0
202 r = (uint8_t)(ld->bufb >> 31);
203 faad_flushbits_ex(ld, 1);
204 #else
205 r = (uint8_t)faad_getbits(ld, 1);
206 #endif
207 return r;
208 }
209
210 /* reversed bitreading routines */
faad_showbits_rev(bitfile * ld,uint32_t bits)211 static INLINE uint32_t faad_showbits_rev(bitfile *ld, uint32_t bits)
212 {
213 uint8_t i;
214 uint32_t B = 0;
215
216 if (bits <= ld->bits_left)
217 {
218 for (i = 0; i < bits; i++)
219 {
220 if (ld->bufa & (1 << (i + (32 - ld->bits_left))))
221 B |= (1 << (bits - i - 1));
222 }
223 return B;
224 } else {
225 for (i = 0; i < ld->bits_left; i++)
226 {
227 if (ld->bufa & (1 << (i + (32 - ld->bits_left))))
228 B |= (1 << (bits - i - 1));
229 }
230 for (i = 0; i < bits - ld->bits_left; i++)
231 {
232 if (ld->bufb & (1 << (i + (32-ld->bits_left))))
233 B |= (1 << (bits - ld->bits_left - i - 1));
234 }
235 return B;
236 }
237 }
238
faad_flushbits_rev(bitfile * ld,uint32_t bits)239 static INLINE void faad_flushbits_rev(bitfile *ld, uint32_t bits)
240 {
241 /* do nothing if error */
242 if (ld->error != 0)
243 return;
244
245 if (bits < ld->bits_left)
246 {
247 ld->bits_left -= bits;
248 } else {
249 uint32_t tmp;
250
251 ld->bufa = ld->bufb;
252 tmp = getdword(ld->start);
253 ld->bufb = tmp;
254 ld->start--;
255 ld->bits_left += (32 - bits);
256
257 if (ld->bytes_left < 4)
258 {
259 ld->error = 1;
260 ld->bytes_left = 0;
261 } else {
262 ld->bytes_left -= 4;
263 }
264 // if (ld->bytes_left == 0)
265 // ld->no_more_reading = 1;
266 }
267 }
268
faad_getbits_rev(bitfile * ld,uint32_t n DEBUGDEC)269 static /*INLINE*/ uint32_t faad_getbits_rev(bitfile *ld, uint32_t n
270 DEBUGDEC)
271 {
272 uint32_t ret;
273
274 if (n == 0)
275 return 0;
276
277 ret = faad_showbits_rev(ld, n);
278 faad_flushbits_rev(ld, n);
279
280 #ifdef ANALYSIS
281 if (print)
282 fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg);
283 #endif
284
285 return ret;
286 }
287
288 #ifdef DRM
289 /* CRC lookup table for G8 polynome in DRM standard */
290 static const uint8_t crc_table_G8[256] = {
291 0x0, 0x1d, 0x3a, 0x27, 0x74, 0x69, 0x4e, 0x53,
292 0xe8, 0xf5, 0xd2, 0xcf, 0x9c, 0x81, 0xa6, 0xbb,
293 0xcd, 0xd0, 0xf7, 0xea, 0xb9, 0xa4, 0x83, 0x9e,
294 0x25, 0x38, 0x1f, 0x2, 0x51, 0x4c, 0x6b, 0x76,
295 0x87, 0x9a, 0xbd, 0xa0, 0xf3, 0xee, 0xc9, 0xd4,
296 0x6f, 0x72, 0x55, 0x48, 0x1b, 0x6, 0x21, 0x3c,
297 0x4a, 0x57, 0x70, 0x6d, 0x3e, 0x23, 0x4, 0x19,
298 0xa2, 0xbf, 0x98, 0x85, 0xd6, 0xcb, 0xec, 0xf1,
299 0x13, 0xe, 0x29, 0x34, 0x67, 0x7a, 0x5d, 0x40,
300 0xfb, 0xe6, 0xc1, 0xdc, 0x8f, 0x92, 0xb5, 0xa8,
301 0xde, 0xc3, 0xe4, 0xf9, 0xaa, 0xb7, 0x90, 0x8d,
302 0x36, 0x2b, 0xc, 0x11, 0x42, 0x5f, 0x78, 0x65,
303 0x94, 0x89, 0xae, 0xb3, 0xe0, 0xfd, 0xda, 0xc7,
304 0x7c, 0x61, 0x46, 0x5b, 0x8, 0x15, 0x32, 0x2f,
305 0x59, 0x44, 0x63, 0x7e, 0x2d, 0x30, 0x17, 0xa,
306 0xb1, 0xac, 0x8b, 0x96, 0xc5, 0xd8, 0xff, 0xe2,
307 0x26, 0x3b, 0x1c, 0x1, 0x52, 0x4f, 0x68, 0x75,
308 0xce, 0xd3, 0xf4, 0xe9, 0xba, 0xa7, 0x80, 0x9d,
309 0xeb, 0xf6, 0xd1, 0xcc, 0x9f, 0x82, 0xa5, 0xb8,
310 0x3, 0x1e, 0x39, 0x24, 0x77, 0x6a, 0x4d, 0x50,
311 0xa1, 0xbc, 0x9b, 0x86, 0xd5, 0xc8, 0xef, 0xf2,
312 0x49, 0x54, 0x73, 0x6e, 0x3d, 0x20, 0x7, 0x1a,
313 0x6c, 0x71, 0x56, 0x4b, 0x18, 0x5, 0x22, 0x3f,
314 0x84, 0x99, 0xbe, 0xa3, 0xf0, 0xed, 0xca, 0xd7,
315 0x35, 0x28, 0xf, 0x12, 0x41, 0x5c, 0x7b, 0x66,
316 0xdd, 0xc0, 0xe7, 0xfa, 0xa9, 0xb4, 0x93, 0x8e,
317 0xf8, 0xe5, 0xc2, 0xdf, 0x8c, 0x91, 0xb6, 0xab,
318 0x10, 0xd, 0x2a, 0x37, 0x64, 0x79, 0x5e, 0x43,
319 0xb2, 0xaf, 0x88, 0x95, 0xc6, 0xdb, 0xfc, 0xe1,
320 0x5a, 0x47, 0x60, 0x7d, 0x2e, 0x33, 0x14, 0x9,
321 0x7f, 0x62, 0x45, 0x58, 0xb, 0x16, 0x31, 0x2c,
322 0x97, 0x8a, 0xad, 0xb0, 0xe3, 0xfe, 0xd9, 0xc4,
323 };
324
faad_check_CRC(bitfile * ld,uint16_t len)325 static uint8_t faad_check_CRC(bitfile *ld, uint16_t len)
326 {
327 int bytes, rem;
328 unsigned int CRC;
329 unsigned int r=255; /* Initialize to all ones */
330
331 /* CRC polynome used x^8 + x^4 + x^3 + x^2 +1 */
332 #define GPOLY 0435
333
334 faad_rewindbits(ld);
335
336 CRC = (unsigned int) ~faad_getbits(ld, 8
337 DEBUGVAR(1,999,"faad_check_CRC(): CRC")) & 0xFF; /* CRC is stored inverted */
338
339 bytes = len >> 3;
340 rem = len & 0x7;
341
342 for (; bytes > 0; bytes--)
343 {
344 r = crc_table_G8[( r ^ faad_getbits(ld, 8 DEBUGVAR(1,998,"")) ) & 0xFF];
345 }
346 for (; rem > 0; rem--)
347 {
348 r = ( (r << 1) ^ (( ( faad_get1bit(ld
349 DEBUGVAR(1,998,"")) & 1) ^ ((r >> 7) & 1)) * GPOLY )) & 0xFF;
350 }
351
352 if (r != CRC)
353 // if (0)
354 {
355 return 28;
356 } else {
357 return 0;
358 }
359 }
360
361 static uint8_t tabFlipbits[256] = {
362 0,128,64,192,32,160,96,224,16,144,80,208,48,176,112,240,
363 8,136,72,200,40,168,104,232,24,152,88,216,56,184,120,248,
364 4,132,68,196,36,164,100,228,20,148,84,212,52,180,116,244,
365 12,140,76,204,44,172,108,236,28,156,92,220,60,188,124,252,
366 2,130,66,194,34,162,98,226,18,146,82,210,50,178,114,242,
367 10,138,74,202,42,170,106,234,26,154,90,218,58,186,122,250,
368 6,134,70,198,38,166,102,230,22,150,86,214,54,182,118,246,
369 14,142,78,206,46,174,110,238,30,158,94,222,62,190,126,254,
370 1,129,65,193,33,161,97,225,17,145,81,209,49,177,113,241,
371 9,137,73,201,41,169,105,233,25,153,89,217,57,185,121,249,
372 5,133,69,197,37,165,101,229,21,149,85,213,53,181,117,245,
373 13,141,77,205,45,173,109,237,29,157,93,221,61,189,125,253,
374 3,131,67,195,35,163,99,227,19,147,83,211,51,179,115,243,
375 11,139,75,203,43,171,107,235,27,155,91,219,59,187,123,251,
376 7,135,71,199,39,167,103,231,23,151,87,215,55,183,119,247,
377 15,143,79,207,47,175,111,239,31,159,95,223,63,191,127,255
378 };
379 #endif
380
381 #ifdef ERROR_RESILIENCE
382
383 /* Modified bit reading functions for HCR */
384
385 typedef struct
386 {
387 /* bit input */
388 uint32_t bufa;
389 uint32_t bufb;
390 int8_t len;
391 } bits_t;
392
393
showbits_hcr(bits_t * ld,uint8_t bits)394 static INLINE uint32_t showbits_hcr(bits_t *ld, uint8_t bits)
395 {
396 if (bits == 0) return 0;
397 if (ld->len <= 32)
398 {
399 /* huffman_spectral_data_2 needs to read more than may be available, bits maybe
400 > ld->len, deliver 0 than */
401 if (ld->len >= bits)
402 return ((ld->bufa >> (ld->len - bits)) & (0xFFFFFFFF >> (32 - bits)));
403 else
404 return ((ld->bufa << (bits - ld->len)) & (0xFFFFFFFF >> (32 - bits)));
405 } else {
406 if ((ld->len - bits) < 32)
407 {
408 return ( (ld->bufb & (0xFFFFFFFF >> (64 - ld->len))) << (bits - ld->len + 32)) |
409 (ld->bufa >> (ld->len - bits));
410 } else {
411 return ((ld->bufb >> (ld->len - bits - 32)) & (0xFFFFFFFF >> (32 - bits)));
412 }
413 }
414 }
415
416 /* return 1 if position is outside of buffer, 0 otherwise */
flushbits_hcr(bits_t * ld,uint8_t bits)417 static INLINE int8_t flushbits_hcr( bits_t *ld, uint8_t bits)
418 {
419 ld->len -= bits;
420
421 if (ld->len <0)
422 {
423 ld->len = 0;
424 return 1;
425 } else {
426 return 0;
427 }
428 }
429
getbits_hcr(bits_t * ld,uint8_t n,uint32_t * result)430 static INLINE int8_t getbits_hcr(bits_t *ld, uint8_t n, uint32_t *result)
431 {
432 *result = showbits_hcr(ld, n);
433 return flushbits_hcr(ld, n);
434 }
435
get1bit_hcr(bits_t * ld,uint8_t * result)436 static INLINE int8_t get1bit_hcr(bits_t *ld, uint8_t *result)
437 {
438 uint32_t res;
439 int8_t ret;
440
441 ret = getbits_hcr(ld, 1, &res);
442 *result = (int8_t)(res & 1);
443 return ret;
444 }
445
446 #endif
447
448
449 #ifdef __cplusplus
450 }
451 #endif
452 #endif
453