ffmpeg / libavcodec / liba52 / parse.c @ 5509bffa
History  View  Annotate  Download (22.8 KB)
1 
/*


2 
* parse.c

3 
* Copyright (C) 20002003 Michel Lespinasse <walken@zoy.org>

4 
* Copyright (C) 19992000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>

5 
*

6 
* This file is part of a52dec, a free ATSC A52 stream decoder.

7 
* See http://liba52.sourceforge.net/ for updates.

8 
*

9 
* a52dec is free software; you can redistribute it and/or modify

10 
* it under the terms of the GNU General Public License as published by

11 
* the Free Software Foundation; either version 2 of the License, or

12 
* (at your option) any later version.

13 
*

14 
* a52dec is distributed in the hope that it will be useful,

15 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

16 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17 
* GNU General Public License for more details.

18 
*

19 
* You should have received a copy of the GNU General Public License

20 
* along with this program; if not, write to the Free Software

21 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

22 
*/

23 
#include "a52.h" 
24 
#include "a52_internal.h" 
25 
#include "bitstream.h" 
26 
#include "tables.h" 
27  
28 
#if defined(HAVE_MEMALIGN) && !defined(__cplusplus)

29 
/* some systems have memalign() but no declaration for it */

30 
void * memalign (size_t align, size_t size);

31 
#else

32 
/* assume malloc alignment is sufficient */

33 
#define memalign(align,size) malloc (size)

34 
#endif

35  
36 
typedef struct { 
37 
quantizer_t q1[2];

38 
quantizer_t q2[2];

39 
quantizer_t q4; 
40 
int q1_ptr;

41 
int q2_ptr;

42 
int q4_ptr;

43 
} quantizer_set_t; 
44  
45 
static uint8_t halfrate[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3}; 
46  
47 
a52_state_t * a52_init (uint32_t mm_accel) 
48 
{ 
49 
a52_state_t * state; 
50 
int i;

51  
52 
state = (a52_state_t *) malloc (sizeof (a52_state_t));

53 
if (state == NULL) 
54 
return NULL; 
55  
56 
state>samples = (sample_t *) memalign (16, 256 * 12 * sizeof (sample_t)); 
57 
if (state>samples == NULL) { 
58 
free (state); 
59 
return NULL; 
60 
} 
61  
62 
for (i = 0; i < 256 * 12; i++) 
63 
state>samples[i] = 0;

64  
65 
state>downmixed = 1;

66  
67 
state>lfsr_state = 1;

68  
69 
a52_imdct_init (mm_accel); 
70  
71 
return state;

72 
} 
73  
74 
sample_t * a52_samples (a52_state_t * state) 
75 
{ 
76 
return state>samples;

77 
} 
78  
79 
int a52_syncinfo (uint8_t * buf, int * flags, 
80 
int * sample_rate, int * bit_rate) 
81 
{ 
82 
static int rate[] = { 32, 40, 48, 56, 64, 80, 96, 112, 
83 
128, 160, 192, 224, 256, 320, 384, 448, 
84 
512, 576, 640}; 
85 
static uint8_t lfeon[8] = {0x10, 0x10, 0x04, 0x04, 0x04, 0x01, 0x04, 0x01}; 
86 
int frmsizecod;

87 
int bitrate;

88 
int half;

89 
int acmod;

90  
91 
if ((buf[0] != 0x0b)  (buf[1] != 0x77)) /* syncword */ 
92 
return 0; 
93  
94 
if (buf[5] >= 0x60) /* bsid >= 12 */ 
95 
return 0; 
96 
half = halfrate[buf[5] >> 3]; 
97  
98 
/* acmod, dsurmod and lfeon */

99 
acmod = buf[6] >> 5; 
100 
*flags = ((((buf[6] & 0xf8) == 0x50) ? A52_DOLBY : acmod)  
101 
((buf[6] & lfeon[acmod]) ? A52_LFE : 0)); 
102  
103 
frmsizecod = buf[4] & 63; 
104 
if (frmsizecod >= 38) 
105 
return 0; 
106 
bitrate = rate [frmsizecod >> 1];

107 
*bit_rate = (bitrate * 1000) >> half;

108  
109 
switch (buf[4] & 0xc0) { 
110 
case 0: 
111 
*sample_rate = 48000 >> half;

112 
return 4 * bitrate; 
113 
case 0x40: 
114 
*sample_rate = 44100 >> half;

115 
return 2 * (320 * bitrate / 147 + (frmsizecod & 1)); 
116 
case 0x80: 
117 
*sample_rate = 32000 >> half;

118 
return 6 * bitrate; 
119 
default:

120 
return 0; 
121 
} 
122 
} 
123  
124 
int a52_frame (a52_state_t * state, uint8_t * buf, int * flags, 
125 
level_t * level, sample_t bias) 
126 
{ 
127 
static level_t clev[4] = { LEVEL (LEVEL_3DB), LEVEL (LEVEL_45DB), 
128 
LEVEL (LEVEL_6DB), LEVEL (LEVEL_45DB) }; 
129 
static level_t slev[4] = { LEVEL (LEVEL_3DB), LEVEL (LEVEL_6DB), 
130 
0, LEVEL (LEVEL_6DB) };

131 
int chaninfo;

132 
int acmod;

133  
134 
state>fscod = buf[4] >> 6; 
135 
state>halfrate = halfrate[buf[5] >> 3]; 
136 
state>acmod = acmod = buf[6] >> 5; 
137  
138 
a52_bitstream_set_ptr (state, buf + 6);

139 
bitstream_get (state, 3); /* skip acmod we already parsed */ 
140  
141 
if ((acmod == 2) && (bitstream_get (state, 2) == 2)) /* dsurmod */ 
142 
acmod = A52_DOLBY; 
143  
144 
state>clev = state>slev = 0;

145  
146 
if ((acmod & 1) && (acmod != 1)) 
147 
state>clev = clev[bitstream_get (state, 2)]; /* cmixlev */ 
148  
149 
if (acmod & 4) 
150 
state>slev = slev[bitstream_get (state, 2)]; /* surmixlev */ 
151  
152 
state>lfeon = bitstream_get (state, 1);

153  
154 
state>output = a52_downmix_init (acmod, *flags, level, 
155 
state>clev, state>slev); 
156 
if (state>output < 0) 
157 
return 1; 
158 
if (state>lfeon && (*flags & A52_LFE))

159 
state>output = A52_LFE; 
160 
*flags = state>output; 
161 
/* the 2* compensates for differences in imdct */

162 
state>dynrng = state>level = MUL_C (*level, 2);

163 
state>bias = bias; 
164 
state>dynrnge = 1;

165 
state>dynrngcall = NULL;

166 
state>cplba.deltbae = DELTA_BIT_NONE; 
167 
state>ba[0].deltbae = state>ba[1].deltbae = state>ba[2].deltbae = 
168 
state>ba[3].deltbae = state>ba[4].deltbae = DELTA_BIT_NONE; 
169  
170 
chaninfo = !acmod; 
171 
do {

172 
bitstream_get (state, 5); /* dialnorm */ 
173 
if (bitstream_get (state, 1)) /* compre */ 
174 
bitstream_get (state, 8); /* compr */ 
175 
if (bitstream_get (state, 1)) /* langcode */ 
176 
bitstream_get (state, 8); /* langcod */ 
177 
if (bitstream_get (state, 1)) /* audprodie */ 
178 
bitstream_get (state, 7); /* mixlevel + roomtyp */ 
179 
} while (chaninfo);

180  
181 
bitstream_get (state, 2); /* copyrightb + origbs */ 
182  
183 
if (bitstream_get (state, 1)) /* timecod1e */ 
184 
bitstream_get (state, 14); /* timecod1 */ 
185 
if (bitstream_get (state, 1)) /* timecod2e */ 
186 
bitstream_get (state, 14); /* timecod2 */ 
187  
188 
if (bitstream_get (state, 1)) { /* addbsie */ 
189 
int addbsil;

190  
191 
addbsil = bitstream_get (state, 6);

192 
do {

193 
bitstream_get (state, 8); /* addbsi */ 
194 
} while (addbsil);

195 
} 
196  
197 
return 0; 
198 
} 
199  
200 
void a52_dynrng (a52_state_t * state,

201 
level_t (* call) (level_t, void *), void * data) 
202 
{ 
203 
state>dynrnge = 0;

204 
if (call) {

205 
state>dynrnge = 1;

206 
state>dynrngcall = call; 
207 
state>dynrngdata = data; 
208 
} 
209 
} 
210  
211 
static int parse_exponents (a52_state_t * state, int expstr, int ngrps, 
212 
uint8_t exponent, uint8_t * dest) 
213 
{ 
214 
int exps;

215  
216 
while (ngrps) {

217 
exps = bitstream_get (state, 7);

218  
219 
exponent += exp_1[exps]; 
220 
if (exponent > 24) 
221 
return 1; 
222  
223 
switch (expstr) {

224 
case EXP_D45:

225 
*(dest++) = exponent; 
226 
*(dest++) = exponent; 
227 
case EXP_D25:

228 
*(dest++) = exponent; 
229 
case EXP_D15:

230 
*(dest++) = exponent; 
231 
} 
232  
233 
exponent += exp_2[exps]; 
234 
if (exponent > 24) 
235 
return 1; 
236  
237 
switch (expstr) {

238 
case EXP_D45:

239 
*(dest++) = exponent; 
240 
*(dest++) = exponent; 
241 
case EXP_D25:

242 
*(dest++) = exponent; 
243 
case EXP_D15:

244 
*(dest++) = exponent; 
245 
} 
246  
247 
exponent += exp_3[exps]; 
248 
if (exponent > 24) 
249 
return 1; 
250  
251 
switch (expstr) {

252 
case EXP_D45:

253 
*(dest++) = exponent; 
254 
*(dest++) = exponent; 
255 
case EXP_D25:

256 
*(dest++) = exponent; 
257 
case EXP_D15:

258 
*(dest++) = exponent; 
259 
} 
260 
} 
261  
262 
return 0; 
263 
} 
264  
265 
static int parse_deltba (a52_state_t * state, int8_t * deltba) 
266 
{ 
267 
int deltnseg, deltlen, delta, j;

268  
269 
memset (deltba, 0, 50); 
270  
271 
deltnseg = bitstream_get (state, 3);

272 
j = 0;

273 
do {

274 
j += bitstream_get (state, 5);

275 
deltlen = bitstream_get (state, 4);

276 
delta = bitstream_get (state, 3);

277 
delta = (delta >= 4) ? 3 : 4; 
278 
if (!deltlen)

279 
continue;

280 
if (j + deltlen >= 50) 
281 
return 1; 
282 
while (deltlen)

283 
deltba[j++] = delta; 
284 
} while (deltnseg);

285  
286 
return 0; 
287 
} 
288  
289 
static inline int zero_snr_offsets (int nfchans, a52_state_t * state) 
290 
{ 
291 
int i;

292  
293 
if ((state>csnroffst) 

294 
(state>chincpl && state>cplba.bai >> 3)  /* cplinu, fsnroffst */ 
295 
(state>lfeon && state>lfeba.bai >> 3)) /* fsnroffst */ 
296 
return 0; 
297 
for (i = 0; i < nfchans; i++) 
298 
if (state>ba[i].bai >> 3) /* fsnroffst */ 
299 
return 0; 
300 
return 1; 
301 
} 
302  
303 
static inline int16_t dither_gen (a52_state_t * state) 
304 
{ 
305 
int16_t nstate; 
306  
307 
nstate = dither_lut[state>lfsr_state >> 8] ^ (state>lfsr_state << 8); 
308  
309 
state>lfsr_state = (uint16_t) nstate; 
310  
311 
return (3 * nstate) >> 2; 
312 
} 
313  
314 
#ifndef LIBA52_FIXED

315 
#define COEFF(c,t,l,s,e) (c) = (t) * (s)[e]

316 
#else

317 
#define COEFF(c,_t,_l,s,e) do { \ 
318 
quantizer_t t = (_t); \ 
319 
level_t l = (_l); \ 
320 
int shift = e  5; \ 
321 
sample_t tmp = t * (l >> 16) + ((t * (l & 0xffff)) >> 16); \ 
322 
if (shift >= 0) \ 
323 
(c) = tmp >> shift; \ 
324 
else \

325 
(c) = tmp << shift; \ 
326 
} while (0) 
327 
#endif

328  
329 
static void coeff_get (a52_state_t * state, sample_t * coeff, 
330 
expbap_t * expbap, quantizer_set_t * quant, 
331 
level_t level, int dither, int end) 
332 
{ 
333 
int i;

334 
uint8_t * exp; 
335 
int8_t * bap; 
336  
337 
#ifndef LIBA52_FIXED

338 
sample_t factor[25];

339  
340 
for (i = 0; i <= 24; i++) 
341 
factor[i] = scale_factor[i] * level; 
342 
#endif

343  
344 
exp = expbap>exp; 
345 
bap = expbap>bap; 
346  
347 
for (i = 0; i < end; i++) { 
348 
int bapi;

349  
350 
bapi = bap[i]; 
351 
switch (bapi) {

352 
case 0: 
353 
if (dither) {

354 
COEFF (coeff[i], dither_gen (state), level, factor, exp[i]); 
355 
continue;

356 
} else {

357 
coeff[i] = 0;

358 
continue;

359 
} 
360  
361 
case 1: 
362 
if (quant>q1_ptr >= 0) { 
363 
COEFF (coeff[i], quant>q1[quant>q1_ptr], level, 
364 
factor, exp[i]); 
365 
continue;

366 
} else {

367 
int code;

368  
369 
code = bitstream_get (state, 5);

370  
371 
quant>q1_ptr = 1;

372 
quant>q1[0] = q_1_2[code];

373 
quant>q1[1] = q_1_1[code];

374 
COEFF (coeff[i], q_1_0[code], level, factor, exp[i]); 
375 
continue;

376 
} 
377  
378 
case 2: 
379 
if (quant>q2_ptr >= 0) { 
380 
COEFF (coeff[i], quant>q2[quant>q2_ptr], level, 
381 
factor, exp[i]); 
382 
continue;

383 
} else {

384 
int code;

385  
386 
code = bitstream_get (state, 7);

387  
388 
quant>q2_ptr = 1;

389 
quant>q2[0] = q_2_2[code];

390 
quant>q2[1] = q_2_1[code];

391 
COEFF (coeff[i], q_2_0[code], level, factor, exp[i]); 
392 
continue;

393 
} 
394  
395 
case 3: 
396 
COEFF (coeff[i], q_3[bitstream_get (state, 3)], level,

397 
factor, exp[i]); 
398 
continue;

399  
400 
case 3: 
401 
if (quant>q4_ptr == 0) { 
402 
quant>q4_ptr = 1;

403 
COEFF (coeff[i], quant>q4, level, factor, exp[i]); 
404 
continue;

405 
} else {

406 
int code;

407  
408 
code = bitstream_get (state, 7);

409  
410 
quant>q4_ptr = 0;

411 
quant>q4 = q_4_1[code]; 
412 
COEFF (coeff[i], q_4_0[code], level, factor, exp[i]); 
413 
continue;

414 
} 
415  
416 
case 4: 
417 
COEFF (coeff[i], q_5[bitstream_get (state, 4)], level,

418 
factor, exp[i]); 
419 
continue;

420  
421 
default:

422 
COEFF (coeff[i], bitstream_get_2 (state, bapi) << (16  bapi),

423 
level, factor, exp[i]); 
424 
} 
425 
} 
426 
} 
427  
428 
static void coeff_get_coupling (a52_state_t * state, int nfchans, 
429 
level_t * coeff, sample_t (* samples)[256],

430 
quantizer_set_t * quant, uint8_t dithflag[5])

431 
{ 
432 
int cplbndstrc, bnd, i, i_end, ch;

433 
uint8_t * exp; 
434 
int8_t * bap; 
435 
level_t cplco[5];

436  
437 
exp = state>cpl_expbap.exp; 
438 
bap = state>cpl_expbap.bap; 
439 
bnd = 0;

440 
cplbndstrc = state>cplbndstrc; 
441 
i = state>cplstrtmant; 
442 
while (i < state>cplendmant) {

443 
i_end = i + 12;

444 
while (cplbndstrc & 1) { 
445 
cplbndstrc >>= 1;

446 
i_end += 12;

447 
} 
448 
cplbndstrc >>= 1;

449 
for (ch = 0; ch < nfchans; ch++) 
450 
cplco[ch] = MUL_L (state>cplco[ch][bnd], coeff[ch]); 
451 
bnd++; 
452  
453 
while (i < i_end) {

454 
quantizer_t cplcoeff; 
455 
int bapi;

456  
457 
bapi = bap[i]; 
458 
switch (bapi) {

459 
case 0: 
460 
for (ch = 0; ch < nfchans; ch++) 
461 
if ((state>chincpl >> ch) & 1) { 
462 
if (dithflag[ch])

463 
#ifndef LIBA52_FIXED

464 
samples[ch][i] = (scale_factor[exp[i]] * 
465 
cplco[ch] * dither_gen (state)); 
466 
#else

467 
COEFF (samples[ch][i], dither_gen (state), 
468 
cplco[ch], scale_factor, exp[i]); 
469 
#endif

470 
else

471 
samples[ch][i] = 0;

472 
} 
473 
i++; 
474 
continue;

475  
476 
case 1: 
477 
if (quant>q1_ptr >= 0) { 
478 
cplcoeff = quant>q1[quant>q1_ptr]; 
479 
break;

480 
} else {

481 
int code;

482  
483 
code = bitstream_get (state, 5);

484  
485 
quant>q1_ptr = 1;

486 
quant>q1[0] = q_1_2[code];

487 
quant>q1[1] = q_1_1[code];

488 
cplcoeff = q_1_0[code]; 
489 
break;

490 
} 
491  
492 
case 2: 
493 
if (quant>q2_ptr >= 0) { 
494 
cplcoeff = quant>q2[quant>q2_ptr]; 
495 
break;

496 
} else {

497 
int code;

498  
499 
code = bitstream_get (state, 7);

500  
501 
quant>q2_ptr = 1;

502 
quant>q2[0] = q_2_2[code];

503 
quant>q2[1] = q_2_1[code];

504 
cplcoeff = q_2_0[code]; 
505 
break;

506 
} 
507  
508 
case 3: 
509 
cplcoeff = q_3[bitstream_get (state, 3)];

510 
break;

511  
512 
case 3: 
513 
if (quant>q4_ptr == 0) { 
514 
quant>q4_ptr = 1;

515 
cplcoeff = quant>q4; 
516 
break;

517 
} else {

518 
int code;

519  
520 
code = bitstream_get (state, 7);

521  
522 
quant>q4_ptr = 0;

523 
quant>q4 = q_4_1[code]; 
524 
cplcoeff = q_4_0[code]; 
525 
break;

526 
} 
527  
528 
case 4: 
529 
cplcoeff = q_5[bitstream_get (state, 4)];

530 
break;

531  
532 
default:

533 
cplcoeff = bitstream_get_2 (state, bapi) << (16  bapi);

534 
} 
535 
#ifndef LIBA52_FIXED

536 
cplcoeff *= scale_factor[exp[i]]; 
537 
#endif

538 
for (ch = 0; ch < nfchans; ch++) 
539 
if ((state>chincpl >> ch) & 1) 
540 
#ifndef LIBA52_FIXED

541 
samples[ch][i] = cplcoeff * cplco[ch]; 
542 
#else

543 
COEFF (samples[ch][i], cplcoeff, cplco[ch], 
544 
scale_factor, exp[i]); 
545 
#endif

546 
i++; 
547 
} 
548 
} 
549 
} 
550  
551 
int a52_block (a52_state_t * state)

552 
{ 
553 
static const uint8_t nfchans_tbl[] = {2, 1, 2, 3, 3, 4, 4, 5, 1, 1, 2}; 
554 
static int rematrix_band[4] = {25, 37, 61, 253}; 
555 
int i, nfchans, chaninfo;

556 
uint8_t cplexpstr, chexpstr[5], lfeexpstr, do_bit_alloc, done_cpl;

557 
uint8_t blksw[5], dithflag[5]; 
558 
level_t coeff[5];

559 
int chanbias;

560 
quantizer_set_t quant; 
561 
sample_t * samples; 
562  
563 
nfchans = nfchans_tbl[state>acmod]; 
564  
565 
for (i = 0; i < nfchans; i++) 
566 
blksw[i] = bitstream_get (state, 1);

567  
568 
for (i = 0; i < nfchans; i++) 
569 
dithflag[i] = bitstream_get (state, 1);

570  
571 
chaninfo = !state>acmod; 
572 
do {

573 
if (bitstream_get (state, 1)) { /* dynrnge */ 
574 
int dynrng;

575  
576 
dynrng = bitstream_get_2 (state, 8);

577 
if (state>dynrnge) {

578 
level_t range; 
579  
580 
#if !defined(LIBA52_FIXED)

581 
range = ((((dynrng & 0x1f)  0x20) << 13) * 
582 
scale_factor[3  (dynrng >> 5)]); 
583 
#else

584 
range = ((dynrng & 0x1f)  0x20) << (21 + (dynrng >> 5)); 
585 
#endif

586 
if (state>dynrngcall)

587 
range = state>dynrngcall (range, state>dynrngdata); 
588 
state>dynrng = MUL_L (state>level, range); 
589 
} 
590 
} 
591 
} while (chaninfo);

592  
593 
if (bitstream_get (state, 1)) { /* cplstre */ 
594 
state>chincpl = 0;

595 
if (bitstream_get (state, 1)) { /* cplinu */ 
596 
static uint8_t bndtab[16] = {31, 35, 37, 39, 41, 42, 43, 44, 
597 
45, 45, 46, 46, 47, 47, 48, 48}; 
598 
int cplbegf;

599 
int cplendf;

600 
int ncplsubnd;

601  
602 
for (i = 0; i < nfchans; i++) 
603 
state>chincpl = bitstream_get (state, 1) << i;

604 
switch (state>acmod) {

605 
case 0: case 1: 
606 
return 1; 
607 
case 2: 
608 
state>phsflginu = bitstream_get (state, 1);

609 
} 
610 
cplbegf = bitstream_get (state, 4);

611 
cplendf = bitstream_get (state, 4);

612  
613 
if (cplendf + 3  cplbegf < 0) 
614 
return 1; 
615 
state>ncplbnd = ncplsubnd = cplendf + 3  cplbegf;

616 
state>cplstrtbnd = bndtab[cplbegf]; 
617 
state>cplstrtmant = cplbegf * 12 + 37; 
618 
state>cplendmant = cplendf * 12 + 73; 
619  
620 
state>cplbndstrc = 0;

621 
for (i = 0; i < ncplsubnd  1; i++) 
622 
if (bitstream_get (state, 1)) { 
623 
state>cplbndstrc = 1 << i;

624 
state>ncplbnd; 
625 
} 
626 
} 
627 
} 
628  
629 
if (state>chincpl) { /* cplinu */ 
630 
int j, cplcoe;

631  
632 
cplcoe = 0;

633 
for (i = 0; i < nfchans; i++) 
634 
if ((state>chincpl) >> i & 1) 
635 
if (bitstream_get (state, 1)) { /* cplcoe */ 
636 
int mstrcplco, cplcoexp, cplcomant;

637  
638 
cplcoe = 1;

639 
mstrcplco = 3 * bitstream_get (state, 2); 
640 
for (j = 0; j < state>ncplbnd; j++) { 
641 
cplcoexp = bitstream_get (state, 4);

642 
cplcomant = bitstream_get (state, 4);

643 
if (cplcoexp == 15) 
644 
cplcomant <<= 14;

645 
else

646 
cplcomant = (cplcomant  0x10) << 13; 
647 
#ifndef LIBA52_FIXED

648 
state>cplco[i][j] = 
649 
cplcomant * scale_factor[cplcoexp + mstrcplco]; 
650 
#else

651 
state>cplco[i][j] = (cplcomant << 11) >> (cplcoexp + mstrcplco);

652 
#endif

653  
654 
} 
655 
} 
656 
if ((state>acmod == 2) && state>phsflginu && cplcoe) 
657 
for (j = 0; j < state>ncplbnd; j++) 
658 
if (bitstream_get (state, 1)) /* phsflg */ 
659 
state>cplco[1][j] = state>cplco[1][j]; 
660 
} 
661  
662 
if ((state>acmod == 2) && (bitstream_get (state, 1))) { /* rematstr */ 
663 
int end;

664  
665 
state>rematflg = 0;

666 
end = (state>chincpl) ? state>cplstrtmant : 253; /* cplinu */ 
667 
i = 0;

668 
do

669 
state>rematflg = bitstream_get (state, 1) << i;

670 
while (rematrix_band[i++] < end);

671 
} 
672  
673 
cplexpstr = EXP_REUSE; 
674 
lfeexpstr = EXP_REUSE; 
675 
if (state>chincpl) /* cplinu */ 
676 
cplexpstr = bitstream_get (state, 2);

677 
for (i = 0; i < nfchans; i++) 
678 
chexpstr[i] = bitstream_get (state, 2);

679 
if (state>lfeon)

680 
lfeexpstr = bitstream_get (state, 1);

681  
682 
for (i = 0; i < nfchans; i++) 
683 
if (chexpstr[i] != EXP_REUSE) {

684 
if ((state>chincpl >> i) & 1) 
685 
state>endmant[i] = state>cplstrtmant; 
686 
else {

687 
int chbwcod;

688  
689 
chbwcod = bitstream_get (state, 6);

690 
if (chbwcod > 60) 
691 
return 1; 
692 
state>endmant[i] = chbwcod * 3 + 73; 
693 
} 
694 
} 
695  
696 
do_bit_alloc = 0;

697  
698 
if (cplexpstr != EXP_REUSE) {

699 
int cplabsexp, ncplgrps;

700  
701 
do_bit_alloc = 64;

702 
ncplgrps = ((state>cplendmant  state>cplstrtmant) / 
703 
(3 << (cplexpstr  1))); 
704 
cplabsexp = bitstream_get (state, 4) << 1; 
705 
if (parse_exponents (state, cplexpstr, ncplgrps, cplabsexp,

706 
state>cpl_expbap.exp + state>cplstrtmant)) 
707 
return 1; 
708 
} 
709 
for (i = 0; i < nfchans; i++) 
710 
if (chexpstr[i] != EXP_REUSE) {

711 
int grp_size, nchgrps;

712  
713 
do_bit_alloc = 1 << i;

714 
grp_size = 3 << (chexpstr[i]  1); 
715 
nchgrps = (state>endmant[i] + grp_size  4) / grp_size;

716 
state>fbw_expbap[i].exp[0] = bitstream_get (state, 4); 
717 
if (parse_exponents (state, chexpstr[i], nchgrps,

718 
state>fbw_expbap[i].exp[0],

719 
state>fbw_expbap[i].exp + 1))

720 
return 1; 
721 
bitstream_get (state, 2); /* gainrng */ 
722 
} 
723 
if (lfeexpstr != EXP_REUSE) {

724 
do_bit_alloc = 32;

725 
state>lfe_expbap.exp[0] = bitstream_get (state, 4); 
726 
if (parse_exponents (state, lfeexpstr, 2, state>lfe_expbap.exp[0], 
727 
state>lfe_expbap.exp + 1))

728 
return 1; 
729 
} 
730  
731 
if (bitstream_get (state, 1)) { /* baie */ 
732 
do_bit_alloc = 127;

733 
state>bai = bitstream_get (state, 11);

734 
} 
735 
if (bitstream_get (state, 1)) { /* snroffste */ 
736 
do_bit_alloc = 127;

737 
state>csnroffst = bitstream_get (state, 6);

738 
if (state>chincpl) /* cplinu */ 
739 
state>cplba.bai = bitstream_get (state, 7);

740 
for (i = 0; i < nfchans; i++) 
741 
state>ba[i].bai = bitstream_get (state, 7);

742 
if (state>lfeon)

743 
state>lfeba.bai = bitstream_get (state, 7);

744 
} 
745 
if ((state>chincpl) && (bitstream_get (state, 1))) { /* cplleake */ 
746 
do_bit_alloc = 64;

747 
state>cplfleak = 9  bitstream_get (state, 3); 
748 
state>cplsleak = 9  bitstream_get (state, 3); 
749 
} 
750  
751 
if (bitstream_get (state, 1)) { /* deltbaie */ 
752 
do_bit_alloc = 127;

753 
if (state>chincpl) /* cplinu */ 
754 
state>cplba.deltbae = bitstream_get (state, 2);

755 
for (i = 0; i < nfchans; i++) 
756 
state>ba[i].deltbae = bitstream_get (state, 2);

757 
if (state>chincpl && /* cplinu */ 
758 
(state>cplba.deltbae == DELTA_BIT_NEW) && 
759 
parse_deltba (state, state>cplba.deltba)) 
760 
return 1; 
761 
for (i = 0; i < nfchans; i++) 
762 
if ((state>ba[i].deltbae == DELTA_BIT_NEW) &&

763 
parse_deltba (state, state>ba[i].deltba)) 
764 
return 1; 
765 
} 
766  
767 
if (do_bit_alloc) {

768 
if (zero_snr_offsets (nfchans, state)) {

769 
memset (state>cpl_expbap.bap, 0, sizeof (state>cpl_expbap.bap)); 
770 
for (i = 0; i < nfchans; i++) 
771 
memset (state>fbw_expbap[i].bap, 0,

772 
sizeof (state>fbw_expbap[i].bap));

773 
memset (state>lfe_expbap.bap, 0, sizeof (state>lfe_expbap.bap)); 
774 
} else {

775 
if (state>chincpl && (do_bit_alloc & 64)) /* cplinu */ 
776 
a52_bit_allocate (state, &state>cplba, state>cplstrtbnd, 
777 
state>cplstrtmant, state>cplendmant, 
778 
state>cplfleak << 8, state>cplsleak << 8, 
779 
&state>cpl_expbap); 
780 
for (i = 0; i < nfchans; i++) 
781 
if (do_bit_alloc & (1 << i)) 
782 
a52_bit_allocate (state, state>ba + i, 0, 0, 
783 
state>endmant[i], 0, 0, 
784 
state>fbw_expbap +i); 
785 
if (state>lfeon && (do_bit_alloc & 32)) { 
786 
state>lfeba.deltbae = DELTA_BIT_NONE; 
787 
a52_bit_allocate (state, &state>lfeba, 0, 0, 7, 0, 0, 
788 
&state>lfe_expbap); 
789 
} 
790 
} 
791 
} 
792  
793 
if (bitstream_get (state, 1)) { /* skiple */ 
794 
i = bitstream_get (state, 9); /* skipl */ 
795 
while (i)

796 
bitstream_get (state, 8);

797 
} 
798  
799 
samples = state>samples; 
800 
if (state>output & A52_LFE)

801 
samples += 256; /* shift for LFE channel */ 
802  
803 
chanbias = a52_downmix_coeff (coeff, state>acmod, state>output, 
804 
state>dynrng, state>clev, state>slev); 
805  
806 
quant.q1_ptr = quant.q2_ptr = quant.q4_ptr = 1;

807 
done_cpl = 0;

808  
809 
for (i = 0; i < nfchans; i++) { 
810 
int j;

811  
812 
coeff_get (state, samples + 256 * i, state>fbw_expbap +i, &quant,

813 
coeff[i], dithflag[i], state>endmant[i]); 
814  
815 
if ((state>chincpl >> i) & 1) { 
816 
if (!done_cpl) {

817 
done_cpl = 1;

818 
coeff_get_coupling (state, nfchans, coeff, 
819 
(sample_t (*)[256])samples, &quant,

820 
dithflag); 
821 
} 
822 
j = state>cplendmant; 
823 
} else

824 
j = state>endmant[i]; 
825 
do

826 
(samples + 256 * i)[j] = 0; 
827 
while (++j < 256); 
828 
} 
829  
830 
if (state>acmod == 2) { 
831 
int j, end, band, rematflg;

832  
833 
end = ((state>endmant[0] < state>endmant[1]) ? 
834 
state>endmant[0] : state>endmant[1]); 
835  
836 
i = 0;

837 
j = 13;

838 
rematflg = state>rematflg; 
839 
do {

840 
if (! (rematflg & 1)) { 
841 
rematflg >>= 1;

842 
j = rematrix_band[i++]; 
843 
continue;

844 
} 
845 
rematflg >>= 1;

846 
band = rematrix_band[i++]; 
847 
if (band > end)

848 
band = end; 
849 
do {

850 
sample_t tmp0, tmp1; 
851  
852 
tmp0 = samples[j]; 
853 
tmp1 = (samples+256)[j];

854 
samples[j] = tmp0 + tmp1; 
855 
(samples+256)[j] = tmp0  tmp1;

856 
} while (++j < band);

857 
} while (j < end);

858 
} 
859  
860 
if (state>lfeon) {

861 
if (state>output & A52_LFE) {

862 
coeff_get (state, samples  256, &state>lfe_expbap, &quant,

863 
state>dynrng, 0, 7); 
864 
for (i = 7; i < 256; i++) 
865 
(samples256)[i] = 0; 
866 
a52_imdct_512 (samples  256, samples + 1536  256, state>bias); 
867 
} else {

868 
/* just skip the LFE coefficients */

869 
coeff_get (state, samples + 1280, &state>lfe_expbap, &quant,

870 
0, 0, 7); 
871 
} 
872 
} 
873  
874 
i = 0;

875 
if (nfchans_tbl[state>output & A52_CHANNEL_MASK] < nfchans)

876 
for (i = 1; i < nfchans; i++) 
877 
if (blksw[i] != blksw[0]) 
878 
break;

879  
880 
if (i < nfchans) {

881 
if (state>downmixed) {

882 
state>downmixed = 0;

883 
a52_upmix (samples + 1536, state>acmod, state>output);

884 
} 
885  
886 
for (i = 0; i < nfchans; i++) { 
887 
sample_t bias; 
888  
889 
bias = 0;

890 
if (!(chanbias & (1 << i))) 
891 
bias = state>bias; 
892  
893 
if (coeff[i]) {

894 
if (blksw[i])

895 
a52_imdct_256 (samples + 256 * i, samples + 1536 + 256 * i, 
896 
bias); 
897 
else

898 
a52_imdct_512 (samples + 256 * i, samples + 1536 + 256 * i, 
899 
bias); 
900 
} else {

901 
int j;

902  
903 
for (j = 0; j < 256; j++) 
904 
(samples + 256 * i)[j] = bias;

905 
} 
906 
} 
907  
908 
a52_downmix (samples, state>acmod, state>output, state>bias, 
909 
state>clev, state>slev); 
910 
} else {

911 
nfchans = nfchans_tbl[state>output & A52_CHANNEL_MASK]; 
912  
913 
a52_downmix (samples, state>acmod, state>output, 0,

914 
state>clev, state>slev); 
915  
916 
if (!state>downmixed) {

917 
state>downmixed = 1;

918 
a52_downmix (samples + 1536, state>acmod, state>output, 0, 
919 
state>clev, state>slev); 
920 
} 
921  
922 
if (blksw[0]) 
923 
for (i = 0; i < nfchans; i++) 
924 
a52_imdct_256 (samples + 256 * i, samples + 1536 + 256 * i, 
925 
state>bias); 
926 
else

927 
for (i = 0; i < nfchans; i++) 
928 
a52_imdct_512 (samples + 256 * i, samples + 1536 + 256 * i, 
929 
state>bias); 
930 
} 
931  
932 
return 0; 
933 
} 
934  
935 
void a52_free (a52_state_t * state)

936 
{ 
937 
free (state>samples); 
938 
free (state); 
939 
} 