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.

1846 lines
58KB

  1. /*
  2. * The simplest AC-3 encoder
  3. * Copyright (c) 2000 Fabrice Bellard
  4. * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
  5. * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
  6. *
  7. * This file is part of FFmpeg.
  8. *
  9. * FFmpeg is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU Lesser General Public
  11. * License as published by the Free Software Foundation; either
  12. * version 2.1 of the License, or (at your option) any later version.
  13. *
  14. * FFmpeg 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 GNU
  17. * Lesser General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU Lesser General Public
  20. * License along with FFmpeg; if not, write to the Free Software
  21. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22. */
  23. /**
  24. * @file
  25. * The simplest AC-3 encoder.
  26. */
  27. //#define DEBUG
  28. #include "libavutil/audioconvert.h"
  29. #include "libavutil/crc.h"
  30. #include "avcodec.h"
  31. #include "put_bits.h"
  32. #include "dsputil.h"
  33. #include "ac3dsp.h"
  34. #include "ac3.h"
  35. #include "audioconvert.h"
  36. #ifndef CONFIG_AC3ENC_FLOAT
  37. #define CONFIG_AC3ENC_FLOAT 0
  38. #endif
  39. /** Maximum number of exponent groups. +1 for separate DC exponent. */
  40. #define AC3_MAX_EXP_GROUPS 85
  41. /* stereo rematrixing algorithms */
  42. #define AC3_REMATRIXING_IS_STATIC 0x1
  43. #define AC3_REMATRIXING_SUMS 0
  44. #define AC3_REMATRIXING_NONE 1
  45. #define AC3_REMATRIXING_ALWAYS 3
  46. /** Scale a float value by 2^bits and convert to an integer. */
  47. #define SCALE_FLOAT(a, bits) lrintf((a) * (float)(1 << (bits)))
  48. #if CONFIG_AC3ENC_FLOAT
  49. #include "ac3enc_float.h"
  50. #else
  51. #include "ac3enc_fixed.h"
  52. #endif
  53. /**
  54. * Data for a single audio block.
  55. */
  56. typedef struct AC3Block {
  57. uint8_t **bap; ///< bit allocation pointers (bap)
  58. CoefType **mdct_coef; ///< MDCT coefficients
  59. int32_t **fixed_coef; ///< fixed-point MDCT coefficients
  60. uint8_t **exp; ///< original exponents
  61. uint8_t **grouped_exp; ///< grouped exponents
  62. int16_t **psd; ///< psd per frequency bin
  63. int16_t **band_psd; ///< psd per critical band
  64. int16_t **mask; ///< masking curve
  65. uint16_t **qmant; ///< quantized mantissas
  66. int8_t exp_shift[AC3_MAX_CHANNELS]; ///< exponent shift values
  67. uint8_t new_rematrixing_strategy; ///< send new rematrixing flags in this block
  68. uint8_t rematrixing_flags[4]; ///< rematrixing flags
  69. } AC3Block;
  70. /**
  71. * AC-3 encoder private context.
  72. */
  73. typedef struct AC3EncodeContext {
  74. PutBitContext pb; ///< bitstream writer context
  75. DSPContext dsp;
  76. AC3DSPContext ac3dsp; ///< AC-3 optimized functions
  77. AC3MDCTContext mdct; ///< MDCT context
  78. AC3Block blocks[AC3_MAX_BLOCKS]; ///< per-block info
  79. int bitstream_id; ///< bitstream id (bsid)
  80. int bitstream_mode; ///< bitstream mode (bsmod)
  81. int bit_rate; ///< target bit rate, in bits-per-second
  82. int sample_rate; ///< sampling frequency, in Hz
  83. int frame_size_min; ///< minimum frame size in case rounding is necessary
  84. int frame_size; ///< current frame size in bytes
  85. int frame_size_code; ///< frame size code (frmsizecod)
  86. uint16_t crc_inv[2];
  87. int bits_written; ///< bit count (used to avg. bitrate)
  88. int samples_written; ///< sample count (used to avg. bitrate)
  89. int fbw_channels; ///< number of full-bandwidth channels (nfchans)
  90. int channels; ///< total number of channels (nchans)
  91. int lfe_on; ///< indicates if there is an LFE channel (lfeon)
  92. int lfe_channel; ///< channel index of the LFE channel
  93. int channel_mode; ///< channel mode (acmod)
  94. const uint8_t *channel_map; ///< channel map used to reorder channels
  95. int cutoff; ///< user-specified cutoff frequency, in Hz
  96. int bandwidth_code[AC3_MAX_CHANNELS]; ///< bandwidth code (0 to 60) (chbwcod)
  97. int nb_coefs[AC3_MAX_CHANNELS];
  98. int rematrixing; ///< determines how rematrixing strategy is calculated
  99. int num_rematrixing_bands; ///< number of rematrixing bands
  100. /* bitrate allocation control */
  101. int slow_gain_code; ///< slow gain code (sgaincod)
  102. int slow_decay_code; ///< slow decay code (sdcycod)
  103. int fast_decay_code; ///< fast decay code (fdcycod)
  104. int db_per_bit_code; ///< dB/bit code (dbpbcod)
  105. int floor_code; ///< floor code (floorcod)
  106. AC3BitAllocParameters bit_alloc; ///< bit allocation parameters
  107. int coarse_snr_offset; ///< coarse SNR offsets (csnroffst)
  108. int fast_gain_code[AC3_MAX_CHANNELS]; ///< fast gain codes (signal-to-mask ratio) (fgaincod)
  109. int fine_snr_offset[AC3_MAX_CHANNELS]; ///< fine SNR offsets (fsnroffst)
  110. int frame_bits_fixed; ///< number of non-coefficient bits for fixed parameters
  111. int frame_bits; ///< all frame bits except exponents and mantissas
  112. int exponent_bits; ///< number of bits used for exponents
  113. /* mantissa encoding */
  114. int mant1_cnt, mant2_cnt, mant4_cnt; ///< mantissa counts for bap=1,2,4
  115. uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
  116. SampleType **planar_samples;
  117. uint8_t *bap_buffer;
  118. uint8_t *bap1_buffer;
  119. CoefType *mdct_coef_buffer;
  120. int32_t *fixed_coef_buffer;
  121. uint8_t *exp_buffer;
  122. uint8_t *grouped_exp_buffer;
  123. int16_t *psd_buffer;
  124. int16_t *band_psd_buffer;
  125. int16_t *mask_buffer;
  126. uint16_t *qmant_buffer;
  127. uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< exponent strategies
  128. DECLARE_ALIGNED(16, SampleType, windowed_samples)[AC3_WINDOW_SIZE];
  129. } AC3EncodeContext;
  130. /* prototypes for functions in ac3enc_fixed.c and ac3enc_float.c */
  131. static av_cold void mdct_end(AC3MDCTContext *mdct);
  132. static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
  133. int nbits);
  134. static void mdct512(AC3MDCTContext *mdct, CoefType *out, SampleType *in);
  135. static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input,
  136. const SampleType *window, int n);
  137. static int normalize_samples(AC3EncodeContext *s);
  138. static void scale_coefficients(AC3EncodeContext *s);
  139. /**
  140. * LUT for number of exponent groups.
  141. * exponent_group_tab[exponent strategy-1][number of coefficients]
  142. */
  143. static uint8_t exponent_group_tab[3][256];
  144. /**
  145. * List of supported channel layouts.
  146. */
  147. static const int64_t ac3_channel_layouts[] = {
  148. AV_CH_LAYOUT_MONO,
  149. AV_CH_LAYOUT_STEREO,
  150. AV_CH_LAYOUT_2_1,
  151. AV_CH_LAYOUT_SURROUND,
  152. AV_CH_LAYOUT_2_2,
  153. AV_CH_LAYOUT_QUAD,
  154. AV_CH_LAYOUT_4POINT0,
  155. AV_CH_LAYOUT_5POINT0,
  156. AV_CH_LAYOUT_5POINT0_BACK,
  157. (AV_CH_LAYOUT_MONO | AV_CH_LOW_FREQUENCY),
  158. (AV_CH_LAYOUT_STEREO | AV_CH_LOW_FREQUENCY),
  159. (AV_CH_LAYOUT_2_1 | AV_CH_LOW_FREQUENCY),
  160. (AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY),
  161. (AV_CH_LAYOUT_2_2 | AV_CH_LOW_FREQUENCY),
  162. (AV_CH_LAYOUT_QUAD | AV_CH_LOW_FREQUENCY),
  163. (AV_CH_LAYOUT_4POINT0 | AV_CH_LOW_FREQUENCY),
  164. AV_CH_LAYOUT_5POINT1,
  165. AV_CH_LAYOUT_5POINT1_BACK,
  166. 0
  167. };
  168. /**
  169. * Adjust the frame size to make the average bit rate match the target bit rate.
  170. * This is only needed for 11025, 22050, and 44100 sample rates.
  171. */
  172. static void adjust_frame_size(AC3EncodeContext *s)
  173. {
  174. while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
  175. s->bits_written -= s->bit_rate;
  176. s->samples_written -= s->sample_rate;
  177. }
  178. s->frame_size = s->frame_size_min +
  179. 2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
  180. s->bits_written += s->frame_size * 8;
  181. s->samples_written += AC3_FRAME_SIZE;
  182. }
  183. /**
  184. * Deinterleave input samples.
  185. * Channels are reordered from FFmpeg's default order to AC-3 order.
  186. */
  187. static void deinterleave_input_samples(AC3EncodeContext *s,
  188. const SampleType *samples)
  189. {
  190. int ch, i;
  191. /* deinterleave and remap input samples */
  192. for (ch = 0; ch < s->channels; ch++) {
  193. const SampleType *sptr;
  194. int sinc;
  195. /* copy last 256 samples of previous frame to the start of the current frame */
  196. memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_FRAME_SIZE],
  197. AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0]));
  198. /* deinterleave */
  199. sinc = s->channels;
  200. sptr = samples + s->channel_map[ch];
  201. for (i = AC3_BLOCK_SIZE; i < AC3_FRAME_SIZE+AC3_BLOCK_SIZE; i++) {
  202. s->planar_samples[ch][i] = *sptr;
  203. sptr += sinc;
  204. }
  205. }
  206. }
  207. /**
  208. * Apply the MDCT to input samples to generate frequency coefficients.
  209. * This applies the KBD window and normalizes the input to reduce precision
  210. * loss due to fixed-point calculations.
  211. */
  212. static void apply_mdct(AC3EncodeContext *s)
  213. {
  214. int blk, ch;
  215. for (ch = 0; ch < s->channels; ch++) {
  216. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  217. AC3Block *block = &s->blocks[blk];
  218. const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
  219. apply_window(&s->dsp, s->windowed_samples, input_samples, s->mdct.window, AC3_WINDOW_SIZE);
  220. block->exp_shift[ch] = normalize_samples(s);
  221. mdct512(&s->mdct, block->mdct_coef[ch], s->windowed_samples);
  222. }
  223. }
  224. }
  225. /**
  226. * Initialize stereo rematrixing.
  227. * If the strategy does not change for each frame, set the rematrixing flags.
  228. */
  229. static void rematrixing_init(AC3EncodeContext *s)
  230. {
  231. if (s->channel_mode == AC3_CHMODE_STEREO)
  232. s->rematrixing = AC3_REMATRIXING_SUMS;
  233. else
  234. s->rematrixing = AC3_REMATRIXING_NONE;
  235. /* NOTE: AC3_REMATRIXING_ALWAYS might be used in
  236. the future in conjunction with channel coupling. */
  237. if (s->rematrixing & AC3_REMATRIXING_IS_STATIC) {
  238. int flag = (s->rematrixing == AC3_REMATRIXING_ALWAYS);
  239. s->blocks[0].new_rematrixing_strategy = 1;
  240. memset(s->blocks[0].rematrixing_flags, flag,
  241. sizeof(s->blocks[0].rematrixing_flags));
  242. }
  243. }
  244. /**
  245. * Determine rematrixing flags for each block and band.
  246. */
  247. static void compute_rematrixing_strategy(AC3EncodeContext *s)
  248. {
  249. int nb_coefs;
  250. int blk, bnd, i;
  251. AC3Block *block, *block0;
  252. s->num_rematrixing_bands = 4;
  253. if (s->rematrixing & AC3_REMATRIXING_IS_STATIC)
  254. return;
  255. nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);
  256. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  257. block = &s->blocks[blk];
  258. block->new_rematrixing_strategy = !blk;
  259. for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
  260. /* calculate calculate sum of squared coeffs for one band in one block */
  261. int start = ff_ac3_rematrix_band_tab[bnd];
  262. int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
  263. CoefSumType sum[4] = {0,};
  264. for (i = start; i < end; i++) {
  265. CoefType lt = block->mdct_coef[0][i];
  266. CoefType rt = block->mdct_coef[1][i];
  267. CoefType md = lt + rt;
  268. CoefType sd = lt - rt;
  269. sum[0] += lt * lt;
  270. sum[1] += rt * rt;
  271. sum[2] += md * md;
  272. sum[3] += sd * sd;
  273. }
  274. /* compare sums to determine if rematrixing will be used for this band */
  275. if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1]))
  276. block->rematrixing_flags[bnd] = 1;
  277. else
  278. block->rematrixing_flags[bnd] = 0;
  279. /* determine if new rematrixing flags will be sent */
  280. if (blk &&
  281. block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) {
  282. block->new_rematrixing_strategy = 1;
  283. }
  284. }
  285. block0 = block;
  286. }
  287. }
  288. /**
  289. * Apply stereo rematrixing to coefficients based on rematrixing flags.
  290. */
  291. static void apply_rematrixing(AC3EncodeContext *s)
  292. {
  293. int nb_coefs;
  294. int blk, bnd, i;
  295. int start, end;
  296. uint8_t *flags;
  297. if (s->rematrixing == AC3_REMATRIXING_NONE)
  298. return;
  299. nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);
  300. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  301. AC3Block *block = &s->blocks[blk];
  302. if (block->new_rematrixing_strategy)
  303. flags = block->rematrixing_flags;
  304. for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
  305. if (flags[bnd]) {
  306. start = ff_ac3_rematrix_band_tab[bnd];
  307. end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
  308. for (i = start; i < end; i++) {
  309. int32_t lt = block->fixed_coef[0][i];
  310. int32_t rt = block->fixed_coef[1][i];
  311. block->fixed_coef[0][i] = (lt + rt) >> 1;
  312. block->fixed_coef[1][i] = (lt - rt) >> 1;
  313. }
  314. }
  315. }
  316. }
  317. }
  318. /**
  319. * Initialize exponent tables.
  320. */
  321. static av_cold void exponent_init(AC3EncodeContext *s)
  322. {
  323. int i;
  324. for (i = 73; i < 256; i++) {
  325. exponent_group_tab[0][i] = (i - 1) / 3;
  326. exponent_group_tab[1][i] = (i + 2) / 6;
  327. exponent_group_tab[2][i] = (i + 8) / 12;
  328. }
  329. /* LFE */
  330. exponent_group_tab[0][7] = 2;
  331. }
  332. /**
  333. * Extract exponents from the MDCT coefficients.
  334. * This takes into account the normalization that was done to the input samples
  335. * by adjusting the exponents by the exponent shift values.
  336. */
  337. static void extract_exponents(AC3EncodeContext *s)
  338. {
  339. int blk, ch, i;
  340. for (ch = 0; ch < s->channels; ch++) {
  341. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  342. AC3Block *block = &s->blocks[blk];
  343. uint8_t *exp = block->exp[ch];
  344. int32_t *coef = block->fixed_coef[ch];
  345. int exp_shift = block->exp_shift[ch];
  346. for (i = 0; i < AC3_MAX_COEFS; i++) {
  347. int e;
  348. int v = abs(coef[i]);
  349. if (v == 0)
  350. e = 24;
  351. else {
  352. e = 23 - av_log2(v) + exp_shift;
  353. if (e >= 24) {
  354. e = 24;
  355. coef[i] = 0;
  356. }
  357. }
  358. exp[i] = e;
  359. }
  360. }
  361. }
  362. }
  363. /**
  364. * Exponent Difference Threshold.
  365. * New exponents are sent if their SAD exceed this number.
  366. */
  367. #define EXP_DIFF_THRESHOLD 500
  368. /**
  369. * Calculate exponent strategies for all blocks in a single channel.
  370. */
  371. static void compute_exp_strategy_ch(AC3EncodeContext *s, uint8_t *exp_strategy,
  372. uint8_t *exp)
  373. {
  374. int blk, blk1;
  375. int exp_diff;
  376. /* estimate if the exponent variation & decide if they should be
  377. reused in the next frame */
  378. exp_strategy[0] = EXP_NEW;
  379. exp += AC3_MAX_COEFS;
  380. for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) {
  381. exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
  382. if (exp_diff > EXP_DIFF_THRESHOLD)
  383. exp_strategy[blk] = EXP_NEW;
  384. else
  385. exp_strategy[blk] = EXP_REUSE;
  386. exp += AC3_MAX_COEFS;
  387. }
  388. /* now select the encoding strategy type : if exponents are often
  389. recoded, we use a coarse encoding */
  390. blk = 0;
  391. while (blk < AC3_MAX_BLOCKS) {
  392. blk1 = blk + 1;
  393. while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)
  394. blk1++;
  395. switch (blk1 - blk) {
  396. case 1: exp_strategy[blk] = EXP_D45; break;
  397. case 2:
  398. case 3: exp_strategy[blk] = EXP_D25; break;
  399. default: exp_strategy[blk] = EXP_D15; break;
  400. }
  401. blk = blk1;
  402. }
  403. }
  404. /**
  405. * Calculate exponent strategies for all channels.
  406. * Array arrangement is reversed to simplify the per-channel calculation.
  407. */
  408. static void compute_exp_strategy(AC3EncodeContext *s)
  409. {
  410. int ch, blk;
  411. for (ch = 0; ch < s->fbw_channels; ch++) {
  412. compute_exp_strategy_ch(s, s->exp_strategy[ch], s->blocks[0].exp[ch]);
  413. }
  414. if (s->lfe_on) {
  415. ch = s->lfe_channel;
  416. s->exp_strategy[ch][0] = EXP_D15;
  417. for (blk = 1; blk < AC3_MAX_BLOCKS; blk++)
  418. s->exp_strategy[ch][blk] = EXP_REUSE;
  419. }
  420. }
  421. /**
  422. * Update the exponents so that they are the ones the decoder will decode.
  423. */
  424. static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy)
  425. {
  426. int nb_groups, i, k;
  427. nb_groups = exponent_group_tab[exp_strategy-1][nb_exps] * 3;
  428. /* for each group, compute the minimum exponent */
  429. switch(exp_strategy) {
  430. case EXP_D25:
  431. for (i = 1, k = 1; i <= nb_groups; i++) {
  432. uint8_t exp_min = exp[k];
  433. if (exp[k+1] < exp_min)
  434. exp_min = exp[k+1];
  435. exp[i] = exp_min;
  436. k += 2;
  437. }
  438. break;
  439. case EXP_D45:
  440. for (i = 1, k = 1; i <= nb_groups; i++) {
  441. uint8_t exp_min = exp[k];
  442. if (exp[k+1] < exp_min)
  443. exp_min = exp[k+1];
  444. if (exp[k+2] < exp_min)
  445. exp_min = exp[k+2];
  446. if (exp[k+3] < exp_min)
  447. exp_min = exp[k+3];
  448. exp[i] = exp_min;
  449. k += 4;
  450. }
  451. break;
  452. }
  453. /* constraint for DC exponent */
  454. if (exp[0] > 15)
  455. exp[0] = 15;
  456. /* decrease the delta between each groups to within 2 so that they can be
  457. differentially encoded */
  458. for (i = 1; i <= nb_groups; i++)
  459. exp[i] = FFMIN(exp[i], exp[i-1] + 2);
  460. i--;
  461. while (--i >= 0)
  462. exp[i] = FFMIN(exp[i], exp[i+1] + 2);
  463. /* now we have the exponent values the decoder will see */
  464. switch (exp_strategy) {
  465. case EXP_D25:
  466. for (i = nb_groups, k = nb_groups * 2; i > 0; i--) {
  467. uint8_t exp1 = exp[i];
  468. exp[k--] = exp1;
  469. exp[k--] = exp1;
  470. }
  471. break;
  472. case EXP_D45:
  473. for (i = nb_groups, k = nb_groups * 4; i > 0; i--) {
  474. exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i];
  475. k -= 4;
  476. }
  477. break;
  478. }
  479. }
  480. /**
  481. * Encode exponents from original extracted form to what the decoder will see.
  482. * This copies and groups exponents based on exponent strategy and reduces
  483. * deltas between adjacent exponent groups so that they can be differentially
  484. * encoded.
  485. */
  486. static void encode_exponents(AC3EncodeContext *s)
  487. {
  488. int blk, blk1, ch;
  489. uint8_t *exp, *exp1, *exp_strategy;
  490. int nb_coefs, num_reuse_blocks;
  491. for (ch = 0; ch < s->channels; ch++) {
  492. exp = s->blocks[0].exp[ch];
  493. exp_strategy = s->exp_strategy[ch];
  494. nb_coefs = s->nb_coefs[ch];
  495. blk = 0;
  496. while (blk < AC3_MAX_BLOCKS) {
  497. blk1 = blk + 1;
  498. /* count the number of EXP_REUSE blocks after the current block */
  499. while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)
  500. blk1++;
  501. num_reuse_blocks = blk1 - blk - 1;
  502. /* for the EXP_REUSE case we select the min of the exponents */
  503. s->ac3dsp.ac3_exponent_min(exp, num_reuse_blocks, nb_coefs);
  504. encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk]);
  505. /* copy encoded exponents for reuse case */
  506. exp1 = exp + AC3_MAX_COEFS;
  507. while (blk < blk1-1) {
  508. memcpy(exp1, exp, nb_coefs * sizeof(*exp));
  509. exp1 += AC3_MAX_COEFS;
  510. blk++;
  511. }
  512. blk = blk1;
  513. exp = exp1;
  514. }
  515. }
  516. }
  517. /**
  518. * Group exponents.
  519. * 3 delta-encoded exponents are in each 7-bit group. The number of groups
  520. * varies depending on exponent strategy and bandwidth.
  521. */
  522. static void group_exponents(AC3EncodeContext *s)
  523. {
  524. int blk, ch, i;
  525. int group_size, nb_groups, bit_count;
  526. uint8_t *p;
  527. int delta0, delta1, delta2;
  528. int exp0, exp1;
  529. bit_count = 0;
  530. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  531. AC3Block *block = &s->blocks[blk];
  532. for (ch = 0; ch < s->channels; ch++) {
  533. int exp_strategy = s->exp_strategy[ch][blk];
  534. if (exp_strategy == EXP_REUSE)
  535. continue;
  536. group_size = exp_strategy + (exp_strategy == EXP_D45);
  537. nb_groups = exponent_group_tab[exp_strategy-1][s->nb_coefs[ch]];
  538. bit_count += 4 + (nb_groups * 7);
  539. p = block->exp[ch];
  540. /* DC exponent */
  541. exp1 = *p++;
  542. block->grouped_exp[ch][0] = exp1;
  543. /* remaining exponents are delta encoded */
  544. for (i = 1; i <= nb_groups; i++) {
  545. /* merge three delta in one code */
  546. exp0 = exp1;
  547. exp1 = p[0];
  548. p += group_size;
  549. delta0 = exp1 - exp0 + 2;
  550. exp0 = exp1;
  551. exp1 = p[0];
  552. p += group_size;
  553. delta1 = exp1 - exp0 + 2;
  554. exp0 = exp1;
  555. exp1 = p[0];
  556. p += group_size;
  557. delta2 = exp1 - exp0 + 2;
  558. block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
  559. }
  560. }
  561. }
  562. s->exponent_bits = bit_count;
  563. }
  564. /**
  565. * Calculate final exponents from the supplied MDCT coefficients and exponent shift.
  566. * Extract exponents from MDCT coefficients, calculate exponent strategies,
  567. * and encode final exponents.
  568. */
  569. static void process_exponents(AC3EncodeContext *s)
  570. {
  571. extract_exponents(s);
  572. compute_exp_strategy(s);
  573. encode_exponents(s);
  574. group_exponents(s);
  575. emms_c();
  576. }
  577. /**
  578. * Count frame bits that are based solely on fixed parameters.
  579. * This only has to be run once when the encoder is initialized.
  580. */
  581. static void count_frame_bits_fixed(AC3EncodeContext *s)
  582. {
  583. static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
  584. int blk;
  585. int frame_bits;
  586. /* assumptions:
  587. * no dynamic range codes
  588. * no channel coupling
  589. * bit allocation parameters do not change between blocks
  590. * SNR offsets do not change between blocks
  591. * no delta bit allocation
  592. * no skipped data
  593. * no auxilliary data
  594. */
  595. /* header size */
  596. frame_bits = 65;
  597. frame_bits += frame_bits_inc[s->channel_mode];
  598. /* audio blocks */
  599. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  600. frame_bits += s->fbw_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */
  601. if (s->channel_mode == AC3_CHMODE_STEREO) {
  602. frame_bits++; /* rematstr */
  603. }
  604. frame_bits += 2 * s->fbw_channels; /* chexpstr[2] * c */
  605. if (s->lfe_on)
  606. frame_bits++; /* lfeexpstr */
  607. frame_bits++; /* baie */
  608. frame_bits++; /* snr */
  609. frame_bits += 2; /* delta / skip */
  610. }
  611. frame_bits++; /* cplinu for block 0 */
  612. /* bit alloc info */
  613. /* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */
  614. /* csnroffset[6] */
  615. /* (fsnoffset[4] + fgaincod[4]) * c */
  616. frame_bits += 2*4 + 3 + 6 + s->channels * (4 + 3);
  617. /* auxdatae, crcrsv */
  618. frame_bits += 2;
  619. /* CRC */
  620. frame_bits += 16;
  621. s->frame_bits_fixed = frame_bits;
  622. }
  623. /**
  624. * Initialize bit allocation.
  625. * Set default parameter codes and calculate parameter values.
  626. */
  627. static void bit_alloc_init(AC3EncodeContext *s)
  628. {
  629. int ch;
  630. /* init default parameters */
  631. s->slow_decay_code = 2;
  632. s->fast_decay_code = 1;
  633. s->slow_gain_code = 1;
  634. s->db_per_bit_code = 3;
  635. s->floor_code = 7;
  636. for (ch = 0; ch < s->channels; ch++)
  637. s->fast_gain_code[ch] = 4;
  638. /* initial snr offset */
  639. s->coarse_snr_offset = 40;
  640. /* compute real values */
  641. /* currently none of these values change during encoding, so we can just
  642. set them once at initialization */
  643. s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->bit_alloc.sr_shift;
  644. s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->bit_alloc.sr_shift;
  645. s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code];
  646. s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
  647. s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code];
  648. count_frame_bits_fixed(s);
  649. }
  650. /**
  651. * Count the bits used to encode the frame, minus exponents and mantissas.
  652. * Bits based on fixed parameters have already been counted, so now we just
  653. * have to add the bits based on parameters that change during encoding.
  654. */
  655. static void count_frame_bits(AC3EncodeContext *s)
  656. {
  657. int blk, ch;
  658. int frame_bits = 0;
  659. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  660. /* stereo rematrixing */
  661. if (s->channel_mode == AC3_CHMODE_STEREO &&
  662. s->blocks[blk].new_rematrixing_strategy) {
  663. frame_bits += s->num_rematrixing_bands;
  664. }
  665. for (ch = 0; ch < s->fbw_channels; ch++) {
  666. if (s->exp_strategy[ch][blk] != EXP_REUSE)
  667. frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */
  668. }
  669. }
  670. s->frame_bits = s->frame_bits_fixed + frame_bits;
  671. }
  672. /**
  673. * Calculate the number of bits needed to encode a set of mantissas.
  674. */
  675. static int compute_mantissa_size(int mant_cnt[5], uint8_t *bap, int nb_coefs)
  676. {
  677. int bits, b, i;
  678. bits = 0;
  679. for (i = 0; i < nb_coefs; i++) {
  680. b = bap[i];
  681. if (b <= 4) {
  682. // bap=1 to bap=4 will be counted in compute_mantissa_size_final
  683. mant_cnt[b]++;
  684. } else if (b <= 13) {
  685. // bap=5 to bap=13 use (bap-1) bits
  686. bits += b - 1;
  687. } else {
  688. // bap=14 uses 14 bits and bap=15 uses 16 bits
  689. bits += (b == 14) ? 14 : 16;
  690. }
  691. }
  692. return bits;
  693. }
  694. /**
  695. * Finalize the mantissa bit count by adding in the grouped mantissas.
  696. */
  697. static int compute_mantissa_size_final(int mant_cnt[5])
  698. {
  699. // bap=1 : 3 mantissas in 5 bits
  700. int bits = (mant_cnt[1] / 3) * 5;
  701. // bap=2 : 3 mantissas in 7 bits
  702. // bap=4 : 2 mantissas in 7 bits
  703. bits += ((mant_cnt[2] / 3) + (mant_cnt[4] >> 1)) * 7;
  704. // bap=3 : each mantissa is 3 bits
  705. bits += mant_cnt[3] * 3;
  706. return bits;
  707. }
  708. /**
  709. * Calculate masking curve based on the final exponents.
  710. * Also calculate the power spectral densities to use in future calculations.
  711. */
  712. static void bit_alloc_masking(AC3EncodeContext *s)
  713. {
  714. int blk, ch;
  715. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  716. AC3Block *block = &s->blocks[blk];
  717. for (ch = 0; ch < s->channels; ch++) {
  718. /* We only need psd and mask for calculating bap.
  719. Since we currently do not calculate bap when exponent
  720. strategy is EXP_REUSE we do not need to calculate psd or mask. */
  721. if (s->exp_strategy[ch][blk] != EXP_REUSE) {
  722. ff_ac3_bit_alloc_calc_psd(block->exp[ch], 0,
  723. s->nb_coefs[ch],
  724. block->psd[ch], block->band_psd[ch]);
  725. ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch],
  726. 0, s->nb_coefs[ch],
  727. ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
  728. ch == s->lfe_channel,
  729. DBA_NONE, 0, NULL, NULL, NULL,
  730. block->mask[ch]);
  731. }
  732. }
  733. }
  734. }
  735. /**
  736. * Ensure that bap for each block and channel point to the current bap_buffer.
  737. * They may have been switched during the bit allocation search.
  738. */
  739. static void reset_block_bap(AC3EncodeContext *s)
  740. {
  741. int blk, ch;
  742. if (s->blocks[0].bap[0] == s->bap_buffer)
  743. return;
  744. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  745. for (ch = 0; ch < s->channels; ch++) {
  746. s->blocks[blk].bap[ch] = &s->bap_buffer[AC3_MAX_COEFS * (blk * s->channels + ch)];
  747. }
  748. }
  749. }
  750. /**
  751. * Run the bit allocation with a given SNR offset.
  752. * This calculates the bit allocation pointers that will be used to determine
  753. * the quantization of each mantissa.
  754. * @return the number of bits needed for mantissas if the given SNR offset is
  755. * is used.
  756. */
  757. static int bit_alloc(AC3EncodeContext *s, int snr_offset)
  758. {
  759. int blk, ch;
  760. int mantissa_bits;
  761. int mant_cnt[5];
  762. snr_offset = (snr_offset - 240) << 2;
  763. reset_block_bap(s);
  764. mantissa_bits = 0;
  765. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  766. AC3Block *block = &s->blocks[blk];
  767. // initialize grouped mantissa counts. these are set so that they are
  768. // padded to the next whole group size when bits are counted in
  769. // compute_mantissa_size_final
  770. mant_cnt[0] = mant_cnt[3] = 0;
  771. mant_cnt[1] = mant_cnt[2] = 2;
  772. mant_cnt[4] = 1;
  773. for (ch = 0; ch < s->channels; ch++) {
  774. /* Currently the only bit allocation parameters which vary across
  775. blocks within a frame are the exponent values. We can take
  776. advantage of that by reusing the bit allocation pointers
  777. whenever we reuse exponents. */
  778. if (s->exp_strategy[ch][blk] == EXP_REUSE) {
  779. memcpy(block->bap[ch], s->blocks[blk-1].bap[ch], AC3_MAX_COEFS);
  780. } else {
  781. ff_ac3_bit_alloc_calc_bap(block->mask[ch], block->psd[ch], 0,
  782. s->nb_coefs[ch], snr_offset,
  783. s->bit_alloc.floor, ff_ac3_bap_tab,
  784. block->bap[ch]);
  785. }
  786. mantissa_bits += compute_mantissa_size(mant_cnt, block->bap[ch], s->nb_coefs[ch]);
  787. }
  788. mantissa_bits += compute_mantissa_size_final(mant_cnt);
  789. }
  790. return mantissa_bits;
  791. }
  792. /**
  793. * Constant bitrate bit allocation search.
  794. * Find the largest SNR offset that will allow data to fit in the frame.
  795. */
  796. static int cbr_bit_allocation(AC3EncodeContext *s)
  797. {
  798. int ch;
  799. int bits_left;
  800. int snr_offset, snr_incr;
  801. bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
  802. snr_offset = s->coarse_snr_offset << 4;
  803. /* if previous frame SNR offset was 1023, check if current frame can also
  804. use SNR offset of 1023. if so, skip the search. */
  805. if ((snr_offset | s->fine_snr_offset[0]) == 1023) {
  806. if (bit_alloc(s, 1023) <= bits_left)
  807. return 0;
  808. }
  809. while (snr_offset >= 0 &&
  810. bit_alloc(s, snr_offset) > bits_left) {
  811. snr_offset -= 64;
  812. }
  813. if (snr_offset < 0)
  814. return AVERROR(EINVAL);
  815. FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
  816. for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) {
  817. while (snr_offset + snr_incr <= 1023 &&
  818. bit_alloc(s, snr_offset + snr_incr) <= bits_left) {
  819. snr_offset += snr_incr;
  820. FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
  821. }
  822. }
  823. FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
  824. reset_block_bap(s);
  825. s->coarse_snr_offset = snr_offset >> 4;
  826. for (ch = 0; ch < s->channels; ch++)
  827. s->fine_snr_offset[ch] = snr_offset & 0xF;
  828. return 0;
  829. }
  830. /**
  831. * Downgrade exponent strategies to reduce the bits used by the exponents.
  832. * This is a fallback for when bit allocation fails with the normal exponent
  833. * strategies. Each time this function is run it only downgrades the
  834. * strategy in 1 channel of 1 block.
  835. * @return non-zero if downgrade was unsuccessful
  836. */
  837. static int downgrade_exponents(AC3EncodeContext *s)
  838. {
  839. int ch, blk;
  840. for (ch = 0; ch < s->fbw_channels; ch++) {
  841. for (blk = AC3_MAX_BLOCKS-1; blk >= 0; blk--) {
  842. if (s->exp_strategy[ch][blk] == EXP_D15) {
  843. s->exp_strategy[ch][blk] = EXP_D25;
  844. return 0;
  845. }
  846. }
  847. }
  848. for (ch = 0; ch < s->fbw_channels; ch++) {
  849. for (blk = AC3_MAX_BLOCKS-1; blk >= 0; blk--) {
  850. if (s->exp_strategy[ch][blk] == EXP_D25) {
  851. s->exp_strategy[ch][blk] = EXP_D45;
  852. return 0;
  853. }
  854. }
  855. }
  856. for (ch = 0; ch < s->fbw_channels; ch++) {
  857. /* block 0 cannot reuse exponents, so only downgrade D45 to REUSE if
  858. the block number > 0 */
  859. for (blk = AC3_MAX_BLOCKS-1; blk > 0; blk--) {
  860. if (s->exp_strategy[ch][blk] > EXP_REUSE) {
  861. s->exp_strategy[ch][blk] = EXP_REUSE;
  862. return 0;
  863. }
  864. }
  865. }
  866. return -1;
  867. }
  868. /**
  869. * Reduce the bandwidth to reduce the number of bits used for a given SNR offset.
  870. * This is a second fallback for when bit allocation still fails after exponents
  871. * have been downgraded.
  872. * @return non-zero if bandwidth reduction was unsuccessful
  873. */
  874. static int reduce_bandwidth(AC3EncodeContext *s, int min_bw_code)
  875. {
  876. int ch;
  877. if (s->bandwidth_code[0] > min_bw_code) {
  878. for (ch = 0; ch < s->fbw_channels; ch++) {
  879. s->bandwidth_code[ch]--;
  880. s->nb_coefs[ch] = s->bandwidth_code[ch] * 3 + 73;
  881. }
  882. return 0;
  883. }
  884. return -1;
  885. }
  886. /**
  887. * Perform bit allocation search.
  888. * Finds the SNR offset value that maximizes quality and fits in the specified
  889. * frame size. Output is the SNR offset and a set of bit allocation pointers
  890. * used to quantize the mantissas.
  891. */
  892. static int compute_bit_allocation(AC3EncodeContext *s)
  893. {
  894. int ret;
  895. count_frame_bits(s);
  896. bit_alloc_masking(s);
  897. ret = cbr_bit_allocation(s);
  898. while (ret) {
  899. /* fallback 1: downgrade exponents */
  900. if (!downgrade_exponents(s)) {
  901. extract_exponents(s);
  902. encode_exponents(s);
  903. group_exponents(s);
  904. ret = compute_bit_allocation(s);
  905. continue;
  906. }
  907. /* fallback 2: reduce bandwidth */
  908. /* only do this if the user has not specified a specific cutoff
  909. frequency */
  910. if (!s->cutoff && !reduce_bandwidth(s, 0)) {
  911. process_exponents(s);
  912. ret = compute_bit_allocation(s);
  913. continue;
  914. }
  915. /* fallbacks were not enough... */
  916. break;
  917. }
  918. return ret;
  919. }
  920. /**
  921. * Symmetric quantization on 'levels' levels.
  922. */
  923. static inline int sym_quant(int c, int e, int levels)
  924. {
  925. int v;
  926. if (c >= 0) {
  927. v = (levels * (c << e)) >> 24;
  928. v = (v + 1) >> 1;
  929. v = (levels >> 1) + v;
  930. } else {
  931. v = (levels * ((-c) << e)) >> 24;
  932. v = (v + 1) >> 1;
  933. v = (levels >> 1) - v;
  934. }
  935. assert(v >= 0 && v < levels);
  936. return v;
  937. }
  938. /**
  939. * Asymmetric quantization on 2^qbits levels.
  940. */
  941. static inline int asym_quant(int c, int e, int qbits)
  942. {
  943. int lshift, m, v;
  944. lshift = e + qbits - 24;
  945. if (lshift >= 0)
  946. v = c << lshift;
  947. else
  948. v = c >> (-lshift);
  949. /* rounding */
  950. v = (v + 1) >> 1;
  951. m = (1 << (qbits-1));
  952. if (v >= m)
  953. v = m - 1;
  954. assert(v >= -m);
  955. return v & ((1 << qbits)-1);
  956. }
  957. /**
  958. * Quantize a set of mantissas for a single channel in a single block.
  959. */
  960. static void quantize_mantissas_blk_ch(AC3EncodeContext *s, int32_t *fixed_coef,
  961. int8_t exp_shift, uint8_t *exp,
  962. uint8_t *bap, uint16_t *qmant, int n)
  963. {
  964. int i;
  965. for (i = 0; i < n; i++) {
  966. int v;
  967. int c = fixed_coef[i];
  968. int e = exp[i] - exp_shift;
  969. int b = bap[i];
  970. switch (b) {
  971. case 0:
  972. v = 0;
  973. break;
  974. case 1:
  975. v = sym_quant(c, e, 3);
  976. switch (s->mant1_cnt) {
  977. case 0:
  978. s->qmant1_ptr = &qmant[i];
  979. v = 9 * v;
  980. s->mant1_cnt = 1;
  981. break;
  982. case 1:
  983. *s->qmant1_ptr += 3 * v;
  984. s->mant1_cnt = 2;
  985. v = 128;
  986. break;
  987. default:
  988. *s->qmant1_ptr += v;
  989. s->mant1_cnt = 0;
  990. v = 128;
  991. break;
  992. }
  993. break;
  994. case 2:
  995. v = sym_quant(c, e, 5);
  996. switch (s->mant2_cnt) {
  997. case 0:
  998. s->qmant2_ptr = &qmant[i];
  999. v = 25 * v;
  1000. s->mant2_cnt = 1;
  1001. break;
  1002. case 1:
  1003. *s->qmant2_ptr += 5 * v;
  1004. s->mant2_cnt = 2;
  1005. v = 128;
  1006. break;
  1007. default:
  1008. *s->qmant2_ptr += v;
  1009. s->mant2_cnt = 0;
  1010. v = 128;
  1011. break;
  1012. }
  1013. break;
  1014. case 3:
  1015. v = sym_quant(c, e, 7);
  1016. break;
  1017. case 4:
  1018. v = sym_quant(c, e, 11);
  1019. switch (s->mant4_cnt) {
  1020. case 0:
  1021. s->qmant4_ptr = &qmant[i];
  1022. v = 11 * v;
  1023. s->mant4_cnt = 1;
  1024. break;
  1025. default:
  1026. *s->qmant4_ptr += v;
  1027. s->mant4_cnt = 0;
  1028. v = 128;
  1029. break;
  1030. }
  1031. break;
  1032. case 5:
  1033. v = sym_quant(c, e, 15);
  1034. break;
  1035. case 14:
  1036. v = asym_quant(c, e, 14);
  1037. break;
  1038. case 15:
  1039. v = asym_quant(c, e, 16);
  1040. break;
  1041. default:
  1042. v = asym_quant(c, e, b - 1);
  1043. break;
  1044. }
  1045. qmant[i] = v;
  1046. }
  1047. }
  1048. /**
  1049. * Quantize mantissas using coefficients, exponents, and bit allocation pointers.
  1050. */
  1051. static void quantize_mantissas(AC3EncodeContext *s)
  1052. {
  1053. int blk, ch;
  1054. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  1055. AC3Block *block = &s->blocks[blk];
  1056. s->mant1_cnt = s->mant2_cnt = s->mant4_cnt = 0;
  1057. s->qmant1_ptr = s->qmant2_ptr = s->qmant4_ptr = NULL;
  1058. for (ch = 0; ch < s->channels; ch++) {
  1059. quantize_mantissas_blk_ch(s, block->fixed_coef[ch], block->exp_shift[ch],
  1060. block->exp[ch], block->bap[ch],
  1061. block->qmant[ch], s->nb_coefs[ch]);
  1062. }
  1063. }
  1064. }
  1065. /**
  1066. * Write the AC-3 frame header to the output bitstream.
  1067. */
  1068. static void output_frame_header(AC3EncodeContext *s)
  1069. {
  1070. put_bits(&s->pb, 16, 0x0b77); /* frame header */
  1071. put_bits(&s->pb, 16, 0); /* crc1: will be filled later */
  1072. put_bits(&s->pb, 2, s->bit_alloc.sr_code);
  1073. put_bits(&s->pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min) / 2);
  1074. put_bits(&s->pb, 5, s->bitstream_id);
  1075. put_bits(&s->pb, 3, s->bitstream_mode);
  1076. put_bits(&s->pb, 3, s->channel_mode);
  1077. if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO)
  1078. put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */
  1079. if (s->channel_mode & 0x04)
  1080. put_bits(&s->pb, 2, 1); /* XXX -6 dB */
  1081. if (s->channel_mode == AC3_CHMODE_STEREO)
  1082. put_bits(&s->pb, 2, 0); /* surround not indicated */
  1083. put_bits(&s->pb, 1, s->lfe_on); /* LFE */
  1084. put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */
  1085. put_bits(&s->pb, 1, 0); /* no compression control word */
  1086. put_bits(&s->pb, 1, 0); /* no lang code */
  1087. put_bits(&s->pb, 1, 0); /* no audio production info */
  1088. put_bits(&s->pb, 1, 0); /* no copyright */
  1089. put_bits(&s->pb, 1, 1); /* original bitstream */
  1090. put_bits(&s->pb, 1, 0); /* no time code 1 */
  1091. put_bits(&s->pb, 1, 0); /* no time code 2 */
  1092. put_bits(&s->pb, 1, 0); /* no additional bit stream info */
  1093. }
  1094. /**
  1095. * Write one audio block to the output bitstream.
  1096. */
  1097. static void output_audio_block(AC3EncodeContext *s, int blk)
  1098. {
  1099. int ch, i, baie, rbnd;
  1100. AC3Block *block = &s->blocks[blk];
  1101. /* block switching */
  1102. for (ch = 0; ch < s->fbw_channels; ch++)
  1103. put_bits(&s->pb, 1, 0);
  1104. /* dither flags */
  1105. for (ch = 0; ch < s->fbw_channels; ch++)
  1106. put_bits(&s->pb, 1, 1);
  1107. /* dynamic range codes */
  1108. put_bits(&s->pb, 1, 0);
  1109. /* channel coupling */
  1110. if (!blk) {
  1111. put_bits(&s->pb, 1, 1); /* coupling strategy present */
  1112. put_bits(&s->pb, 1, 0); /* no coupling strategy */
  1113. } else {
  1114. put_bits(&s->pb, 1, 0); /* no new coupling strategy */
  1115. }
  1116. /* stereo rematrixing */
  1117. if (s->channel_mode == AC3_CHMODE_STEREO) {
  1118. put_bits(&s->pb, 1, block->new_rematrixing_strategy);
  1119. if (block->new_rematrixing_strategy) {
  1120. /* rematrixing flags */
  1121. for (rbnd = 0; rbnd < s->num_rematrixing_bands; rbnd++)
  1122. put_bits(&s->pb, 1, block->rematrixing_flags[rbnd]);
  1123. }
  1124. }
  1125. /* exponent strategy */
  1126. for (ch = 0; ch < s->fbw_channels; ch++)
  1127. put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
  1128. if (s->lfe_on)
  1129. put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
  1130. /* bandwidth */
  1131. for (ch = 0; ch < s->fbw_channels; ch++) {
  1132. if (s->exp_strategy[ch][blk] != EXP_REUSE)
  1133. put_bits(&s->pb, 6, s->bandwidth_code[ch]);
  1134. }
  1135. /* exponents */
  1136. for (ch = 0; ch < s->channels; ch++) {
  1137. int nb_groups;
  1138. if (s->exp_strategy[ch][blk] == EXP_REUSE)
  1139. continue;
  1140. /* DC exponent */
  1141. put_bits(&s->pb, 4, block->grouped_exp[ch][0]);
  1142. /* exponent groups */
  1143. nb_groups = exponent_group_tab[s->exp_strategy[ch][blk]-1][s->nb_coefs[ch]];
  1144. for (i = 1; i <= nb_groups; i++)
  1145. put_bits(&s->pb, 7, block->grouped_exp[ch][i]);
  1146. /* gain range info */
  1147. if (ch != s->lfe_channel)
  1148. put_bits(&s->pb, 2, 0);
  1149. }
  1150. /* bit allocation info */
  1151. baie = (blk == 0);
  1152. put_bits(&s->pb, 1, baie);
  1153. if (baie) {
  1154. put_bits(&s->pb, 2, s->slow_decay_code);
  1155. put_bits(&s->pb, 2, s->fast_decay_code);
  1156. put_bits(&s->pb, 2, s->slow_gain_code);
  1157. put_bits(&s->pb, 2, s->db_per_bit_code);
  1158. put_bits(&s->pb, 3, s->floor_code);
  1159. }
  1160. /* snr offset */
  1161. put_bits(&s->pb, 1, baie);
  1162. if (baie) {
  1163. put_bits(&s->pb, 6, s->coarse_snr_offset);
  1164. for (ch = 0; ch < s->channels; ch++) {
  1165. put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
  1166. put_bits(&s->pb, 3, s->fast_gain_code[ch]);
  1167. }
  1168. }
  1169. put_bits(&s->pb, 1, 0); /* no delta bit allocation */
  1170. put_bits(&s->pb, 1, 0); /* no data to skip */
  1171. /* mantissas */
  1172. for (ch = 0; ch < s->channels; ch++) {
  1173. int b, q;
  1174. for (i = 0; i < s->nb_coefs[ch]; i++) {
  1175. q = block->qmant[ch][i];
  1176. b = block->bap[ch][i];
  1177. switch (b) {
  1178. case 0: break;
  1179. case 1: if (q != 128) put_bits(&s->pb, 5, q); break;
  1180. case 2: if (q != 128) put_bits(&s->pb, 7, q); break;
  1181. case 3: put_bits(&s->pb, 3, q); break;
  1182. case 4: if (q != 128) put_bits(&s->pb, 7, q); break;
  1183. case 14: put_bits(&s->pb, 14, q); break;
  1184. case 15: put_bits(&s->pb, 16, q); break;
  1185. default: put_bits(&s->pb, b-1, q); break;
  1186. }
  1187. }
  1188. }
  1189. }
  1190. /** CRC-16 Polynomial */
  1191. #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))
  1192. static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
  1193. {
  1194. unsigned int c;
  1195. c = 0;
  1196. while (a) {
  1197. if (a & 1)
  1198. c ^= b;
  1199. a = a >> 1;
  1200. b = b << 1;
  1201. if (b & (1 << 16))
  1202. b ^= poly;
  1203. }
  1204. return c;
  1205. }
  1206. static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
  1207. {
  1208. unsigned int r;
  1209. r = 1;
  1210. while (n) {
  1211. if (n & 1)
  1212. r = mul_poly(r, a, poly);
  1213. a = mul_poly(a, a, poly);
  1214. n >>= 1;
  1215. }
  1216. return r;
  1217. }
  1218. /**
  1219. * Fill the end of the frame with 0's and compute the two CRCs.
  1220. */
  1221. static void output_frame_end(AC3EncodeContext *s)
  1222. {
  1223. const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI);
  1224. int frame_size_58, pad_bytes, crc1, crc2_partial, crc2, crc_inv;
  1225. uint8_t *frame;
  1226. frame_size_58 = ((s->frame_size >> 2) + (s->frame_size >> 4)) << 1;
  1227. /* pad the remainder of the frame with zeros */
  1228. flush_put_bits(&s->pb);
  1229. frame = s->pb.buf;
  1230. pad_bytes = s->frame_size - (put_bits_ptr(&s->pb) - frame) - 2;
  1231. assert(pad_bytes >= 0);
  1232. if (pad_bytes > 0)
  1233. memset(put_bits_ptr(&s->pb), 0, pad_bytes);
  1234. /* compute crc1 */
  1235. /* this is not so easy because it is at the beginning of the data... */
  1236. crc1 = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58 - 4));
  1237. crc_inv = s->crc_inv[s->frame_size > s->frame_size_min];
  1238. crc1 = mul_poly(crc_inv, crc1, CRC16_POLY);
  1239. AV_WB16(frame + 2, crc1);
  1240. /* compute crc2 */
  1241. crc2_partial = av_crc(crc_ctx, 0, frame + frame_size_58,
  1242. s->frame_size - frame_size_58 - 3);
  1243. crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
  1244. /* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
  1245. if (crc2 == 0x770B) {
  1246. frame[s->frame_size - 3] ^= 0x1;
  1247. crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
  1248. }
  1249. crc2 = av_bswap16(crc2);
  1250. AV_WB16(frame + s->frame_size - 2, crc2);
  1251. }
  1252. /**
  1253. * Write the frame to the output bitstream.
  1254. */
  1255. static void output_frame(AC3EncodeContext *s, unsigned char *frame)
  1256. {
  1257. int blk;
  1258. init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);
  1259. output_frame_header(s);
  1260. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
  1261. output_audio_block(s, blk);
  1262. output_frame_end(s);
  1263. }
  1264. /**
  1265. * Encode a single AC-3 frame.
  1266. */
  1267. static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame,
  1268. int buf_size, void *data)
  1269. {
  1270. AC3EncodeContext *s = avctx->priv_data;
  1271. const SampleType *samples = data;
  1272. int ret;
  1273. if (s->bit_alloc.sr_code == 1)
  1274. adjust_frame_size(s);
  1275. deinterleave_input_samples(s, samples);
  1276. apply_mdct(s);
  1277. compute_rematrixing_strategy(s);
  1278. scale_coefficients(s);
  1279. apply_rematrixing(s);
  1280. process_exponents(s);
  1281. ret = compute_bit_allocation(s);
  1282. if (ret) {
  1283. av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
  1284. return ret;
  1285. }
  1286. quantize_mantissas(s);
  1287. output_frame(s, frame);
  1288. return s->frame_size;
  1289. }
  1290. /**
  1291. * Finalize encoding and free any memory allocated by the encoder.
  1292. */
  1293. static av_cold int ac3_encode_close(AVCodecContext *avctx)
  1294. {
  1295. int blk, ch;
  1296. AC3EncodeContext *s = avctx->priv_data;
  1297. for (ch = 0; ch < s->channels; ch++)
  1298. av_freep(&s->planar_samples[ch]);
  1299. av_freep(&s->planar_samples);
  1300. av_freep(&s->bap_buffer);
  1301. av_freep(&s->bap1_buffer);
  1302. av_freep(&s->mdct_coef_buffer);
  1303. av_freep(&s->fixed_coef_buffer);
  1304. av_freep(&s->exp_buffer);
  1305. av_freep(&s->grouped_exp_buffer);
  1306. av_freep(&s->psd_buffer);
  1307. av_freep(&s->band_psd_buffer);
  1308. av_freep(&s->mask_buffer);
  1309. av_freep(&s->qmant_buffer);
  1310. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  1311. AC3Block *block = &s->blocks[blk];
  1312. av_freep(&block->bap);
  1313. av_freep(&block->mdct_coef);
  1314. av_freep(&block->fixed_coef);
  1315. av_freep(&block->exp);
  1316. av_freep(&block->grouped_exp);
  1317. av_freep(&block->psd);
  1318. av_freep(&block->band_psd);
  1319. av_freep(&block->mask);
  1320. av_freep(&block->qmant);
  1321. }
  1322. mdct_end(&s->mdct);
  1323. av_freep(&avctx->coded_frame);
  1324. return 0;
  1325. }
  1326. /**
  1327. * Set channel information during initialization.
  1328. */
  1329. static av_cold int set_channel_info(AC3EncodeContext *s, int channels,
  1330. int64_t *channel_layout)
  1331. {
  1332. int ch_layout;
  1333. if (channels < 1 || channels > AC3_MAX_CHANNELS)
  1334. return AVERROR(EINVAL);
  1335. if ((uint64_t)*channel_layout > 0x7FF)
  1336. return AVERROR(EINVAL);
  1337. ch_layout = *channel_layout;
  1338. if (!ch_layout)
  1339. ch_layout = avcodec_guess_channel_layout(channels, CODEC_ID_AC3, NULL);
  1340. if (av_get_channel_layout_nb_channels(ch_layout) != channels)
  1341. return AVERROR(EINVAL);
  1342. s->lfe_on = !!(ch_layout & AV_CH_LOW_FREQUENCY);
  1343. s->channels = channels;
  1344. s->fbw_channels = channels - s->lfe_on;
  1345. s->lfe_channel = s->lfe_on ? s->fbw_channels : -1;
  1346. if (s->lfe_on)
  1347. ch_layout -= AV_CH_LOW_FREQUENCY;
  1348. switch (ch_layout) {
  1349. case AV_CH_LAYOUT_MONO: s->channel_mode = AC3_CHMODE_MONO; break;
  1350. case AV_CH_LAYOUT_STEREO: s->channel_mode = AC3_CHMODE_STEREO; break;
  1351. case AV_CH_LAYOUT_SURROUND: s->channel_mode = AC3_CHMODE_3F; break;
  1352. case AV_CH_LAYOUT_2_1: s->channel_mode = AC3_CHMODE_2F1R; break;
  1353. case AV_CH_LAYOUT_4POINT0: s->channel_mode = AC3_CHMODE_3F1R; break;
  1354. case AV_CH_LAYOUT_QUAD:
  1355. case AV_CH_LAYOUT_2_2: s->channel_mode = AC3_CHMODE_2F2R; break;
  1356. case AV_CH_LAYOUT_5POINT0:
  1357. case AV_CH_LAYOUT_5POINT0_BACK: s->channel_mode = AC3_CHMODE_3F2R; break;
  1358. default:
  1359. return AVERROR(EINVAL);
  1360. }
  1361. s->channel_map = ff_ac3_enc_channel_map[s->channel_mode][s->lfe_on];
  1362. *channel_layout = ch_layout;
  1363. if (s->lfe_on)
  1364. *channel_layout |= AV_CH_LOW_FREQUENCY;
  1365. return 0;
  1366. }
  1367. static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s)
  1368. {
  1369. int i, ret;
  1370. /* validate channel layout */
  1371. if (!avctx->channel_layout) {
  1372. av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
  1373. "encoder will guess the layout, but it "
  1374. "might be incorrect.\n");
  1375. }
  1376. ret = set_channel_info(s, avctx->channels, &avctx->channel_layout);
  1377. if (ret) {
  1378. av_log(avctx, AV_LOG_ERROR, "invalid channel layout\n");
  1379. return ret;
  1380. }
  1381. /* validate sample rate */
  1382. for (i = 0; i < 9; i++) {
  1383. if ((ff_ac3_sample_rate_tab[i / 3] >> (i % 3)) == avctx->sample_rate)
  1384. break;
  1385. }
  1386. if (i == 9) {
  1387. av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
  1388. return AVERROR(EINVAL);
  1389. }
  1390. s->sample_rate = avctx->sample_rate;
  1391. s->bit_alloc.sr_shift = i % 3;
  1392. s->bit_alloc.sr_code = i / 3;
  1393. /* validate bit rate */
  1394. for (i = 0; i < 19; i++) {
  1395. if ((ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift)*1000 == avctx->bit_rate)
  1396. break;
  1397. }
  1398. if (i == 19) {
  1399. av_log(avctx, AV_LOG_ERROR, "invalid bit rate\n");
  1400. return AVERROR(EINVAL);
  1401. }
  1402. s->bit_rate = avctx->bit_rate;
  1403. s->frame_size_code = i << 1;
  1404. /* validate cutoff */
  1405. if (avctx->cutoff < 0) {
  1406. av_log(avctx, AV_LOG_ERROR, "invalid cutoff frequency\n");
  1407. return AVERROR(EINVAL);
  1408. }
  1409. s->cutoff = avctx->cutoff;
  1410. if (s->cutoff > (s->sample_rate >> 1))
  1411. s->cutoff = s->sample_rate >> 1;
  1412. return 0;
  1413. }
  1414. /**
  1415. * Set bandwidth for all channels.
  1416. * The user can optionally supply a cutoff frequency. Otherwise an appropriate
  1417. * default value will be used.
  1418. */
  1419. static av_cold void set_bandwidth(AC3EncodeContext *s)
  1420. {
  1421. int ch, bw_code;
  1422. if (s->cutoff) {
  1423. /* calculate bandwidth based on user-specified cutoff frequency */
  1424. int fbw_coeffs;
  1425. fbw_coeffs = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
  1426. bw_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
  1427. } else {
  1428. /* use default bandwidth setting */
  1429. /* XXX: should compute the bandwidth according to the frame
  1430. size, so that we avoid annoying high frequency artifacts */
  1431. bw_code = 50;
  1432. }
  1433. /* set number of coefficients for each channel */
  1434. for (ch = 0; ch < s->fbw_channels; ch++) {
  1435. s->bandwidth_code[ch] = bw_code;
  1436. s->nb_coefs[ch] = bw_code * 3 + 73;
  1437. }
  1438. if (s->lfe_on)
  1439. s->nb_coefs[s->lfe_channel] = 7; /* LFE channel always has 7 coefs */
  1440. }
  1441. static av_cold int allocate_buffers(AVCodecContext *avctx)
  1442. {
  1443. int blk, ch;
  1444. AC3EncodeContext *s = avctx->priv_data;
  1445. FF_ALLOC_OR_GOTO(avctx, s->planar_samples, s->channels * sizeof(*s->planar_samples),
  1446. alloc_fail);
  1447. for (ch = 0; ch < s->channels; ch++) {
  1448. FF_ALLOCZ_OR_GOTO(avctx, s->planar_samples[ch],
  1449. (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples),
  1450. alloc_fail);
  1451. }
  1452. FF_ALLOC_OR_GOTO(avctx, s->bap_buffer, AC3_MAX_BLOCKS * s->channels *
  1453. AC3_MAX_COEFS * sizeof(*s->bap_buffer), alloc_fail);
  1454. FF_ALLOC_OR_GOTO(avctx, s->bap1_buffer, AC3_MAX_BLOCKS * s->channels *
  1455. AC3_MAX_COEFS * sizeof(*s->bap1_buffer), alloc_fail);
  1456. FF_ALLOC_OR_GOTO(avctx, s->mdct_coef_buffer, AC3_MAX_BLOCKS * s->channels *
  1457. AC3_MAX_COEFS * sizeof(*s->mdct_coef_buffer), alloc_fail);
  1458. FF_ALLOC_OR_GOTO(avctx, s->exp_buffer, AC3_MAX_BLOCKS * s->channels *
  1459. AC3_MAX_COEFS * sizeof(*s->exp_buffer), alloc_fail);
  1460. FF_ALLOC_OR_GOTO(avctx, s->grouped_exp_buffer, AC3_MAX_BLOCKS * s->channels *
  1461. 128 * sizeof(*s->grouped_exp_buffer), alloc_fail);
  1462. FF_ALLOC_OR_GOTO(avctx, s->psd_buffer, AC3_MAX_BLOCKS * s->channels *
  1463. AC3_MAX_COEFS * sizeof(*s->psd_buffer), alloc_fail);
  1464. FF_ALLOC_OR_GOTO(avctx, s->band_psd_buffer, AC3_MAX_BLOCKS * s->channels *
  1465. 64 * sizeof(*s->band_psd_buffer), alloc_fail);
  1466. FF_ALLOC_OR_GOTO(avctx, s->mask_buffer, AC3_MAX_BLOCKS * s->channels *
  1467. 64 * sizeof(*s->mask_buffer), alloc_fail);
  1468. FF_ALLOC_OR_GOTO(avctx, s->qmant_buffer, AC3_MAX_BLOCKS * s->channels *
  1469. AC3_MAX_COEFS * sizeof(*s->qmant_buffer), alloc_fail);
  1470. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  1471. AC3Block *block = &s->blocks[blk];
  1472. FF_ALLOC_OR_GOTO(avctx, block->bap, s->channels * sizeof(*block->bap),
  1473. alloc_fail);
  1474. FF_ALLOCZ_OR_GOTO(avctx, block->mdct_coef, s->channels * sizeof(*block->mdct_coef),
  1475. alloc_fail);
  1476. FF_ALLOCZ_OR_GOTO(avctx, block->exp, s->channels * sizeof(*block->exp),
  1477. alloc_fail);
  1478. FF_ALLOCZ_OR_GOTO(avctx, block->grouped_exp, s->channels * sizeof(*block->grouped_exp),
  1479. alloc_fail);
  1480. FF_ALLOCZ_OR_GOTO(avctx, block->psd, s->channels * sizeof(*block->psd),
  1481. alloc_fail);
  1482. FF_ALLOCZ_OR_GOTO(avctx, block->band_psd, s->channels * sizeof(*block->band_psd),
  1483. alloc_fail);
  1484. FF_ALLOCZ_OR_GOTO(avctx, block->mask, s->channels * sizeof(*block->mask),
  1485. alloc_fail);
  1486. FF_ALLOCZ_OR_GOTO(avctx, block->qmant, s->channels * sizeof(*block->qmant),
  1487. alloc_fail);
  1488. for (ch = 0; ch < s->channels; ch++) {
  1489. /* arrangement: block, channel, coeff */
  1490. block->bap[ch] = &s->bap_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)];
  1491. block->mdct_coef[ch] = &s->mdct_coef_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)];
  1492. block->grouped_exp[ch] = &s->grouped_exp_buffer[128 * (blk * s->channels + ch)];
  1493. block->psd[ch] = &s->psd_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)];
  1494. block->band_psd[ch] = &s->band_psd_buffer [64 * (blk * s->channels + ch)];
  1495. block->mask[ch] = &s->mask_buffer [64 * (blk * s->channels + ch)];
  1496. block->qmant[ch] = &s->qmant_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)];
  1497. /* arrangement: channel, block, coeff */
  1498. block->exp[ch] = &s->exp_buffer [AC3_MAX_COEFS * (AC3_MAX_BLOCKS * ch + blk)];
  1499. }
  1500. }
  1501. if (CONFIG_AC3ENC_FLOAT) {
  1502. FF_ALLOC_OR_GOTO(avctx, s->fixed_coef_buffer, AC3_MAX_BLOCKS * s->channels *
  1503. AC3_MAX_COEFS * sizeof(*s->fixed_coef_buffer), alloc_fail);
  1504. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  1505. AC3Block *block = &s->blocks[blk];
  1506. FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, s->channels *
  1507. sizeof(*block->fixed_coef), alloc_fail);
  1508. for (ch = 0; ch < s->channels; ch++)
  1509. block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (blk * s->channels + ch)];
  1510. }
  1511. } else {
  1512. for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
  1513. AC3Block *block = &s->blocks[blk];
  1514. FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, s->channels *
  1515. sizeof(*block->fixed_coef), alloc_fail);
  1516. for (ch = 0; ch < s->channels; ch++)
  1517. block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch];
  1518. }
  1519. }
  1520. return 0;
  1521. alloc_fail:
  1522. return AVERROR(ENOMEM);
  1523. }
  1524. /**
  1525. * Initialize the encoder.
  1526. */
  1527. static av_cold int ac3_encode_init(AVCodecContext *avctx)
  1528. {
  1529. AC3EncodeContext *s = avctx->priv_data;
  1530. int ret, frame_size_58;
  1531. avctx->frame_size = AC3_FRAME_SIZE;
  1532. ff_ac3_common_init();
  1533. ret = validate_options(avctx, s);
  1534. if (ret)
  1535. return ret;
  1536. s->bitstream_id = 8 + s->bit_alloc.sr_shift;
  1537. s->bitstream_mode = 0; /* complete main audio service */
  1538. s->frame_size_min = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
  1539. s->bits_written = 0;
  1540. s->samples_written = 0;
  1541. s->frame_size = s->frame_size_min;
  1542. /* calculate crc_inv for both possible frame sizes */
  1543. frame_size_58 = (( s->frame_size >> 2) + ( s->frame_size >> 4)) << 1;
  1544. s->crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
  1545. if (s->bit_alloc.sr_code == 1) {
  1546. frame_size_58 = (((s->frame_size+2) >> 2) + ((s->frame_size+2) >> 4)) << 1;
  1547. s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
  1548. }
  1549. set_bandwidth(s);
  1550. rematrixing_init(s);
  1551. exponent_init(s);
  1552. bit_alloc_init(s);
  1553. ret = mdct_init(avctx, &s->mdct, 9);
  1554. if (ret)
  1555. goto init_fail;
  1556. ret = allocate_buffers(avctx);
  1557. if (ret)
  1558. goto init_fail;
  1559. avctx->coded_frame= avcodec_alloc_frame();
  1560. dsputil_init(&s->dsp, avctx);
  1561. ff_ac3dsp_init(&s->ac3dsp);
  1562. return 0;
  1563. init_fail:
  1564. ac3_encode_close(avctx);
  1565. return ret;
  1566. }