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.
1803 Commits
32 Branches
1.1GB
Tree: c947dec982
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c947dec982'
${ noResults }
FFmpeg/libavcodec/liba52/parse.c

947 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. 

  24. #include "config.h"

  25. 

  26. #include <stdlib.h>

  27. #include <string.h>

  28. #include <inttypes.h>

  29. 

  30. #include "a52.h"

  31. #include "a52_internal.h"

  32. #include "bitstream.h"

  33. #include "tables.h"

  34. 

  35. #if defined(HAVE_MEMALIGN) && !defined(__cplusplus)

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

  37. void * memalign (size_t align, size_t size);

  38. #else

  39. /* assume malloc alignment is sufficient */

  40. #define memalign(align,size) malloc (size)

  41. #endif

  42. 

  43. typedef struct {

  44.     quantizer_t q1[2];

  45.     quantizer_t q2[2];

  46.     quantizer_t q4;

  47.     int q1_ptr;

  48.     int q2_ptr;

  49.     int q4_ptr;

  50. } quantizer_set_t;

  51. 

  52. static uint8_t halfrate[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3};

  53. 

  54. a52_state_t * a52_init (uint32_t mm_accel)

  55. {

  56.     a52_state_t * state;

  57.     int i;

  58. 

  59.     state = (a52_state_t *) malloc (sizeof (a52_state_t));

  60.     if (state == NULL)

  61. 	return NULL;

  62. 

  63.     state->samples = (sample_t *) memalign (16, 256 * 12 * sizeof (sample_t));

  64.     if (state->samples == NULL) {

  65. 	free (state);

  66. 	return NULL;

  67.     }

  68. 

  69.     for (i = 0; i < 256 * 12; i++)

  70. 	state->samples[i] = 0;

  71. 

  72.     state->downmixed = 1;

  73. 

  74.     state->lfsr_state = 1;

  75. 

  76.     a52_imdct_init (mm_accel);

  77. 

  78.     return state;

  79. }

  80. 

  81. sample_t * a52_samples (a52_state_t * state)

  82. {

  83.     return state->samples;

  84. }

  85. 

  86. int a52_syncinfo (uint8_t * buf, int * flags,

  87. 		  int * sample_rate, int * bit_rate)

  88. {

  89.     static int rate[] = { 32,  40,  48,  56,  64,  80,  96, 112,

  90. 			 128, 160, 192, 224, 256, 320, 384, 448,

  91. 			 512, 576, 640};

  92.     static uint8_t lfeon[8] = {0x10, 0x10, 0x04, 0x04, 0x04, 0x01, 0x04, 0x01};

  93.     int frmsizecod;

  94.     int bitrate;

  95.     int half;

  96.     int acmod;

  97. 

  98.     if ((buf[0] != 0x0b) || (buf[1] != 0x77))	/* syncword */

  99. 	return 0;

  100. 

  101.     if (buf[5] >= 0x60)		/* bsid >= 12 */

  102. 	return 0;

  103.     half = halfrate[buf[5] >> 3];

  104. 

  105.     /* acmod, dsurmod and lfeon */

  106.     acmod = buf[6] >> 5;

  107.     *flags = ((((buf[6] & 0xf8) == 0x50) ? A52_DOLBY : acmod) |

  108. 	      ((buf[6] & lfeon[acmod]) ? A52_LFE : 0));

  109. 

  110.     frmsizecod = buf[4] & 63;

  111.     if (frmsizecod >= 38)

  112. 	return 0;

  113.     bitrate = rate [frmsizecod >> 1];

  114.     *bit_rate = (bitrate * 1000) >> half;

  115. 

  116.     switch (buf[4] & 0xc0) {

  117.     case 0:

  118. 	*sample_rate = 48000 >> half;

  119. 	return 4 * bitrate;

  120.     case 0x40:

  121. 	*sample_rate = 44100 >> half;

  122. 	return 2 * (320 * bitrate / 147 + (frmsizecod & 1));

  123.     case 0x80:

  124. 	*sample_rate = 32000 >> half;

  125. 	return 6 * bitrate;

  126.     default:

  127. 	return 0;

  128.     }

  129. }

  130. 

  131. int a52_frame (a52_state_t * state, uint8_t * buf, int * flags,

  132. 	       level_t * level, sample_t bias)

  133. {

  134.     static level_t clev[4] = { LEVEL (LEVEL_3DB), LEVEL (LEVEL_45DB),

  135. 			       LEVEL (LEVEL_6DB), LEVEL (LEVEL_45DB) };

  136.     static level_t slev[4] = { LEVEL (LEVEL_3DB), LEVEL (LEVEL_6DB), 

  137. 			       0,                 LEVEL (LEVEL_6DB) };

  138.     int chaninfo;

  139.     int acmod;

  140. 

  141.     state->fscod = buf[4] >> 6;

  142.     state->halfrate = halfrate[buf[5] >> 3];

  143.     state->acmod = acmod = buf[6] >> 5;

  144. 

  145.     a52_bitstream_set_ptr (state, buf + 6);

  146.     bitstream_get (state, 3);	/* skip acmod we already parsed */

  147. 

  148.     if ((acmod == 2) && (bitstream_get (state, 2) == 2))	/* dsurmod */

  149. 	acmod = A52_DOLBY;

  150. 

  151.     state->clev = state->slev = 0;

  152. 

  153.     if ((acmod & 1) && (acmod != 1))

  154. 	state->clev = clev[bitstream_get (state, 2)];	/* cmixlev */

  155. 

  156.     if (acmod & 4)

  157. 	state->slev = slev[bitstream_get (state, 2)];	/* surmixlev */

  158. 

  159.     state->lfeon = bitstream_get (state, 1);

  160. 

  161.     state->output = a52_downmix_init (acmod, *flags, level,

  162. 				      state->clev, state->slev);

  163.     if (state->output < 0)

  164. 	return 1;

  165.     if (state->lfeon && (*flags & A52_LFE))

  166. 	state->output |= A52_LFE;

  167.     *flags = state->output;

  168.     /* the 2* compensates for differences in imdct */

  169.     state->dynrng = state->level = MUL_C (*level, 2);

  170.     state->bias = bias;

  171.     state->dynrnge = 1;

  172.     state->dynrngcall = NULL;

  173.     state->cplba.deltbae = DELTA_BIT_NONE;

  174.     state->ba[0].deltbae = state->ba[1].deltbae = state->ba[2].deltbae =

  175. 	state->ba[3].deltbae = state->ba[4].deltbae = DELTA_BIT_NONE;

  176. 

  177.     chaninfo = !acmod;

  178.     do {

  179. 	bitstream_get (state, 5);	/* dialnorm */

  180. 	if (bitstream_get (state, 1))	/* compre */

  181. 	    bitstream_get (state, 8);	/* compr */

  182. 	if (bitstream_get (state, 1))	/* langcode */

  183. 	    bitstream_get (state, 8);	/* langcod */

  184. 	if (bitstream_get (state, 1))	/* audprodie */

  185. 	    bitstream_get (state, 7);	/* mixlevel + roomtyp */

  186.     } while (chaninfo--);

  187. 

  188.     bitstream_get (state, 2);		/* copyrightb + origbs */

  189. 

  190.     if (bitstream_get (state, 1))	/* timecod1e */

  191. 	bitstream_get (state, 14);	/* timecod1 */

  192.     if (bitstream_get (state, 1))	/* timecod2e */

  193. 	bitstream_get (state, 14);	/* timecod2 */

  194. 

  195.     if (bitstream_get (state, 1)) {	/* addbsie */

  196. 	int addbsil;

  197. 

  198. 	addbsil = bitstream_get (state, 6);

  199. 	do {

  200. 	    bitstream_get (state, 8);	/* addbsi */

  201. 	} while (addbsil--);

  202.     }

  203. 

  204.     return 0;

  205. }

  206. 

  207. void a52_dynrng (a52_state_t * state,

  208. 		 level_t (* call) (level_t, void *), void * data)

  209. {

  210.     state->dynrnge = 0;

  211.     if (call) {

  212. 	state->dynrnge = 1;

  213. 	state->dynrngcall = call;

  214. 	state->dynrngdata = data;

  215.     }

  216. }

  217. 

  218. static int parse_exponents (a52_state_t * state, int expstr, int ngrps,

  219. 			    uint8_t exponent, uint8_t * dest)

  220. {

  221.     int exps;

  222. 

  223.     while (ngrps--) {

  224. 	exps = bitstream_get (state, 7);

  225. 

  226. 	exponent += exp_1[exps];

  227. 	if (exponent > 24)

  228. 	    return 1;

  229. 

  230. 	switch (expstr) {

  231. 	case EXP_D45:

  232. 	    *(dest++) = exponent;

  233. 	    *(dest++) = exponent;

  234. 	case EXP_D25:

  235. 	    *(dest++) = exponent;

  236. 	case EXP_D15:

  237. 	    *(dest++) = exponent;

  238. 	}

  239. 

  240. 	exponent += exp_2[exps];

  241. 	if (exponent > 24)

  242. 	    return 1;

  243. 

  244. 	switch (expstr) {

  245. 	case EXP_D45:

  246. 	    *(dest++) = exponent;

  247. 	    *(dest++) = exponent;

  248. 	case EXP_D25:

  249. 	    *(dest++) = exponent;

  250. 	case EXP_D15:

  251. 	    *(dest++) = exponent;

  252. 	}

  253. 

  254. 	exponent += exp_3[exps];

  255. 	if (exponent > 24)

  256. 	    return 1;

  257. 

  258. 	switch (expstr) {

  259. 	case EXP_D45:

  260. 	    *(dest++) = exponent;

  261. 	    *(dest++) = exponent;

  262. 	case EXP_D25:

  263. 	    *(dest++) = exponent;

  264. 	case EXP_D15:

  265. 	    *(dest++) = exponent;

  266. 	}

  267.     }	

  268. 

  269.     return 0;

  270. }

  271. 

  272. static int parse_deltba (a52_state_t * state, int8_t * deltba)

  273. {

  274.     int deltnseg, deltlen, delta, j;

  275. 

  276.     memset (deltba, 0, 50);

  277. 

  278.     deltnseg = bitstream_get (state, 3);

  279.     j = 0;

  280.     do {

  281. 	j += bitstream_get (state, 5);

  282. 	deltlen = bitstream_get (state, 4);

  283. 	delta = bitstream_get (state, 3);

  284. 	delta -= (delta >= 4) ? 3 : 4;

  285. 	if (!deltlen)

  286. 	    continue;

  287. 	if (j + deltlen >= 50)

  288. 	    return 1;

  289. 	while (deltlen--)

  290. 	    deltba[j++] = delta;

  291.     } while (deltnseg--);

  292. 

  293.     return 0;

  294. }

  295. 

  296. static inline int zero_snr_offsets (int nfchans, a52_state_t * state)

  297. {

  298.     int i;

  299. 

  300.     if ((state->csnroffst) ||

  301. 	(state->chincpl && state->cplba.bai >> 3) ||	/* cplinu, fsnroffst */

  302. 	(state->lfeon && state->lfeba.bai >> 3))	/* fsnroffst */

  303. 	return 0;

  304.     for (i = 0; i < nfchans; i++)

  305. 	if (state->ba[i].bai >> 3)			/* fsnroffst */

  306. 	    return 0;

  307.     return 1;

  308. }

  309. 

  310. static inline int16_t dither_gen (a52_state_t * state)

  311. {

  312.     int16_t nstate;

  313. 

  314.     nstate = dither_lut[state->lfsr_state >> 8] ^ (state->lfsr_state << 8);

  315. 	

  316.     state->lfsr_state = (uint16_t) nstate;

  317. 

  318.     return (3 * nstate) >> 2;

  319. }

  320. 

  321. #ifndef LIBA52_FIXED

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

  323. #else

  324. #define COEFF(c,_t,_l,s,e) do {					\

  325.     quantizer_t t = (_t);					\

  326.     level_t l = (_l);						\

  327.     int shift = e - 5;						\

  328.     sample_t tmp = t * (l >> 16) + ((t * (l & 0xffff)) >> 16);	\

  329.     if (shift >= 0)						\

  330. 	(c) = tmp >> shift;					\

  331.     else							\

  332. 	(c) = tmp << -shift;					\

  333. } while (0)

  334. #endif

  335. 

  336. static void coeff_get (a52_state_t * state, sample_t * coeff,

  337. 		       expbap_t * expbap, quantizer_set_t * quant,

  338. 		       level_t level, int dither, int end)

  339. {

  340.     int i;

  341.     uint8_t * exp;

  342.     int8_t * bap;

  343. 

  344. #ifndef LIBA52_FIXED

  345.     sample_t factor[25];

  346. 

  347.     for (i = 0; i <= 24; i++)

  348. 	factor[i] = scale_factor[i] * level;

  349. #endif

  350. 

  351.     exp = expbap->exp;

  352.     bap = expbap->bap;

  353. 

  354.     for (i = 0; i < end; i++) {

  355. 	int bapi;

  356. 

  357. 	bapi = bap[i];

  358. 	switch (bapi) {

  359. 	case 0:

  360. 	    if (dither) {

  361. 		COEFF (coeff[i], dither_gen (state), level, factor, exp[i]);

  362. 		continue;

  363. 	    } else {

  364. 		coeff[i] = 0;

  365. 		continue;

  366. 	    }

  367. 

  368. 	case -1:

  369. 	    if (quant->q1_ptr >= 0) {

  370. 		COEFF (coeff[i], quant->q1[quant->q1_ptr--], level,

  371. 		       factor, exp[i]);

  372. 		continue;

  373. 	    } else {

  374. 		int code;

  375. 

  376. 		code = bitstream_get (state, 5);

  377. 

  378. 		quant->q1_ptr = 1;

  379. 		quant->q1[0] = q_1_2[code];

  380. 		quant->q1[1] = q_1_1[code];

  381. 		COEFF (coeff[i], q_1_0[code], level, factor, exp[i]);

  382. 		continue;

  383. 	    }

  384. 

  385. 	case -2:

  386. 	    if (quant->q2_ptr >= 0) {

  387. 		COEFF (coeff[i], quant->q2[quant->q2_ptr--], level,

  388. 		       factor, exp[i]);

  389. 		continue;

  390. 	    } else {

  391. 		int code;

  392. 

  393. 		code = bitstream_get (state, 7);

  394. 

  395. 		quant->q2_ptr = 1;

  396. 		quant->q2[0] = q_2_2[code];

  397. 		quant->q2[1] = q_2_1[code];

  398. 		COEFF (coeff[i], q_2_0[code], level, factor, exp[i]);

  399. 		continue;

  400. 	    }

  401. 

  402. 	case 3:

  403. 	    COEFF (coeff[i], q_3[bitstream_get (state, 3)], level,

  404. 		   factor, exp[i]);

  405. 	    continue;

  406. 

  407. 	case -3:

  408. 	    if (quant->q4_ptr == 0) {

  409. 		quant->q4_ptr = -1;

  410. 		COEFF (coeff[i], quant->q4, level, factor, exp[i]);

  411. 		continue;

  412. 	    } else {

  413. 		int code;

  414. 

  415. 		code = bitstream_get (state, 7);

  416. 

  417. 		quant->q4_ptr = 0;

  418. 		quant->q4 = q_4_1[code];

  419. 		COEFF (coeff[i], q_4_0[code], level, factor, exp[i]);

  420. 		continue;

  421. 	    }

  422. 

  423. 	case 4:

  424. 	    COEFF (coeff[i], q_5[bitstream_get (state, 4)], level,

  425. 		   factor, exp[i]);

  426. 	    continue;

  427. 

  428. 	default:

  429. 	    COEFF (coeff[i], bitstream_get_2 (state, bapi) << (16 - bapi),

  430. 		   level, factor, exp[i]);

  431. 	}

  432.     }

  433. }

  434. 

  435. static void coeff_get_coupling (a52_state_t * state, int nfchans,

  436. 				level_t * coeff, sample_t (* samples)[256],

  437. 				quantizer_set_t * quant, uint8_t dithflag[5])

  438. {

  439.     int cplbndstrc, bnd, i, i_end, ch;

  440.     uint8_t * exp;

  441.     int8_t * bap;

  442.     level_t cplco[5];

  443. 

  444.     exp = state->cpl_expbap.exp;

  445.     bap = state->cpl_expbap.bap;

  446.     bnd = 0;

  447.     cplbndstrc = state->cplbndstrc;

  448.     i = state->cplstrtmant;

  449.     while (i < state->cplendmant) {

  450. 	i_end = i + 12;

  451. 	while (cplbndstrc & 1) {

  452. 	    cplbndstrc >>= 1;

  453. 	    i_end += 12;

  454. 	}

  455. 	cplbndstrc >>= 1;

  456. 	for (ch = 0; ch < nfchans; ch++)

  457. 	    cplco[ch] = MUL_L (state->cplco[ch][bnd], coeff[ch]);

  458. 	bnd++;

  459. 

  460. 	while (i < i_end) {

  461. 	    quantizer_t cplcoeff;

  462. 	    int bapi;

  463. 

  464. 	    bapi = bap[i];

  465. 	    switch (bapi) {

  466. 	    case 0:

  467. 		for (ch = 0; ch < nfchans; ch++)

  468. 		    if ((state->chincpl >> ch) & 1) {

  469. 			if (dithflag[ch])

  470. #ifndef LIBA52_FIXED

  471. 			    samples[ch][i] = (scale_factor[exp[i]] *

  472. 					      cplco[ch] * dither_gen (state));

  473. #else

  474. 			    COEFF (samples[ch][i], dither_gen (state),

  475. 				   cplco[ch], scale_factor, exp[i]);

  476. #endif

  477. 			else

  478. 			    samples[ch][i] = 0;

  479. 		    }

  480. 		i++;

  481. 		continue;

  482. 

  483. 	    case -1:

  484. 		if (quant->q1_ptr >= 0) {

  485. 		    cplcoeff = quant->q1[quant->q1_ptr--];

  486. 		    break;

  487. 		} else {

  488. 		    int code;

  489. 

  490. 		    code = bitstream_get (state, 5);

  491. 

  492. 		    quant->q1_ptr = 1;

  493. 		    quant->q1[0] = q_1_2[code];

  494. 		    quant->q1[1] = q_1_1[code];

  495. 		    cplcoeff = q_1_0[code];

  496. 		    break;

  497. 		}

  498. 

  499. 	    case -2:

  500. 		if (quant->q2_ptr >= 0) {

  501. 		    cplcoeff = quant->q2[quant->q2_ptr--];

  502. 		    break;

  503. 		} else {

  504. 		    int code;

  505. 

  506. 		    code = bitstream_get (state, 7);

  507. 

  508. 		    quant->q2_ptr = 1;

  509. 		    quant->q2[0] = q_2_2[code];

  510. 		    quant->q2[1] = q_2_1[code];

  511. 		    cplcoeff = q_2_0[code];

  512. 		    break;

  513. 		}

  514. 

  515. 	    case 3:

  516. 		cplcoeff = q_3[bitstream_get (state, 3)];

  517. 		break;

  518. 

  519. 	    case -3:

  520. 		if (quant->q4_ptr == 0) {

  521. 		    quant->q4_ptr = -1;

  522. 		    cplcoeff = quant->q4;

  523. 		    break;

  524. 		} else {

  525. 		    int code;

  526. 

  527. 		    code = bitstream_get (state, 7);

  528. 

  529. 		    quant->q4_ptr = 0;

  530. 		    quant->q4 = q_4_1[code];

  531. 		    cplcoeff = q_4_0[code];

  532. 		    break;

  533. 		}

  534. 

  535. 	    case 4:

  536. 		cplcoeff = q_5[bitstream_get (state, 4)];

  537. 		break;

  538. 

  539. 	    default:

  540. 		cplcoeff = bitstream_get_2 (state, bapi) << (16 - bapi);

  541. 	    }

  542. #ifndef LIBA52_FIXED

  543. 	    cplcoeff *= scale_factor[exp[i]];

  544. #endif

  545. 	    for (ch = 0; ch < nfchans; ch++)

  546. 	       if ((state->chincpl >> ch) & 1)

  547. #ifndef LIBA52_FIXED

  548. 		    samples[ch][i] = cplcoeff * cplco[ch];

  549. #else

  550. 		    COEFF (samples[ch][i], cplcoeff, cplco[ch],

  551. 			   scale_factor, exp[i]);

  552. #endif

  553. 	    i++;

  554. 	}

  555.     }

  556. }

  557. 

  558. int a52_block (a52_state_t * state)

  559. {

  560.     static const uint8_t nfchans_tbl[] = {2, 1, 2, 3, 3, 4, 4, 5, 1, 1, 2};

  561.     static int rematrix_band[4] = {25, 37, 61, 253};

  562.     int i, nfchans, chaninfo;

  563.     uint8_t cplexpstr, chexpstr[5], lfeexpstr, do_bit_alloc, done_cpl;

  564.     uint8_t blksw[5], dithflag[5];

  565.     level_t coeff[5];

  566.     int chanbias;

  567.     quantizer_set_t quant;

  568.     sample_t * samples;

  569. 

  570.     nfchans = nfchans_tbl[state->acmod];

  571. 

  572.     for (i = 0; i < nfchans; i++)

  573. 	blksw[i] = bitstream_get (state, 1);

  574. 

  575.     for (i = 0; i < nfchans; i++)

  576. 	dithflag[i] = bitstream_get (state, 1);

  577. 

  578.     chaninfo = !state->acmod;

  579.     do {

  580. 	if (bitstream_get (state, 1)) {	/* dynrnge */

  581. 	    int dynrng;

  582. 

  583. 	    dynrng = bitstream_get_2 (state, 8);

  584. 	    if (state->dynrnge) {

  585. 		level_t range;

  586. 

  587. #if !defined(LIBA52_FIXED)

  588. 		range = ((((dynrng & 0x1f) | 0x20) << 13) *

  589. 			 scale_factor[3 - (dynrng >> 5)]);

  590. #else

  591. 		range = ((dynrng & 0x1f) | 0x20) << (21 + (dynrng >> 5));

  592. #endif

  593. 		if (state->dynrngcall)

  594. 		    range = state->dynrngcall (range, state->dynrngdata);

  595. 		state->dynrng = MUL_L (state->level, range);

  596. 	    }

  597. 	}

  598.     } while (chaninfo--);

  599. 

  600.     if (bitstream_get (state, 1)) {	/* cplstre */

  601. 	state->chincpl = 0;

  602. 	if (bitstream_get (state, 1)) {	/* cplinu */

  603. 	    static uint8_t bndtab[16] = {31, 35, 37, 39, 41, 42, 43, 44,

  604. 					 45, 45, 46, 46, 47, 47, 48, 48};

  605. 	    int cplbegf;

  606. 	    int cplendf;

  607. 	    int ncplsubnd;

  608. 

  609. 	    for (i = 0; i < nfchans; i++)

  610. 		state->chincpl |= bitstream_get (state, 1) << i;

  611. 	    switch (state->acmod) {

  612. 	    case 0: case 1:

  613. 		return 1;

  614. 	    case 2:

  615. 		state->phsflginu = bitstream_get (state, 1);

  616. 	    }

  617. 	    cplbegf = bitstream_get (state, 4);

  618. 	    cplendf = bitstream_get (state, 4);

  619. 

  620. 	    if (cplendf + 3 - cplbegf < 0)

  621. 		return 1;

  622. 	    state->ncplbnd = ncplsubnd = cplendf + 3 - cplbegf;

  623. 	    state->cplstrtbnd = bndtab[cplbegf];

  624. 	    state->cplstrtmant = cplbegf * 12 + 37;

  625. 	    state->cplendmant = cplendf * 12 + 73;

  626. 

  627. 	    state->cplbndstrc = 0;

  628. 	    for (i = 0; i < ncplsubnd - 1; i++)

  629. 		if (bitstream_get (state, 1)) {

  630. 		    state->cplbndstrc |= 1 << i;

  631. 		    state->ncplbnd--;

  632. 		}

  633. 	}

  634.     }

  635. 

  636.     if (state->chincpl) {	/* cplinu */

  637. 	int j, cplcoe;

  638. 

  639. 	cplcoe = 0;

  640. 	for (i = 0; i < nfchans; i++)

  641. 	    if ((state->chincpl) >> i & 1)

  642. 		if (bitstream_get (state, 1)) {	/* cplcoe */

  643. 		    int mstrcplco, cplcoexp, cplcomant;

  644. 

  645. 		    cplcoe = 1;

  646. 		    mstrcplco = 3 * bitstream_get (state, 2);

  647. 		    for (j = 0; j < state->ncplbnd; j++) {

  648. 			cplcoexp = bitstream_get (state, 4);

  649. 			cplcomant = bitstream_get (state, 4);

  650. 			if (cplcoexp == 15)

  651. 			    cplcomant <<= 14;

  652. 			else

  653. 			    cplcomant = (cplcomant | 0x10) << 13;

  654. #ifndef LIBA52_FIXED

  655. 			state->cplco[i][j] =

  656. 			    cplcomant * scale_factor[cplcoexp + mstrcplco];

  657. #else

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

  659. #endif

  660. 

  661. 		    }

  662. 		}

  663. 	if ((state->acmod == 2) && state->phsflginu && cplcoe)

  664. 	    for (j = 0; j < state->ncplbnd; j++)

  665. 		if (bitstream_get (state, 1))	/* phsflg */

  666. 		    state->cplco[1][j] = -state->cplco[1][j];

  667.     }

  668. 

  669.     if ((state->acmod == 2) && (bitstream_get (state, 1))) {	/* rematstr */

  670. 	int end;

  671. 

  672. 	state->rematflg = 0;

  673. 	end = (state->chincpl) ? state->cplstrtmant : 253;	/* cplinu */

  674. 	i = 0;

  675. 	do

  676. 	    state->rematflg |= bitstream_get (state, 1) << i;

  677. 	while (rematrix_band[i++] < end);

  678.     }

  679. 

  680.     cplexpstr = EXP_REUSE;

  681.     lfeexpstr = EXP_REUSE;

  682.     if (state->chincpl)	/* cplinu */

  683. 	cplexpstr = bitstream_get (state, 2);

  684.     for (i = 0; i < nfchans; i++)

  685. 	chexpstr[i] = bitstream_get (state, 2);

  686.     if (state->lfeon) 

  687. 	lfeexpstr = bitstream_get (state, 1);

  688. 

  689.     for (i = 0; i < nfchans; i++)

  690. 	if (chexpstr[i] != EXP_REUSE) {

  691. 	    if ((state->chincpl >> i) & 1)

  692. 		state->endmant[i] = state->cplstrtmant;

  693. 	    else {

  694. 		int chbwcod;

  695. 

  696. 		chbwcod = bitstream_get (state, 6);

  697. 		if (chbwcod > 60)

  698. 		    return 1;

  699. 		state->endmant[i] = chbwcod * 3 + 73;

  700. 	    }

  701. 	}

  702. 

  703.     do_bit_alloc = 0;

  704. 

  705.     if (cplexpstr != EXP_REUSE) {

  706. 	int cplabsexp, ncplgrps;

  707. 

  708. 	do_bit_alloc = 64;

  709. 	ncplgrps = ((state->cplendmant - state->cplstrtmant) /

  710. 		    (3 << (cplexpstr - 1)));

  711. 	cplabsexp = bitstream_get (state, 4) << 1;

  712. 	if (parse_exponents (state, cplexpstr, ncplgrps, cplabsexp,

  713. 			     state->cpl_expbap.exp + state->cplstrtmant))

  714. 	    return 1;

  715.     }

  716.     for (i = 0; i < nfchans; i++)

  717. 	if (chexpstr[i] != EXP_REUSE) {

  718. 	    int grp_size, nchgrps;

  719. 

  720. 	    do_bit_alloc |= 1 << i;

  721. 	    grp_size = 3 << (chexpstr[i] - 1);

  722. 	    nchgrps = (state->endmant[i] + grp_size - 4) / grp_size;

  723. 	    state->fbw_expbap[i].exp[0] = bitstream_get (state, 4);

  724. 	    if (parse_exponents (state, chexpstr[i], nchgrps,

  725. 				 state->fbw_expbap[i].exp[0],

  726. 				 state->fbw_expbap[i].exp + 1))

  727. 		return 1;

  728. 	    bitstream_get (state, 2);	/* gainrng */

  729. 	}

  730.     if (lfeexpstr != EXP_REUSE) {

  731. 	do_bit_alloc |= 32;

  732. 	state->lfe_expbap.exp[0] = bitstream_get (state, 4);

  733. 	if (parse_exponents (state, lfeexpstr, 2, state->lfe_expbap.exp[0],

  734. 			     state->lfe_expbap.exp + 1))

  735. 	    return 1;

  736.     }

  737. 

  738.     if (bitstream_get (state, 1)) {	/* baie */

  739. 	do_bit_alloc = 127;

  740. 	state->bai = bitstream_get (state, 11);

  741.     }

  742.     if (bitstream_get (state, 1)) {	/* snroffste */

  743. 	do_bit_alloc = 127;

  744. 	state->csnroffst = bitstream_get (state, 6);

  745. 	if (state->chincpl)	/* cplinu */

  746. 	    state->cplba.bai = bitstream_get (state, 7);

  747. 	for (i = 0; i < nfchans; i++)

  748. 	    state->ba[i].bai = bitstream_get (state, 7);

  749. 	if (state->lfeon)

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

  751.     }

  752.     if ((state->chincpl) && (bitstream_get (state, 1))) { /* cplleake */

  753. 	do_bit_alloc |= 64;

  754. 	state->cplfleak = 9 - bitstream_get (state, 3);

  755. 	state->cplsleak = 9 - bitstream_get (state, 3);

  756.     }

  757. 

  758.     if (bitstream_get (state, 1)) {	/* deltbaie */

  759. 	do_bit_alloc = 127;

  760. 	if (state->chincpl)	/* cplinu */

  761. 	    state->cplba.deltbae = bitstream_get (state, 2);

  762. 	for (i = 0; i < nfchans; i++)

  763. 	    state->ba[i].deltbae = bitstream_get (state, 2);

  764. 	if (state->chincpl &&	/* cplinu */

  765. 	    (state->cplba.deltbae == DELTA_BIT_NEW) &&

  766. 	    parse_deltba (state, state->cplba.deltba))

  767. 	    return 1;

  768. 	for (i = 0; i < nfchans; i++)

  769. 	    if ((state->ba[i].deltbae == DELTA_BIT_NEW) &&

  770. 		parse_deltba (state, state->ba[i].deltba))

  771. 		return 1;

  772.     }

  773. 

  774.     if (do_bit_alloc) {

  775. 	if (zero_snr_offsets (nfchans, state)) {

  776. 	    memset (state->cpl_expbap.bap, 0, sizeof (state->cpl_expbap.bap));

  777. 	    for (i = 0; i < nfchans; i++)

  778. 		memset (state->fbw_expbap[i].bap, 0,

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

  780. 	    memset (state->lfe_expbap.bap, 0, sizeof (state->lfe_expbap.bap));

  781. 	} else {

  782. 	    if (state->chincpl && (do_bit_alloc & 64))	/* cplinu */

  783. 		a52_bit_allocate (state, &state->cplba, state->cplstrtbnd,

  784. 				  state->cplstrtmant, state->cplendmant,

  785. 				  state->cplfleak << 8, state->cplsleak << 8,

  786. 				  &state->cpl_expbap);

  787. 	    for (i = 0; i < nfchans; i++)

  788. 		if (do_bit_alloc & (1 << i))

  789. 		    a52_bit_allocate (state, state->ba + i, 0, 0,

  790. 				      state->endmant[i], 0, 0,

  791. 				      state->fbw_expbap +i);

  792. 	    if (state->lfeon && (do_bit_alloc & 32)) {

  793. 		state->lfeba.deltbae = DELTA_BIT_NONE;

  794. 		a52_bit_allocate (state, &state->lfeba, 0, 0, 7, 0, 0,

  795. 				  &state->lfe_expbap);

  796. 	    }

  797. 	}

  798.     }

  799. 

  800.     if (bitstream_get (state, 1)) {	/* skiple */

  801. 	i = bitstream_get (state, 9);	/* skipl */

  802. 	while (i--)

  803. 	    bitstream_get (state, 8);

  804.     }

  805. 

  806.     samples = state->samples;

  807.     if (state->output & A52_LFE)

  808. 	samples += 256;	/* shift for LFE channel */

  809. 

  810.     chanbias = a52_downmix_coeff (coeff, state->acmod, state->output,

  811. 				  state->dynrng, state->clev, state->slev);

  812. 

  813.     quant.q1_ptr = quant.q2_ptr = quant.q4_ptr = -1;

  814.     done_cpl = 0;

  815. 

  816.     for (i = 0; i < nfchans; i++) {

  817. 	int j;

  818. 

  819. 	coeff_get (state, samples + 256 * i, state->fbw_expbap +i, &quant,

  820. 		   coeff[i], dithflag[i], state->endmant[i]);

  821. 

  822. 	if ((state->chincpl >> i) & 1) {

  823. 	    if (!done_cpl) {

  824. 		done_cpl = 1;

  825. 		coeff_get_coupling (state, nfchans, coeff,

  826. 				    (sample_t (*)[256])samples, &quant,

  827. 				    dithflag);

  828. 	    }

  829. 	    j = state->cplendmant;

  830. 	} else

  831. 	    j = state->endmant[i];

  832. 	do

  833. 	    (samples + 256 * i)[j] = 0;

  834. 	while (++j < 256);

  835.     }

  836. 

  837.     if (state->acmod == 2) {

  838. 	int j, end, band, rematflg;

  839. 

  840. 	end = ((state->endmant[0] < state->endmant[1]) ?

  841. 	       state->endmant[0] : state->endmant[1]);

  842. 

  843. 	i = 0;

  844. 	j = 13;

  845. 	rematflg = state->rematflg;

  846. 	do {

  847. 	    if (! (rematflg & 1)) {

  848. 		rematflg >>= 1;

  849. 		j = rematrix_band[i++];

  850. 		continue;

  851. 	    }

  852. 	    rematflg >>= 1;

  853. 	    band = rematrix_band[i++];

  854. 	    if (band > end)

  855. 		band = end;

  856. 	    do {

  857. 		sample_t tmp0, tmp1;

  858. 

  859. 		tmp0 = samples[j];

  860. 		tmp1 = (samples+256)[j];

  861. 		samples[j] = tmp0 + tmp1;

  862. 		(samples+256)[j] = tmp0 - tmp1;

  863. 	    } while (++j < band);

  864. 	} while (j < end);

  865.     }

  866. 

  867.     if (state->lfeon) {

  868. 	if (state->output & A52_LFE) {

  869. 	    coeff_get (state, samples - 256, &state->lfe_expbap, &quant,

  870. 		       state->dynrng, 0, 7);

  871. 	    for (i = 7; i < 256; i++)

  872. 		(samples-256)[i] = 0;

  873. 	    a52_imdct_512 (samples - 256, samples + 1536 - 256, state->bias);

  874. 	} else {

  875. 	    /* just skip the LFE coefficients */

  876. 	    coeff_get (state, samples + 1280, &state->lfe_expbap, &quant,

  877. 		       0, 0, 7);

  878. 	}

  879.     }

  880. 

  881.     i = 0;

  882.     if (nfchans_tbl[state->output & A52_CHANNEL_MASK] < nfchans)

  883. 	for (i = 1; i < nfchans; i++)

  884. 	    if (blksw[i] != blksw[0])

  885. 		break;

  886. 

  887.     if (i < nfchans) {

  888. 	if (state->downmixed) {

  889. 	    state->downmixed = 0;

  890. 	    a52_upmix (samples + 1536, state->acmod, state->output);

  891. 	}

  892. 

  893. 	for (i = 0; i < nfchans; i++) {

  894. 	    sample_t bias;

  895. 

  896. 	    bias = 0;

  897. 	    if (!(chanbias & (1 << i)))

  898. 		bias = state->bias;

  899. 

  900. 	    if (coeff[i]) {

  901. 		if (blksw[i])

  902. 		    a52_imdct_256 (samples + 256 * i, samples + 1536 + 256 * i,

  903. 				   bias);

  904. 		else 

  905. 		    a52_imdct_512 (samples + 256 * i, samples + 1536 + 256 * i,

  906. 				   bias);

  907. 	    } else {

  908. 		int j;

  909. 

  910. 		for (j = 0; j < 256; j++)

  911. 		    (samples + 256 * i)[j] = bias;

  912. 	    }

  913. 	}

  914. 

  915. 	a52_downmix (samples, state->acmod, state->output, state->bias,

  916. 		     state->clev, state->slev);

  917.     } else {

  918. 	nfchans = nfchans_tbl[state->output & A52_CHANNEL_MASK];

  919. 

  920. 	a52_downmix (samples, state->acmod, state->output, 0,

  921. 		     state->clev, state->slev);

  922. 

  923. 	if (!state->downmixed) {

  924. 	    state->downmixed = 1;

  925. 	    a52_downmix (samples + 1536, state->acmod, state->output, 0,

  926. 			 state->clev, state->slev);

  927. 	}

  928. 

  929. 	if (blksw[0])

  930. 	    for (i = 0; i < nfchans; i++)

  931. 		a52_imdct_256 (samples + 256 * i, samples + 1536 + 256 * i,

  932. 			       state->bias);

  933. 	else 

  934. 	    for (i = 0; i < nfchans; i++)

  935. 		a52_imdct_512 (samples + 256 * i, samples + 1536 + 256 * i,

  936. 			       state->bias);

  937.     }

  938. 

  939.     return 0;

  940. }

  941. 

  942. void a52_free (a52_state_t * state)

  943. {

  944.     free (state->samples);

  945.     free (state);

  946. }