falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4744 Commits
32 Branches
570MB
Tree: 1b51e051c0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1b51e051c0'
${ noResults }
FFmpeg/libavcodec/liba52/parse.c

940 lines
23KB
Raw Blame History 

  1. /*

  2.  * parse.c

  3.  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>

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

  5.  *

  6.  * This file is part of a52dec, a free ATSC A-52 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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. 		(samples-256)[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. }