ac3enc.c
Go to the documentation of this file.
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 /**
25  * @file
26  * The simplest AC-3 encoder.
27  */
28 
29 //#define ASSERT_LEVEL 2
30 
31 #include <stdint.h>
32 
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
36 #include "libavutil/crc.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/opt.h"
39 #include "avcodec.h"
40 #include "put_bits.h"
41 #include "ac3dsp.h"
42 #include "ac3.h"
43 #include "fft.h"
44 #include "ac3enc.h"
45 #include "eac3enc.h"
46 
47 typedef struct AC3Mant {
48  int16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
49  int mant1_cnt, mant2_cnt, mant4_cnt; ///< mantissa counts for bap=1,2,4
50 } AC3Mant;
51 
52 #define CMIXLEV_NUM_OPTIONS 3
53 static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = {
55 };
56 
57 #define SURMIXLEV_NUM_OPTIONS 3
60 };
61 
62 #define EXTMIXLEV_NUM_OPTIONS 8
66 };
67 
68 
69 /**
70  * LUT for number of exponent groups.
71  * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
72  */
73 static uint8_t exponent_group_tab[2][3][256];
74 
75 
76 /**
77  * List of supported channel layouts.
78  */
79 const uint64_t ff_ac3_channel_layouts[19] = {
90  (AV_CH_LAYOUT_STEREO | AV_CH_LOW_FREQUENCY),
91  (AV_CH_LAYOUT_2_1 | AV_CH_LOW_FREQUENCY),
92  (AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY),
93  (AV_CH_LAYOUT_2_2 | AV_CH_LOW_FREQUENCY),
94  (AV_CH_LAYOUT_QUAD | AV_CH_LOW_FREQUENCY),
95  (AV_CH_LAYOUT_4POINT0 | AV_CH_LOW_FREQUENCY),
98  0
99 };
100 
101 
102 /**
103  * LUT to select the bandwidth code based on the bit rate, sample rate, and
104  * number of full-bandwidth channels.
105  * bandwidth_tab[fbw_channels-1][sample rate code][bit rate code]
106  */
107 static const uint8_t ac3_bandwidth_tab[5][3][19] = {
108 // 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
109 
110  { { 0, 0, 0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
111  { 0, 0, 0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
112  { 0, 0, 0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
113 
114  { { 0, 0, 0, 0, 0, 0, 0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
115  { 0, 0, 0, 0, 0, 0, 4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
116  { 0, 0, 0, 0, 0, 0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
117 
118  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 },
119  { 0, 0, 0, 0, 0, 0, 0, 0, 4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 },
120  { 0, 0, 0, 0, 0, 0, 0, 0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } },
121 
122  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 32, 48, 48, 48, 48, 48, 48 },
123  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 28, 36, 56, 56, 56, 56, 56, 56 },
124  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } },
125 
126  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 20, 32, 40, 48, 48, 48, 48 },
127  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 36, 44, 56, 56, 56, 56 },
128  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 44, 60, 60, 60, 60, 60, 60 } }
129 };
130 
131 
132 /**
133  * LUT to select the coupling start band based on the bit rate, sample rate, and
134  * number of full-bandwidth channels. -1 = coupling off
135  * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]
136  *
137  * TODO: more testing for optimal parameters.
138  * multi-channel tests at 44.1kHz and 32kHz.
139  */
140 static const int8_t ac3_coupling_start_tab[6][3][19] = {
141 // 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
142 
143  // 2/0
144  { { 0, 0, 0, 0, 0, 0, 0, 1, 1, 7, 8, 11, 12, -1, -1, -1, -1, -1, -1 },
145  { 0, 0, 0, 0, 0, 0, 1, 3, 5, 7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },
146  { 0, 0, 0, 0, 1, 2, 2, 9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
147 
148  // 3/0
149  { { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
150  { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
151  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
152 
153  // 2/1 - untested
154  { { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
155  { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
156  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
157 
158  // 3/1
159  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
160  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
161  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
162 
163  // 2/2 - untested
164  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
165  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
166  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
167 
168  // 3/2
169  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
170  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
171  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
172 };
173 
174 
175 /**
176  * Adjust the frame size to make the average bit rate match the target bit rate.
177  * This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3.
178  *
179  * @param s AC-3 encoder private context
180  */
182 {
183  while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
184  s->bits_written -= s->bit_rate;
185  s->samples_written -= s->sample_rate;
186  }
187  s->frame_size = s->frame_size_min +
188  2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
189  s->bits_written += s->frame_size * 8;
191 }
192 
193 
194 /**
195  * Set the initial coupling strategy parameters prior to coupling analysis.
196  *
197  * @param s AC-3 encoder private context
198  */
200 {
201  int blk, ch;
202  int got_cpl_snr;
203  int num_cpl_blocks;
204 
205  /* set coupling use flags for each block/channel */
206  /* TODO: turn coupling on/off and adjust start band based on bit usage */
207  for (blk = 0; blk < s->num_blocks; blk++) {
208  AC3Block *block = &s->blocks[blk];
209  for (ch = 1; ch <= s->fbw_channels; ch++)
210  block->channel_in_cpl[ch] = s->cpl_on;
211  }
212 
213  /* enable coupling for each block if at least 2 channels have coupling
214  enabled for that block */
215  got_cpl_snr = 0;
216  num_cpl_blocks = 0;
217  for (blk = 0; blk < s->num_blocks; blk++) {
218  AC3Block *block = &s->blocks[blk];
219  block->num_cpl_channels = 0;
220  for (ch = 1; ch <= s->fbw_channels; ch++)
221  block->num_cpl_channels += block->channel_in_cpl[ch];
222  block->cpl_in_use = block->num_cpl_channels > 1;
223  num_cpl_blocks += block->cpl_in_use;
224  if (!block->cpl_in_use) {
225  block->num_cpl_channels = 0;
226  for (ch = 1; ch <= s->fbw_channels; ch++)
227  block->channel_in_cpl[ch] = 0;
228  }
229 
230  block->new_cpl_strategy = !blk;
231  if (blk) {
232  for (ch = 1; ch <= s->fbw_channels; ch++) {
233  if (block->channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
234  block->new_cpl_strategy = 1;
235  break;
236  }
237  }
238  }
239  block->new_cpl_leak = block->new_cpl_strategy;
240 
241  if (!blk || (block->cpl_in_use && !got_cpl_snr)) {
242  block->new_snr_offsets = 1;
243  if (block->cpl_in_use)
244  got_cpl_snr = 1;
245  } else {
246  block->new_snr_offsets = 0;
247  }
248  }
249  if (!num_cpl_blocks)
250  s->cpl_on = 0;
251 
252  /* set bandwidth for each channel */
253  for (blk = 0; blk < s->num_blocks; blk++) {
254  AC3Block *block = &s->blocks[blk];
255  for (ch = 1; ch <= s->fbw_channels; ch++) {
256  if (block->channel_in_cpl[ch])
257  block->end_freq[ch] = s->start_freq[CPL_CH];
258  else
259  block->end_freq[ch] = s->bandwidth_code * 3 + 73;
260  }
261  }
262 }
263 
264 
265 /**
266  * Apply stereo rematrixing to coefficients based on rematrixing flags.
267  *
268  * @param s AC-3 encoder private context
269  */
271 {
272  int nb_coefs;
273  int blk, bnd, i;
274  int start, end;
275  uint8_t *flags = NULL;
276 
277  if (!s->rematrixing_enabled)
278  return;
279 
280  for (blk = 0; blk < s->num_blocks; blk++) {
281  AC3Block *block = &s->blocks[blk];
282  if (block->new_rematrixing_strategy)
283  flags = block->rematrixing_flags;
284  nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
285  for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
286  if (flags[bnd]) {
287  start = ff_ac3_rematrix_band_tab[bnd];
288  end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
289  for (i = start; i < end; i++) {
290  int32_t lt = block->fixed_coef[1][i];
291  int32_t rt = block->fixed_coef[2][i];
292  block->fixed_coef[1][i] = (lt + rt) >> 1;
293  block->fixed_coef[2][i] = (lt - rt) >> 1;
294  }
295  }
296  }
297  }
298 }
299 
300 
301 /*
302  * Initialize exponent tables.
303  */
305 {
306  int expstr, i, grpsize;
307 
308  for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {
309  grpsize = 3 << expstr;
310  for (i = 12; i < 256; i++) {
311  exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize;
312  exponent_group_tab[1][expstr][i] = (i ) / grpsize;
313  }
314  }
315  /* LFE */
316  exponent_group_tab[0][0][7] = 2;
317 
318  if (CONFIG_EAC3_ENCODER && s->eac3)
320 }
321 
322 
323 /*
324  * Extract exponents from the MDCT coefficients.
325  */
327 {
328  int ch = !s->cpl_on;
329  int chan_size = AC3_MAX_COEFS * s->num_blocks * (s->channels - ch + 1);
330  AC3Block *block = &s->blocks[0];
331 
332  s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], chan_size);
333 }
334 
335 
336 /**
337  * Exponent Difference Threshold.
338  * New exponents are sent if their SAD exceed this number.
339  */
340 #define EXP_DIFF_THRESHOLD 500
341 
342 /**
343  * Table used to select exponent strategy based on exponent reuse block interval.
344  */
345 static const uint8_t exp_strategy_reuse_tab[4][6] = {
346  { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
347  { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
348  { EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
349  { EXP_D45, EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15 }
350 };
351 
352 /*
353  * Calculate exponent strategies for all channels.
354  * Array arrangement is reversed to simplify the per-channel calculation.
355  */
357 {
358  int ch, blk, blk1;
359 
360  for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) {
361  uint8_t *exp_strategy = s->exp_strategy[ch];
362  uint8_t *exp = s->blocks[0].exp[ch];
363  int exp_diff;
364 
365  /* estimate if the exponent variation & decide if they should be
366  reused in the next frame */
367  exp_strategy[0] = EXP_NEW;
368  exp += AC3_MAX_COEFS;
369  for (blk = 1; blk < s->num_blocks; blk++, exp += AC3_MAX_COEFS) {
370  if (ch == CPL_CH) {
371  if (!s->blocks[blk-1].cpl_in_use) {
372  exp_strategy[blk] = EXP_NEW;
373  continue;
374  } else if (!s->blocks[blk].cpl_in_use) {
375  exp_strategy[blk] = EXP_REUSE;
376  continue;
377  }
378  } else if (s->blocks[blk].channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
379  exp_strategy[blk] = EXP_NEW;
380  continue;
381  }
382  exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
383  exp_strategy[blk] = EXP_REUSE;
384  if (ch == CPL_CH && exp_diff > (EXP_DIFF_THRESHOLD * (s->blocks[blk].end_freq[ch] - s->start_freq[ch]) / AC3_MAX_COEFS))
385  exp_strategy[blk] = EXP_NEW;
386  else if (ch > CPL_CH && exp_diff > EXP_DIFF_THRESHOLD)
387  exp_strategy[blk] = EXP_NEW;
388  }
389 
390  /* now select the encoding strategy type : if exponents are often
391  recoded, we use a coarse encoding */
392  blk = 0;
393  while (blk < s->num_blocks) {
394  blk1 = blk + 1;
395  while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE)
396  blk1++;
397  exp_strategy[blk] = exp_strategy_reuse_tab[s->num_blks_code][blk1-blk-1];
398  blk = blk1;
399  }
400  }
401  if (s->lfe_on) {
402  ch = s->lfe_channel;
403  s->exp_strategy[ch][0] = EXP_D15;
404  for (blk = 1; blk < s->num_blocks; blk++)
405  s->exp_strategy[ch][blk] = EXP_REUSE;
406  }
407 
408  /* for E-AC-3, determine frame exponent strategy */
409  if (CONFIG_EAC3_ENCODER && s->eac3)
411 }
412 
413 
414 /**
415  * Update the exponents so that they are the ones the decoder will decode.
416  *
417  * @param[in,out] exp array of exponents for 1 block in 1 channel
418  * @param nb_exps number of exponents in active bandwidth
419  * @param exp_strategy exponent strategy for the block
420  * @param cpl indicates if the block is in the coupling channel
421  */
422 static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,
423  int cpl)
424 {
425  int nb_groups, i, k;
426 
427  nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;
428 
429  /* for each group, compute the minimum exponent */
430  switch(exp_strategy) {
431  case EXP_D25:
432  for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
433  uint8_t exp_min = exp[k];
434  if (exp[k+1] < exp_min)
435  exp_min = exp[k+1];
436  exp[i-cpl] = exp_min;
437  k += 2;
438  }
439  break;
440  case EXP_D45:
441  for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
442  uint8_t exp_min = exp[k];
443  if (exp[k+1] < exp_min)
444  exp_min = exp[k+1];
445  if (exp[k+2] < exp_min)
446  exp_min = exp[k+2];
447  if (exp[k+3] < exp_min)
448  exp_min = exp[k+3];
449  exp[i-cpl] = exp_min;
450  k += 4;
451  }
452  break;
453  }
454 
455  /* constraint for DC exponent */
456  if (!cpl && exp[0] > 15)
457  exp[0] = 15;
458 
459  /* decrease the delta between each groups to within 2 so that they can be
460  differentially encoded */
461  for (i = 1; i <= nb_groups; i++)
462  exp[i] = FFMIN(exp[i], exp[i-1] + 2);
463  i--;
464  while (--i >= 0)
465  exp[i] = FFMIN(exp[i], exp[i+1] + 2);
466 
467  if (cpl)
468  exp[-1] = exp[0] & ~1;
469 
470  /* now we have the exponent values the decoder will see */
471  switch (exp_strategy) {
472  case EXP_D25:
473  for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) {
474  uint8_t exp1 = exp[i-cpl];
475  exp[k--] = exp1;
476  exp[k--] = exp1;
477  }
478  break;
479  case EXP_D45:
480  for (i = nb_groups, k = (nb_groups * 4)-cpl; i > 0; i--) {
481  exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i-cpl];
482  k -= 4;
483  }
484  break;
485  }
486 }
487 
488 
489 /*
490  * Encode exponents from original extracted form to what the decoder will see.
491  * This copies and groups exponents based on exponent strategy and reduces
492  * deltas between adjacent exponent groups so that they can be differentially
493  * encoded.
494  */
496 {
497  int blk, blk1, ch, cpl;
498  uint8_t *exp, *exp_strategy;
499  int nb_coefs, num_reuse_blocks;
500 
501  for (ch = !s->cpl_on; ch <= s->channels; ch++) {
502  exp = s->blocks[0].exp[ch] + s->start_freq[ch];
503  exp_strategy = s->exp_strategy[ch];
504 
505  cpl = (ch == CPL_CH);
506  blk = 0;
507  while (blk < s->num_blocks) {
508  AC3Block *block = &s->blocks[blk];
509  if (cpl && !block->cpl_in_use) {
510  exp += AC3_MAX_COEFS;
511  blk++;
512  continue;
513  }
514  nb_coefs = block->end_freq[ch] - s->start_freq[ch];
515  blk1 = blk + 1;
516 
517  /* count the number of EXP_REUSE blocks after the current block
518  and set exponent reference block numbers */
519  s->exp_ref_block[ch][blk] = blk;
520  while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE) {
521  s->exp_ref_block[ch][blk1] = blk;
522  blk1++;
523  }
524  num_reuse_blocks = blk1 - blk - 1;
525 
526  /* for the EXP_REUSE case we select the min of the exponents */
527  s->ac3dsp.ac3_exponent_min(exp-s->start_freq[ch], num_reuse_blocks,
528  AC3_MAX_COEFS);
529 
530  encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk], cpl);
531 
532  exp += AC3_MAX_COEFS * (num_reuse_blocks + 1);
533  blk = blk1;
534  }
535  }
536 
537  /* reference block numbers have been changed, so reset ref_bap_set */
538  s->ref_bap_set = 0;
539 }
540 
541 
542 /*
543  * Count exponent bits based on bandwidth, coupling, and exponent strategies.
544  */
546 {
547  int blk, ch;
548  int nb_groups, bit_count;
549 
550  bit_count = 0;
551  for (blk = 0; blk < s->num_blocks; blk++) {
552  AC3Block *block = &s->blocks[blk];
553  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
554  int exp_strategy = s->exp_strategy[ch][blk];
555  int cpl = (ch == CPL_CH);
556  int nb_coefs = block->end_freq[ch] - s->start_freq[ch];
557 
558  if (exp_strategy == EXP_REUSE)
559  continue;
560 
561  nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_coefs];
562  bit_count += 4 + (nb_groups * 7);
563  }
564  }
565 
566  return bit_count;
567 }
568 
569 
570 /**
571  * Group exponents.
572  * 3 delta-encoded exponents are in each 7-bit group. The number of groups
573  * varies depending on exponent strategy and bandwidth.
574  *
575  * @param s AC-3 encoder private context
576  */
578 {
579  int blk, ch, i, cpl;
580  int group_size, nb_groups;
581  uint8_t *p;
582  int delta0, delta1, delta2;
583  int exp0, exp1;
584 
585  for (blk = 0; blk < s->num_blocks; blk++) {
586  AC3Block *block = &s->blocks[blk];
587  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
588  int exp_strategy = s->exp_strategy[ch][blk];
589  if (exp_strategy == EXP_REUSE)
590  continue;
591  cpl = (ch == CPL_CH);
592  group_size = exp_strategy + (exp_strategy == EXP_D45);
593  nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]];
594  p = block->exp[ch] + s->start_freq[ch] - cpl;
595 
596  /* DC exponent */
597  exp1 = *p++;
598  block->grouped_exp[ch][0] = exp1;
599 
600  /* remaining exponents are delta encoded */
601  for (i = 1; i <= nb_groups; i++) {
602  /* merge three delta in one code */
603  exp0 = exp1;
604  exp1 = p[0];
605  p += group_size;
606  delta0 = exp1 - exp0 + 2;
607  av_assert2(delta0 >= 0 && delta0 <= 4);
608 
609  exp0 = exp1;
610  exp1 = p[0];
611  p += group_size;
612  delta1 = exp1 - exp0 + 2;
613  av_assert2(delta1 >= 0 && delta1 <= 4);
614 
615  exp0 = exp1;
616  exp1 = p[0];
617  p += group_size;
618  delta2 = exp1 - exp0 + 2;
619  av_assert2(delta2 >= 0 && delta2 <= 4);
620 
621  block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
622  }
623  }
624  }
625 }
626 
627 
628 /**
629  * Calculate final exponents from the supplied MDCT coefficients and exponent shift.
630  * Extract exponents from MDCT coefficients, calculate exponent strategies,
631  * and encode final exponents.
632  *
633  * @param s AC-3 encoder private context
634  */
636 {
638 
640 
641  encode_exponents(s);
642 
643  emms_c();
644 }
645 
646 
647 /*
648  * Count frame bits that are based solely on fixed parameters.
649  * This only has to be run once when the encoder is initialized.
650  */
652 {
653  static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
654  int blk;
655  int frame_bits;
656 
657  /* assumptions:
658  * no dynamic range codes
659  * bit allocation parameters do not change between blocks
660  * no delta bit allocation
661  * no skipped data
662  * no auxiliary data
663  * no E-AC-3 metadata
664  */
665 
666  /* header */
667  frame_bits = 16; /* sync info */
668  if (s->eac3) {
669  /* bitstream info header */
670  frame_bits += 35;
671  frame_bits += 1 + 1;
672  if (s->num_blocks != 0x6)
673  frame_bits++;
674  frame_bits++;
675  /* audio frame header */
676  if (s->num_blocks == 6)
677  frame_bits += 2;
678  frame_bits += 10;
679  /* exponent strategy */
680  if (s->use_frame_exp_strategy)
681  frame_bits += 5 * s->fbw_channels;
682  else
683  frame_bits += s->num_blocks * 2 * s->fbw_channels;
684  if (s->lfe_on)
685  frame_bits += s->num_blocks;
686  /* converter exponent strategy */
687  if (s->num_blks_code != 0x3)
688  frame_bits++;
689  else
690  frame_bits += s->fbw_channels * 5;
691  /* snr offsets */
692  frame_bits += 10;
693  /* block start info */
694  if (s->num_blocks != 1)
695  frame_bits++;
696  } else {
697  frame_bits += 49;
698  frame_bits += frame_bits_inc[s->channel_mode];
699  }
700 
701  /* audio blocks */
702  for (blk = 0; blk < s->num_blocks; blk++) {
703  if (!s->eac3) {
704  /* block switch flags */
705  frame_bits += s->fbw_channels;
706 
707  /* dither flags */
708  frame_bits += s->fbw_channels;
709  }
710 
711  /* dynamic range */
712  frame_bits++;
713 
714  /* spectral extension */
715  if (s->eac3)
716  frame_bits++;
717 
718  if (!s->eac3) {
719  /* exponent strategy */
720  frame_bits += 2 * s->fbw_channels;
721  if (s->lfe_on)
722  frame_bits++;
723 
724  /* bit allocation params */
725  frame_bits++;
726  if (!blk)
727  frame_bits += 2 + 2 + 2 + 2 + 3;
728  }
729 
730  /* converter snr offset */
731  if (s->eac3)
732  frame_bits++;
733 
734  if (!s->eac3) {
735  /* delta bit allocation */
736  frame_bits++;
737 
738  /* skipped data */
739  frame_bits++;
740  }
741  }
742 
743  /* auxiliary data */
744  frame_bits++;
745 
746  /* CRC */
747  frame_bits += 1 + 16;
748 
749  s->frame_bits_fixed = frame_bits;
750 }
751 
752 
753 /*
754  * Initialize bit allocation.
755  * Set default parameter codes and calculate parameter values.
756  */
758 {
759  int ch;
760 
761  /* init default parameters */
762  s->slow_decay_code = 2;
763  s->fast_decay_code = 1;
764  s->slow_gain_code = 1;
765  s->db_per_bit_code = s->eac3 ? 2 : 3;
766  s->floor_code = 7;
767  for (ch = 0; ch <= s->channels; ch++)
768  s->fast_gain_code[ch] = 4;
769 
770  /* initial snr offset */
771  s->coarse_snr_offset = 40;
772 
773  /* compute real values */
774  /* currently none of these values change during encoding, so we can just
775  set them once at initialization */
781  s->bit_alloc.cpl_fast_leak = 0;
782  s->bit_alloc.cpl_slow_leak = 0;
783 
785 }
786 
787 
788 /*
789  * Count the bits used to encode the frame, minus exponents and mantissas.
790  * Bits based on fixed parameters have already been counted, so now we just
791  * have to add the bits based on parameters that change during encoding.
792  */
794 {
795  AC3EncOptions *opt = &s->options;
796  int blk, ch;
797  int frame_bits = 0;
798 
799  /* header */
800  if (s->eac3) {
801  if (opt->eac3_mixing_metadata) {
803  frame_bits += 2;
804  if (s->has_center)
805  frame_bits += 6;
806  if (s->has_surround)
807  frame_bits += 6;
808  frame_bits += s->lfe_on;
809  frame_bits += 1 + 1 + 2;
811  frame_bits++;
812  frame_bits++;
813  }
814  if (opt->eac3_info_metadata) {
815  frame_bits += 3 + 1 + 1;
817  frame_bits += 2 + 2;
818  if (s->channel_mode >= AC3_CHMODE_2F2R)
819  frame_bits += 2;
820  frame_bits++;
821  if (opt->audio_production_info)
822  frame_bits += 5 + 2 + 1;
823  frame_bits++;
824  }
825  /* coupling */
826  if (s->channel_mode > AC3_CHMODE_MONO) {
827  frame_bits++;
828  for (blk = 1; blk < s->num_blocks; blk++) {
829  AC3Block *block = &s->blocks[blk];
830  frame_bits++;
831  if (block->new_cpl_strategy)
832  frame_bits++;
833  }
834  }
835  /* coupling exponent strategy */
836  if (s->cpl_on) {
837  if (s->use_frame_exp_strategy) {
838  frame_bits += 5 * s->cpl_on;
839  } else {
840  for (blk = 0; blk < s->num_blocks; blk++)
841  frame_bits += 2 * s->blocks[blk].cpl_in_use;
842  }
843  }
844  } else {
845  if (opt->audio_production_info)
846  frame_bits += 7;
847  if (s->bitstream_id == 6) {
848  if (opt->extended_bsi_1)
849  frame_bits += 14;
850  if (opt->extended_bsi_2)
851  frame_bits += 14;
852  }
853  }
854 
855  /* audio blocks */
856  for (blk = 0; blk < s->num_blocks; blk++) {
857  AC3Block *block = &s->blocks[blk];
858 
859  /* coupling strategy */
860  if (!s->eac3)
861  frame_bits++;
862  if (block->new_cpl_strategy) {
863  if (!s->eac3)
864  frame_bits++;
865  if (block->cpl_in_use) {
866  if (s->eac3)
867  frame_bits++;
868  if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO)
869  frame_bits += s->fbw_channels;
871  frame_bits++;
872  frame_bits += 4 + 4;
873  if (s->eac3)
874  frame_bits++;
875  else
876  frame_bits += s->num_cpl_subbands - 1;
877  }
878  }
879 
880  /* coupling coordinates */
881  if (block->cpl_in_use) {
882  for (ch = 1; ch <= s->fbw_channels; ch++) {
883  if (block->channel_in_cpl[ch]) {
884  if (!s->eac3 || block->new_cpl_coords[ch] != 2)
885  frame_bits++;
886  if (block->new_cpl_coords[ch]) {
887  frame_bits += 2;
888  frame_bits += (4 + 4) * s->num_cpl_bands;
889  }
890  }
891  }
892  }
893 
894  /* stereo rematrixing */
895  if (s->channel_mode == AC3_CHMODE_STEREO) {
896  if (!s->eac3 || blk > 0)
897  frame_bits++;
898  if (s->blocks[blk].new_rematrixing_strategy)
899  frame_bits += block->num_rematrixing_bands;
900  }
901 
902  /* bandwidth codes & gain range */
903  for (ch = 1; ch <= s->fbw_channels; ch++) {
904  if (s->exp_strategy[ch][blk] != EXP_REUSE) {
905  if (!block->channel_in_cpl[ch])
906  frame_bits += 6;
907  frame_bits += 2;
908  }
909  }
910 
911  /* coupling exponent strategy */
912  if (!s->eac3 && block->cpl_in_use)
913  frame_bits += 2;
914 
915  /* snr offsets and fast gain codes */
916  if (!s->eac3) {
917  frame_bits++;
918  if (block->new_snr_offsets)
919  frame_bits += 6 + (s->channels + block->cpl_in_use) * (4 + 3);
920  }
921 
922  /* coupling leak info */
923  if (block->cpl_in_use) {
924  if (!s->eac3 || block->new_cpl_leak != 2)
925  frame_bits++;
926  if (block->new_cpl_leak)
927  frame_bits += 3 + 3;
928  }
929  }
930 
931  s->frame_bits = s->frame_bits_fixed + frame_bits;
932 }
933 
934 
935 /*
936  * Calculate masking curve based on the final exponents.
937  * Also calculate the power spectral densities to use in future calculations.
938  */
940 {
941  int blk, ch;
942 
943  for (blk = 0; blk < s->num_blocks; blk++) {
944  AC3Block *block = &s->blocks[blk];
945  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
946  /* We only need psd and mask for calculating bap.
947  Since we currently do not calculate bap when exponent
948  strategy is EXP_REUSE we do not need to calculate psd or mask. */
949  if (s->exp_strategy[ch][blk] != EXP_REUSE) {
950  ff_ac3_bit_alloc_calc_psd(block->exp[ch], s->start_freq[ch],
951  block->end_freq[ch], block->psd[ch],
952  block->band_psd[ch]);
954  s->start_freq[ch], block->end_freq[ch],
956  ch == s->lfe_channel,
957  DBA_NONE, 0, NULL, NULL, NULL,
958  block->mask[ch]);
959  }
960  }
961  }
962 }
963 
964 
965 /*
966  * Ensure that bap for each block and channel point to the current bap_buffer.
967  * They may have been switched during the bit allocation search.
968  */
970 {
971  int blk, ch;
972  uint8_t *ref_bap;
973 
974  if (s->ref_bap[0][0] == s->bap_buffer && s->ref_bap_set)
975  return;
976 
977  ref_bap = s->bap_buffer;
978  for (ch = 0; ch <= s->channels; ch++) {
979  for (blk = 0; blk < s->num_blocks; blk++)
980  s->ref_bap[ch][blk] = ref_bap + AC3_MAX_COEFS * s->exp_ref_block[ch][blk];
981  ref_bap += AC3_MAX_COEFS * s->num_blocks;
982  }
983  s->ref_bap_set = 1;
984 }
985 
986 
987 /**
988  * Initialize mantissa counts.
989  * These are set so that they are padded to the next whole group size when bits
990  * are counted in compute_mantissa_size.
991  *
992  * @param[in,out] mant_cnt running counts for each bap value for each block
993  */
994 static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
995 {
996  int blk;
997 
998  for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
999  memset(mant_cnt[blk], 0, sizeof(mant_cnt[blk]));
1000  mant_cnt[blk][1] = mant_cnt[blk][2] = 2;
1001  mant_cnt[blk][4] = 1;
1002  }
1003 }
1004 
1005 
1006 /**
1007  * Update mantissa bit counts for all blocks in 1 channel in a given bandwidth
1008  * range.
1009  *
1010  * @param s AC-3 encoder private context
1011  * @param ch channel index
1012  * @param[in,out] mant_cnt running counts for each bap value for each block
1013  * @param start starting coefficient bin
1014  * @param end ending coefficient bin
1015  */
1017  uint16_t mant_cnt[AC3_MAX_BLOCKS][16],
1018  int start, int end)
1019 {
1020  int blk;
1021 
1022  for (blk = 0; blk < s->num_blocks; blk++) {
1023  AC3Block *block = &s->blocks[blk];
1024  if (ch == CPL_CH && !block->cpl_in_use)
1025  continue;
1026  s->ac3dsp.update_bap_counts(mant_cnt[blk],
1027  s->ref_bap[ch][blk] + start,
1028  FFMIN(end, block->end_freq[ch]) - start);
1029  }
1030 }
1031 
1032 
1033 /*
1034  * Count the number of mantissa bits in the frame based on the bap values.
1035  */
1037 {
1038  int ch, max_end_freq;
1039  LOCAL_ALIGNED_16(uint16_t, mant_cnt, [AC3_MAX_BLOCKS], [16]);
1040 
1041  count_mantissa_bits_init(mant_cnt);
1042 
1043  max_end_freq = s->bandwidth_code * 3 + 73;
1044  for (ch = !s->cpl_enabled; ch <= s->channels; ch++)
1045  count_mantissa_bits_update_ch(s, ch, mant_cnt, s->start_freq[ch],
1046  max_end_freq);
1047 
1048  return s->ac3dsp.compute_mantissa_size(mant_cnt);
1049 }
1050 
1051 
1052 /**
1053  * Run the bit allocation with a given SNR offset.
1054  * This calculates the bit allocation pointers that will be used to determine
1055  * the quantization of each mantissa.
1056  *
1057  * @param s AC-3 encoder private context
1058  * @param snr_offset SNR offset, 0 to 1023
1059  * @return the number of bits needed for mantissas if the given SNR offset is
1060  * is used.
1061  */
1062 static int bit_alloc(AC3EncodeContext *s, int snr_offset)
1063 {
1064  int blk, ch;
1065 
1066  snr_offset = (snr_offset - 240) << 2;
1067 
1068  reset_block_bap(s);
1069  for (blk = 0; blk < s->num_blocks; blk++) {
1070  AC3Block *block = &s->blocks[blk];
1071 
1072  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1073  /* Currently the only bit allocation parameters which vary across
1074  blocks within a frame are the exponent values. We can take
1075  advantage of that by reusing the bit allocation pointers
1076  whenever we reuse exponents. */
1077  if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1078  s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch],
1079  s->start_freq[ch], block->end_freq[ch],
1080  snr_offset, s->bit_alloc.floor,
1081  ff_ac3_bap_tab, s->ref_bap[ch][blk]);
1082  }
1083  }
1084  }
1085  return count_mantissa_bits(s);
1086 }
1087 
1088 
1089 /*
1090  * Constant bitrate bit allocation search.
1091  * Find the largest SNR offset that will allow data to fit in the frame.
1092  */
1094 {
1095  int ch;
1096  int bits_left;
1097  int snr_offset, snr_incr;
1098 
1099  bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
1100  if (bits_left < 0)
1101  return AVERROR(EINVAL);
1102 
1103  snr_offset = s->coarse_snr_offset << 4;
1104 
1105  /* if previous frame SNR offset was 1023, check if current frame can also
1106  use SNR offset of 1023. if so, skip the search. */
1107  if ((snr_offset | s->fine_snr_offset[1]) == 1023) {
1108  if (bit_alloc(s, 1023) <= bits_left)
1109  return 0;
1110  }
1111 
1112  while (snr_offset >= 0 &&
1113  bit_alloc(s, snr_offset) > bits_left) {
1114  snr_offset -= 64;
1115  }
1116  if (snr_offset < 0)
1117  return AVERROR(EINVAL);
1118 
1119  FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1120  for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) {
1121  while (snr_offset + snr_incr <= 1023 &&
1122  bit_alloc(s, snr_offset + snr_incr) <= bits_left) {
1123  snr_offset += snr_incr;
1124  FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1125  }
1126  }
1127  FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1128  reset_block_bap(s);
1129 
1130  s->coarse_snr_offset = snr_offset >> 4;
1131  for (ch = !s->cpl_on; ch <= s->channels; ch++)
1132  s->fine_snr_offset[ch] = snr_offset & 0xF;
1133 
1134  return 0;
1135 }
1136 
1137 
1138 /*
1139  * Perform bit allocation search.
1140  * Finds the SNR offset value that maximizes quality and fits in the specified
1141  * frame size. Output is the SNR offset and a set of bit allocation pointers
1142  * used to quantize the mantissas.
1143  */
1145 {
1146  count_frame_bits(s);
1147 
1149 
1150  bit_alloc_masking(s);
1151 
1152  return cbr_bit_allocation(s);
1153 }
1154 
1155 
1156 /**
1157  * Symmetric quantization on 'levels' levels.
1158  *
1159  * @param c unquantized coefficient
1160  * @param e exponent
1161  * @param levels number of quantization levels
1162  * @return quantized coefficient
1163  */
1164 static inline int sym_quant(int c, int e, int levels)
1165 {
1166  int v = (((levels * c) >> (24 - e)) + levels) >> 1;
1167  av_assert2(v >= 0 && v < levels);
1168  return v;
1169 }
1170 
1171 
1172 /**
1173  * Asymmetric quantization on 2^qbits levels.
1174  *
1175  * @param c unquantized coefficient
1176  * @param e exponent
1177  * @param qbits number of quantization bits
1178  * @return quantized coefficient
1179  */
1180 static inline int asym_quant(int c, int e, int qbits)
1181 {
1182  int m;
1183 
1184  c = (((c << e) >> (24 - qbits)) + 1) >> 1;
1185  m = (1 << (qbits-1));
1186  if (c >= m)
1187  c = m - 1;
1188  av_assert2(c >= -m);
1189  return c;
1190 }
1191 
1192 
1193 /**
1194  * Quantize a set of mantissas for a single channel in a single block.
1195  *
1196  * @param s Mantissa count context
1197  * @param fixed_coef unquantized fixed-point coefficients
1198  * @param exp exponents
1199  * @param bap bit allocation pointer indices
1200  * @param[out] qmant quantized coefficients
1201  * @param start_freq starting coefficient bin
1202  * @param end_freq ending coefficient bin
1203  */
1204 static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef,
1205  uint8_t *exp, uint8_t *bap,
1206  int16_t *qmant, int start_freq,
1207  int end_freq)
1208 {
1209  int i;
1210 
1211  for (i = start_freq; i < end_freq; i++) {
1212  int c = fixed_coef[i];
1213  int e = exp[i];
1214  int v = bap[i];
1215  if (v)
1216  switch (v) {
1217  case 1:
1218  v = sym_quant(c, e, 3);
1219  switch (s->mant1_cnt) {
1220  case 0:
1221  s->qmant1_ptr = &qmant[i];
1222  v = 9 * v;
1223  s->mant1_cnt = 1;
1224  break;
1225  case 1:
1226  *s->qmant1_ptr += 3 * v;
1227  s->mant1_cnt = 2;
1228  v = 128;
1229  break;
1230  default:
1231  *s->qmant1_ptr += v;
1232  s->mant1_cnt = 0;
1233  v = 128;
1234  break;
1235  }
1236  break;
1237  case 2:
1238  v = sym_quant(c, e, 5);
1239  switch (s->mant2_cnt) {
1240  case 0:
1241  s->qmant2_ptr = &qmant[i];
1242  v = 25 * v;
1243  s->mant2_cnt = 1;
1244  break;
1245  case 1:
1246  *s->qmant2_ptr += 5 * v;
1247  s->mant2_cnt = 2;
1248  v = 128;
1249  break;
1250  default:
1251  *s->qmant2_ptr += v;
1252  s->mant2_cnt = 0;
1253  v = 128;
1254  break;
1255  }
1256  break;
1257  case 3:
1258  v = sym_quant(c, e, 7);
1259  break;
1260  case 4:
1261  v = sym_quant(c, e, 11);
1262  switch (s->mant4_cnt) {
1263  case 0:
1264  s->qmant4_ptr = &qmant[i];
1265  v = 11 * v;
1266  s->mant4_cnt = 1;
1267  break;
1268  default:
1269  *s->qmant4_ptr += v;
1270  s->mant4_cnt = 0;
1271  v = 128;
1272  break;
1273  }
1274  break;
1275  case 5:
1276  v = sym_quant(c, e, 15);
1277  break;
1278  case 14:
1279  v = asym_quant(c, e, 14);
1280  break;
1281  case 15:
1282  v = asym_quant(c, e, 16);
1283  break;
1284  default:
1285  v = asym_quant(c, e, v - 1);
1286  break;
1287  }
1288  qmant[i] = v;
1289  }
1290 }
1291 
1292 
1293 /**
1294  * Quantize mantissas using coefficients, exponents, and bit allocation pointers.
1295  *
1296  * @param s AC-3 encoder private context
1297  */
1299 {
1300  int blk, ch, ch0=0, got_cpl;
1301 
1302  for (blk = 0; blk < s->num_blocks; blk++) {
1303  AC3Block *block = &s->blocks[blk];
1304  AC3Mant m = { 0 };
1305 
1306  got_cpl = !block->cpl_in_use;
1307  for (ch = 1; ch <= s->channels; ch++) {
1308  if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
1309  ch0 = ch - 1;
1310  ch = CPL_CH;
1311  got_cpl = 1;
1312  }
1313  quantize_mantissas_blk_ch(&m, block->fixed_coef[ch],
1314  s->blocks[s->exp_ref_block[ch][blk]].exp[ch],
1315  s->ref_bap[ch][blk], block->qmant[ch],
1316  s->start_freq[ch], block->end_freq[ch]);
1317  if (ch == CPL_CH)
1318  ch = ch0;
1319  }
1320  }
1321 }
1322 
1323 
1324 /*
1325  * Write the AC-3 frame header to the output bitstream.
1326  */
1328 {
1329  AC3EncOptions *opt = &s->options;
1330 
1331  put_bits(&s->pb, 16, 0x0b77); /* frame header */
1332  put_bits(&s->pb, 16, 0); /* crc1: will be filled later */
1333  put_bits(&s->pb, 2, s->bit_alloc.sr_code);
1334  put_bits(&s->pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min) / 2);
1335  put_bits(&s->pb, 5, s->bitstream_id);
1336  put_bits(&s->pb, 3, s->bitstream_mode);
1337  put_bits(&s->pb, 3, s->channel_mode);
1338  if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO)
1339  put_bits(&s->pb, 2, s->center_mix_level);
1340  if (s->channel_mode & 0x04)
1341  put_bits(&s->pb, 2, s->surround_mix_level);
1342  if (s->channel_mode == AC3_CHMODE_STEREO)
1343  put_bits(&s->pb, 2, opt->dolby_surround_mode);
1344  put_bits(&s->pb, 1, s->lfe_on); /* LFE */
1345  put_bits(&s->pb, 5, -opt->dialogue_level);
1346  put_bits(&s->pb, 1, 0); /* no compression control word */
1347  put_bits(&s->pb, 1, 0); /* no lang code */
1348  put_bits(&s->pb, 1, opt->audio_production_info);
1349  if (opt->audio_production_info) {
1350  put_bits(&s->pb, 5, opt->mixing_level - 80);
1351  put_bits(&s->pb, 2, opt->room_type);
1352  }
1353  put_bits(&s->pb, 1, opt->copyright);
1354  put_bits(&s->pb, 1, opt->original);
1355  if (s->bitstream_id == 6) {
1356  /* alternate bit stream syntax */
1357  put_bits(&s->pb, 1, opt->extended_bsi_1);
1358  if (opt->extended_bsi_1) {
1359  put_bits(&s->pb, 2, opt->preferred_stereo_downmix);
1360  put_bits(&s->pb, 3, s->ltrt_center_mix_level);
1361  put_bits(&s->pb, 3, s->ltrt_surround_mix_level);
1362  put_bits(&s->pb, 3, s->loro_center_mix_level);
1363  put_bits(&s->pb, 3, s->loro_surround_mix_level);
1364  }
1365  put_bits(&s->pb, 1, opt->extended_bsi_2);
1366  if (opt->extended_bsi_2) {
1367  put_bits(&s->pb, 2, opt->dolby_surround_ex_mode);
1368  put_bits(&s->pb, 2, opt->dolby_headphone_mode);
1369  put_bits(&s->pb, 1, opt->ad_converter_type);
1370  put_bits(&s->pb, 9, 0); /* xbsi2 and encinfo : reserved */
1371  }
1372  } else {
1373  put_bits(&s->pb, 1, 0); /* no time code 1 */
1374  put_bits(&s->pb, 1, 0); /* no time code 2 */
1375  }
1376  put_bits(&s->pb, 1, 0); /* no additional bit stream info */
1377 }
1378 
1379 
1380 /*
1381  * Write one audio block to the output bitstream.
1382  */
1384 {
1385  int ch, i, baie, bnd, got_cpl, ch0;
1386  AC3Block *block = &s->blocks[blk];
1387 
1388  /* block switching */
1389  if (!s->eac3) {
1390  for (ch = 0; ch < s->fbw_channels; ch++)
1391  put_bits(&s->pb, 1, 0);
1392  }
1393 
1394  /* dither flags */
1395  if (!s->eac3) {
1396  for (ch = 0; ch < s->fbw_channels; ch++)
1397  put_bits(&s->pb, 1, 1);
1398  }
1399 
1400  /* dynamic range codes */
1401  put_bits(&s->pb, 1, 0);
1402 
1403  /* spectral extension */
1404  if (s->eac3)
1405  put_bits(&s->pb, 1, 0);
1406 
1407  /* channel coupling */
1408  if (!s->eac3)
1409  put_bits(&s->pb, 1, block->new_cpl_strategy);
1410  if (block->new_cpl_strategy) {
1411  if (!s->eac3)
1412  put_bits(&s->pb, 1, block->cpl_in_use);
1413  if (block->cpl_in_use) {
1414  int start_sub, end_sub;
1415  if (s->eac3)
1416  put_bits(&s->pb, 1, 0); /* enhanced coupling */
1417  if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO) {
1418  for (ch = 1; ch <= s->fbw_channels; ch++)
1419  put_bits(&s->pb, 1, block->channel_in_cpl[ch]);
1420  }
1421  if (s->channel_mode == AC3_CHMODE_STEREO)
1422  put_bits(&s->pb, 1, 0); /* phase flags in use */
1423  start_sub = (s->start_freq[CPL_CH] - 37) / 12;
1424  end_sub = (s->cpl_end_freq - 37) / 12;
1425  put_bits(&s->pb, 4, start_sub);
1426  put_bits(&s->pb, 4, end_sub - 3);
1427  /* coupling band structure */
1428  if (s->eac3) {
1429  put_bits(&s->pb, 1, 0); /* use default */
1430  } else {
1431  for (bnd = start_sub+1; bnd < end_sub; bnd++)
1433  }
1434  }
1435  }
1436 
1437  /* coupling coordinates */
1438  if (block->cpl_in_use) {
1439  for (ch = 1; ch <= s->fbw_channels; ch++) {
1440  if (block->channel_in_cpl[ch]) {
1441  if (!s->eac3 || block->new_cpl_coords[ch] != 2)
1442  put_bits(&s->pb, 1, block->new_cpl_coords[ch]);
1443  if (block->new_cpl_coords[ch]) {
1444  put_bits(&s->pb, 2, block->cpl_master_exp[ch]);
1445  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1446  put_bits(&s->pb, 4, block->cpl_coord_exp [ch][bnd]);
1447  put_bits(&s->pb, 4, block->cpl_coord_mant[ch][bnd]);
1448  }
1449  }
1450  }
1451  }
1452  }
1453 
1454  /* stereo rematrixing */
1455  if (s->channel_mode == AC3_CHMODE_STEREO) {
1456  if (!s->eac3 || blk > 0)
1457  put_bits(&s->pb, 1, block->new_rematrixing_strategy);
1458  if (block->new_rematrixing_strategy) {
1459  /* rematrixing flags */
1460  for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++)
1461  put_bits(&s->pb, 1, block->rematrixing_flags[bnd]);
1462  }
1463  }
1464 
1465  /* exponent strategy */
1466  if (!s->eac3) {
1467  for (ch = !block->cpl_in_use; ch <= s->fbw_channels; ch++)
1468  put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
1469  if (s->lfe_on)
1470  put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
1471  }
1472 
1473  /* bandwidth */
1474  for (ch = 1; ch <= s->fbw_channels; ch++) {
1475  if (s->exp_strategy[ch][blk] != EXP_REUSE && !block->channel_in_cpl[ch])
1476  put_bits(&s->pb, 6, s->bandwidth_code);
1477  }
1478 
1479  /* exponents */
1480  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1481  int nb_groups;
1482  int cpl = (ch == CPL_CH);
1483 
1484  if (s->exp_strategy[ch][blk] == EXP_REUSE)
1485  continue;
1486 
1487  /* DC exponent */
1488  put_bits(&s->pb, 4, block->grouped_exp[ch][0] >> cpl);
1489 
1490  /* exponent groups */
1491  nb_groups = exponent_group_tab[cpl][s->exp_strategy[ch][blk]-1][block->end_freq[ch]-s->start_freq[ch]];
1492  for (i = 1; i <= nb_groups; i++)
1493  put_bits(&s->pb, 7, block->grouped_exp[ch][i]);
1494 
1495  /* gain range info */
1496  if (ch != s->lfe_channel && !cpl)
1497  put_bits(&s->pb, 2, 0);
1498  }
1499 
1500  /* bit allocation info */
1501  if (!s->eac3) {
1502  baie = (blk == 0);
1503  put_bits(&s->pb, 1, baie);
1504  if (baie) {
1505  put_bits(&s->pb, 2, s->slow_decay_code);
1506  put_bits(&s->pb, 2, s->fast_decay_code);
1507  put_bits(&s->pb, 2, s->slow_gain_code);
1508  put_bits(&s->pb, 2, s->db_per_bit_code);
1509  put_bits(&s->pb, 3, s->floor_code);
1510  }
1511  }
1512 
1513  /* snr offset */
1514  if (!s->eac3) {
1515  put_bits(&s->pb, 1, block->new_snr_offsets);
1516  if (block->new_snr_offsets) {
1517  put_bits(&s->pb, 6, s->coarse_snr_offset);
1518  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1519  put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
1520  put_bits(&s->pb, 3, s->fast_gain_code[ch]);
1521  }
1522  }
1523  } else {
1524  put_bits(&s->pb, 1, 0); /* no converter snr offset */
1525  }
1526 
1527  /* coupling leak */
1528  if (block->cpl_in_use) {
1529  if (!s->eac3 || block->new_cpl_leak != 2)
1530  put_bits(&s->pb, 1, block->new_cpl_leak);
1531  if (block->new_cpl_leak) {
1532  put_bits(&s->pb, 3, s->bit_alloc.cpl_fast_leak);
1533  put_bits(&s->pb, 3, s->bit_alloc.cpl_slow_leak);
1534  }
1535  }
1536 
1537  if (!s->eac3) {
1538  put_bits(&s->pb, 1, 0); /* no delta bit allocation */
1539  put_bits(&s->pb, 1, 0); /* no data to skip */
1540  }
1541 
1542  /* mantissas */
1543  got_cpl = !block->cpl_in_use;
1544  for (ch = 1; ch <= s->channels; ch++) {
1545  int b, q;
1546 
1547  if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
1548  ch0 = ch - 1;
1549  ch = CPL_CH;
1550  got_cpl = 1;
1551  }
1552  for (i = s->start_freq[ch]; i < block->end_freq[ch]; i++) {
1553  q = block->qmant[ch][i];
1554  b = s->ref_bap[ch][blk][i];
1555  switch (b) {
1556  case 0: break;
1557  case 1: if (q != 128) put_bits (&s->pb, 5, q); break;
1558  case 2: if (q != 128) put_bits (&s->pb, 7, q); break;
1559  case 3: put_sbits(&s->pb, 3, q); break;
1560  case 4: if (q != 128) put_bits (&s->pb, 7, q); break;
1561  case 14: put_sbits(&s->pb, 14, q); break;
1562  case 15: put_sbits(&s->pb, 16, q); break;
1563  default: put_sbits(&s->pb, b-1, q); break;
1564  }
1565  }
1566  if (ch == CPL_CH)
1567  ch = ch0;
1568  }
1569 }
1570 
1571 
1572 /** CRC-16 Polynomial */
1573 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))
1574 
1575 
1576 static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
1577 {
1578  unsigned int c;
1579 
1580  c = 0;
1581  while (a) {
1582  if (a & 1)
1583  c ^= b;
1584  a = a >> 1;
1585  b = b << 1;
1586  if (b & (1 << 16))
1587  b ^= poly;
1588  }
1589  return c;
1590 }
1591 
1592 
1593 static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
1594 {
1595  unsigned int r;
1596  r = 1;
1597  while (n) {
1598  if (n & 1)
1599  r = mul_poly(r, a, poly);
1600  a = mul_poly(a, a, poly);
1601  n >>= 1;
1602  }
1603  return r;
1604 }
1605 
1606 
1607 /*
1608  * Fill the end of the frame with 0's and compute the two CRCs.
1609  */
1611 {
1612  const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI);
1613  int frame_size_58, pad_bytes, crc1, crc2_partial, crc2, crc_inv;
1614  uint8_t *frame;
1615 
1616  frame_size_58 = ((s->frame_size >> 2) + (s->frame_size >> 4)) << 1;
1617 
1618  /* pad the remainder of the frame with zeros */
1619  av_assert2(s->frame_size * 8 - put_bits_count(&s->pb) >= 18);
1620  flush_put_bits(&s->pb);
1621  frame = s->pb.buf;
1622  pad_bytes = s->frame_size - (put_bits_ptr(&s->pb) - frame) - 2;
1623  av_assert2(pad_bytes >= 0);
1624  if (pad_bytes > 0)
1625  memset(put_bits_ptr(&s->pb), 0, pad_bytes);
1626 
1627  if (s->eac3) {
1628  /* compute crc2 */
1629  crc2_partial = av_crc(crc_ctx, 0, frame + 2, s->frame_size - 5);
1630  } else {
1631  /* compute crc1 */
1632  /* this is not so easy because it is at the beginning of the data... */
1633  crc1 = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58 - 4));
1634  crc_inv = s->crc_inv[s->frame_size > s->frame_size_min];
1635  crc1 = mul_poly(crc_inv, crc1, CRC16_POLY);
1636  AV_WB16(frame + 2, crc1);
1637 
1638  /* compute crc2 */
1639  crc2_partial = av_crc(crc_ctx, 0, frame + frame_size_58,
1640  s->frame_size - frame_size_58 - 3);
1641  }
1642  crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
1643  /* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
1644  if (crc2 == 0x770B) {
1645  frame[s->frame_size - 3] ^= 0x1;
1646  crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
1647  }
1648  crc2 = av_bswap16(crc2);
1649  AV_WB16(frame + s->frame_size - 2, crc2);
1650 }
1651 
1652 
1653 /**
1654  * Write the frame to the output bitstream.
1655  *
1656  * @param s AC-3 encoder private context
1657  * @param frame output data buffer
1658  */
1660 {
1661  int blk;
1662 
1664 
1665  s->output_frame_header(s);
1666 
1667  for (blk = 0; blk < s->num_blocks; blk++)
1668  output_audio_block(s, blk);
1669 
1670  output_frame_end(s);
1671 }
1672 
1673 
1675 {
1676 #ifdef DEBUG
1677  AVCodecContext *avctx = s->avctx;
1678  AC3EncOptions *opt = &s->options;
1679  char strbuf[32];
1680 
1681  switch (s->bitstream_id) {
1682  case 6: av_strlcpy(strbuf, "AC-3 (alt syntax)", 32); break;
1683  case 8: av_strlcpy(strbuf, "AC-3 (standard)", 32); break;
1684  case 9: av_strlcpy(strbuf, "AC-3 (dnet half-rate)", 32); break;
1685  case 10: av_strlcpy(strbuf, "AC-3 (dnet quater-rate)", 32); break;
1686  case 16: av_strlcpy(strbuf, "E-AC-3 (enhanced)", 32); break;
1687  default: snprintf(strbuf, 32, "ERROR");
1688  }
1689  av_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id);
1690  av_dlog(avctx, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx->sample_fmt));
1691  av_get_channel_layout_string(strbuf, 32, s->channels, avctx->channel_layout);
1692  av_dlog(avctx, "channel_layout: %s\n", strbuf);
1693  av_dlog(avctx, "sample_rate: %d\n", s->sample_rate);
1694  av_dlog(avctx, "bit_rate: %d\n", s->bit_rate);
1695  av_dlog(avctx, "blocks/frame: %d (code=%d)\n", s->num_blocks, s->num_blks_code);
1696  if (s->cutoff)
1697  av_dlog(avctx, "cutoff: %d\n", s->cutoff);
1698 
1699  av_dlog(avctx, "per_frame_metadata: %s\n",
1700  opt->allow_per_frame_metadata?"on":"off");
1701  if (s->has_center)
1702  av_dlog(avctx, "center_mixlev: %0.3f (%d)\n", opt->center_mix_level,
1703  s->center_mix_level);
1704  else
1705  av_dlog(avctx, "center_mixlev: {not written}\n");
1706  if (s->has_surround)
1707  av_dlog(avctx, "surround_mixlev: %0.3f (%d)\n", opt->surround_mix_level,
1708  s->surround_mix_level);
1709  else
1710  av_dlog(avctx, "surround_mixlev: {not written}\n");
1711  if (opt->audio_production_info) {
1712  av_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level);
1713  switch (opt->room_type) {
1714  case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
1715  case AC3ENC_OPT_LARGE_ROOM: av_strlcpy(strbuf, "large", 32); break;
1716  case AC3ENC_OPT_SMALL_ROOM: av_strlcpy(strbuf, "small", 32); break;
1717  default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type);
1718  }
1719  av_dlog(avctx, "room_type: %s\n", strbuf);
1720  } else {
1721  av_dlog(avctx, "mixing_level: {not written}\n");
1722  av_dlog(avctx, "room_type: {not written}\n");
1723  }
1724  av_dlog(avctx, "copyright: %s\n", opt->copyright?"on":"off");
1725  av_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level);
1726  if (s->channel_mode == AC3_CHMODE_STEREO) {
1727  switch (opt->dolby_surround_mode) {
1728  case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
1729  case AC3ENC_OPT_MODE_ON: av_strlcpy(strbuf, "on", 32); break;
1730  case AC3ENC_OPT_MODE_OFF: av_strlcpy(strbuf, "off", 32); break;
1731  default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode);
1732  }
1733  av_dlog(avctx, "dsur_mode: %s\n", strbuf);
1734  } else {
1735  av_dlog(avctx, "dsur_mode: {not written}\n");
1736  }
1737  av_dlog(avctx, "original: %s\n", opt->original?"on":"off");
1738 
1739  if (s->bitstream_id == 6) {
1740  if (opt->extended_bsi_1) {
1741  switch (opt->preferred_stereo_downmix) {
1742  case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
1743  case AC3ENC_OPT_DOWNMIX_LTRT: av_strlcpy(strbuf, "ltrt", 32); break;
1744  case AC3ENC_OPT_DOWNMIX_LORO: av_strlcpy(strbuf, "loro", 32); break;
1745  default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix);
1746  }
1747  av_dlog(avctx, "dmix_mode: %s\n", strbuf);
1748  av_dlog(avctx, "ltrt_cmixlev: %0.3f (%d)\n",
1750  av_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n",
1752  av_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n",
1754  av_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n",
1756  } else {
1757  av_dlog(avctx, "extended bitstream info 1: {not written}\n");
1758  }
1759  if (opt->extended_bsi_2) {
1760  switch (opt->dolby_surround_ex_mode) {
1761  case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
1762  case AC3ENC_OPT_MODE_ON: av_strlcpy(strbuf, "on", 32); break;
1763  case AC3ENC_OPT_MODE_OFF: av_strlcpy(strbuf, "off", 32); break;
1764  default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode);
1765  }
1766  av_dlog(avctx, "dsurex_mode: %s\n", strbuf);
1767  switch (opt->dolby_headphone_mode) {
1768  case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
1769  case AC3ENC_OPT_MODE_ON: av_strlcpy(strbuf, "on", 32); break;
1770  case AC3ENC_OPT_MODE_OFF: av_strlcpy(strbuf, "off", 32); break;
1771  default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode);
1772  }
1773  av_dlog(avctx, "dheadphone_mode: %s\n", strbuf);
1774 
1775  switch (opt->ad_converter_type) {
1776  case AC3ENC_OPT_ADCONV_STANDARD: av_strlcpy(strbuf, "standard", 32); break;
1777  case AC3ENC_OPT_ADCONV_HDCD: av_strlcpy(strbuf, "hdcd", 32); break;
1778  default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type);
1779  }
1780  av_dlog(avctx, "ad_conv_type: %s\n", strbuf);
1781  } else {
1782  av_dlog(avctx, "extended bitstream info 2: {not written}\n");
1783  }
1784  }
1785 #endif
1786 }
1787 
1788 
1789 #define FLT_OPTION_THRESHOLD 0.01
1790 
1791 static int validate_float_option(float v, const float *v_list, int v_list_size)
1792 {
1793  int i;
1794 
1795  for (i = 0; i < v_list_size; i++) {
1796  if (v < (v_list[i] + FLT_OPTION_THRESHOLD) &&
1797  v > (v_list[i] - FLT_OPTION_THRESHOLD))
1798  break;
1799  }
1800  if (i == v_list_size)
1801  return -1;
1802 
1803  return i;
1804 }
1805 
1806 
1807 static void validate_mix_level(void *log_ctx, const char *opt_name,
1808  float *opt_param, const float *list,
1809  int list_size, int default_value, int min_value,
1810  int *ctx_param)
1811 {
1812  int mixlev = validate_float_option(*opt_param, list, list_size);
1813  if (mixlev < min_value) {
1814  mixlev = default_value;
1815  if (*opt_param >= 0.0) {
1816  av_log(log_ctx, AV_LOG_WARNING, "requested %s is not valid. using "
1817  "default value: %0.3f\n", opt_name, list[mixlev]);
1818  }
1819  }
1820  *opt_param = list[mixlev];
1821  *ctx_param = mixlev;
1822 }
1823 
1824 
1825 /**
1826  * Validate metadata options as set by AVOption system.
1827  * These values can optionally be changed per-frame.
1828  *
1829  * @param s AC-3 encoder private context
1830  */
1832 {
1833  AVCodecContext *avctx = s->avctx;
1834  AC3EncOptions *opt = &s->options;
1835 
1836  opt->audio_production_info = 0;
1837  opt->extended_bsi_1 = 0;
1838  opt->extended_bsi_2 = 0;
1839  opt->eac3_mixing_metadata = 0;
1840  opt->eac3_info_metadata = 0;
1841 
1842  /* determine mixing metadata / xbsi1 use */
1844  opt->extended_bsi_1 = 1;
1845  opt->eac3_mixing_metadata = 1;
1846  }
1847  if (s->has_center &&
1848  (opt->ltrt_center_mix_level >= 0 || opt->loro_center_mix_level >= 0)) {
1849  opt->extended_bsi_1 = 1;
1850  opt->eac3_mixing_metadata = 1;
1851  }
1852  if (s->has_surround &&
1853  (opt->ltrt_surround_mix_level >= 0 || opt->loro_surround_mix_level >= 0)) {
1854  opt->extended_bsi_1 = 1;
1855  opt->eac3_mixing_metadata = 1;
1856  }
1857 
1858  if (s->eac3) {
1859  /* determine info metadata use */
1861  opt->eac3_info_metadata = 1;
1862  if (opt->copyright != AC3ENC_OPT_NONE || opt->original != AC3ENC_OPT_NONE)
1863  opt->eac3_info_metadata = 1;
1864  if (s->channel_mode == AC3_CHMODE_STEREO &&
1866  opt->eac3_info_metadata = 1;
1868  opt->eac3_info_metadata = 1;
1869  if (opt->mixing_level != AC3ENC_OPT_NONE || opt->room_type != AC3ENC_OPT_NONE ||
1871  opt->audio_production_info = 1;
1872  opt->eac3_info_metadata = 1;
1873  }
1874  } else {
1875  /* determine audio production info use */
1876  if (opt->mixing_level != AC3ENC_OPT_NONE || opt->room_type != AC3ENC_OPT_NONE)
1877  opt->audio_production_info = 1;
1878 
1879  /* determine xbsi2 use */
1881  opt->extended_bsi_2 = 1;
1883  opt->extended_bsi_2 = 1;
1884  if (opt->ad_converter_type != AC3ENC_OPT_NONE)
1885  opt->extended_bsi_2 = 1;
1886  }
1887 
1888  /* validate AC-3 mixing levels */
1889  if (!s->eac3) {
1890  if (s->has_center) {
1891  validate_mix_level(avctx, "center_mix_level", &opt->center_mix_level,
1893  &s->center_mix_level);
1894  }
1895  if (s->has_surround) {
1896  validate_mix_level(avctx, "surround_mix_level", &opt->surround_mix_level,
1898  &s->surround_mix_level);
1899  }
1900  }
1901 
1902  /* validate extended bsi 1 / mixing metadata */
1903  if (opt->extended_bsi_1 || opt->eac3_mixing_metadata) {
1904  /* default preferred stereo downmix */
1907  if (!s->eac3 || s->has_center) {
1908  /* validate Lt/Rt center mix level */
1909  validate_mix_level(avctx, "ltrt_center_mix_level",
1911  EXTMIXLEV_NUM_OPTIONS, 5, 0,
1912  &s->ltrt_center_mix_level);
1913  /* validate Lo/Ro center mix level */
1914  validate_mix_level(avctx, "loro_center_mix_level",
1916  EXTMIXLEV_NUM_OPTIONS, 5, 0,
1917  &s->loro_center_mix_level);
1918  }
1919  if (!s->eac3 || s->has_surround) {
1920  /* validate Lt/Rt surround mix level */
1921  validate_mix_level(avctx, "ltrt_surround_mix_level",
1923  EXTMIXLEV_NUM_OPTIONS, 6, 3,
1925  /* validate Lo/Ro surround mix level */
1926  validate_mix_level(avctx, "loro_surround_mix_level",
1928  EXTMIXLEV_NUM_OPTIONS, 6, 3,
1930  }
1931  }
1932 
1933  /* validate audio service type / channels combination */
1935  avctx->channels == 1) ||
1939  && avctx->channels > 1)) {
1940  av_log(avctx, AV_LOG_ERROR, "invalid audio service type for the "
1941  "specified number of channels\n");
1942  return AVERROR(EINVAL);
1943  }
1944 
1945  /* validate extended bsi 2 / info metadata */
1946  if (opt->extended_bsi_2 || opt->eac3_info_metadata) {
1947  /* default dolby headphone mode */
1950  /* default dolby surround ex mode */
1953  /* default A/D converter type */
1954  if (opt->ad_converter_type == AC3ENC_OPT_NONE)
1956  }
1957 
1958  /* copyright & original defaults */
1959  if (!s->eac3 || opt->eac3_info_metadata) {
1960  /* default copyright */
1961  if (opt->copyright == AC3ENC_OPT_NONE)
1962  opt->copyright = AC3ENC_OPT_OFF;
1963  /* default original */
1964  if (opt->original == AC3ENC_OPT_NONE)
1965  opt->original = AC3ENC_OPT_ON;
1966  }
1967 
1968  /* dolby surround mode default */
1969  if (!s->eac3 || opt->eac3_info_metadata) {
1972  }
1973 
1974  /* validate audio production info */
1975  if (opt->audio_production_info) {
1976  if (opt->mixing_level == AC3ENC_OPT_NONE) {
1977  av_log(avctx, AV_LOG_ERROR, "mixing_level must be set if "
1978  "room_type is set\n");
1979  return AVERROR(EINVAL);
1980  }
1981  if (opt->mixing_level < 80) {
1982  av_log(avctx, AV_LOG_ERROR, "invalid mixing level. must be between "
1983  "80dB and 111dB\n");
1984  return AVERROR(EINVAL);
1985  }
1986  /* default room type */
1987  if (opt->room_type == AC3ENC_OPT_NONE)
1989  }
1990 
1991  /* set bitstream id for alternate bitstream syntax */
1992  if (!s->eac3 && (opt->extended_bsi_1 || opt->extended_bsi_2)) {
1993  if (s->bitstream_id > 8 && s->bitstream_id < 11) {
1994  static int warn_once = 1;
1995  if (warn_once) {
1996  av_log(avctx, AV_LOG_WARNING, "alternate bitstream syntax is "
1997  "not compatible with reduced samplerates. writing of "
1998  "extended bitstream information will be disabled.\n");
1999  warn_once = 0;
2000  }
2001  } else {
2002  s->bitstream_id = 6;
2003  }
2004  }
2005 
2006  return 0;
2007 }
2008 
2009 
2010 /**
2011  * Finalize encoding and free any memory allocated by the encoder.
2012  *
2013  * @param avctx Codec context
2014  */
2016 {
2017  int blk, ch;
2018  AC3EncodeContext *s = avctx->priv_data;
2019 
2021  for (ch = 0; ch < s->channels; ch++)
2022  av_freep(&s->planar_samples[ch]);
2023  av_freep(&s->planar_samples);
2024  av_freep(&s->bap_buffer);
2025  av_freep(&s->bap1_buffer);
2028  av_freep(&s->exp_buffer);
2030  av_freep(&s->psd_buffer);
2032  av_freep(&s->mask_buffer);
2033  av_freep(&s->qmant_buffer);
2036  for (blk = 0; blk < s->num_blocks; blk++) {
2037  AC3Block *block = &s->blocks[blk];
2038  av_freep(&block->mdct_coef);
2039  av_freep(&block->fixed_coef);
2040  av_freep(&block->exp);
2041  av_freep(&block->grouped_exp);
2042  av_freep(&block->psd);
2043  av_freep(&block->band_psd);
2044  av_freep(&block->mask);
2045  av_freep(&block->qmant);
2046  av_freep(&block->cpl_coord_exp);
2047  av_freep(&block->cpl_coord_mant);
2048  }
2049 
2050  s->mdct_end(s);
2051 
2052  return 0;
2053 }
2054 
2055 
2056 /*
2057  * Set channel information during initialization.
2058  */
2059 static av_cold int set_channel_info(AC3EncodeContext *s, int channels,
2060  uint64_t *channel_layout)
2061 {
2062  int ch_layout;
2063 
2064  if (channels < 1 || channels > AC3_MAX_CHANNELS)
2065  return AVERROR(EINVAL);
2066  if (*channel_layout > 0x7FF)
2067  return AVERROR(EINVAL);
2068  ch_layout = *channel_layout;
2069  if (!ch_layout)
2070  ch_layout = av_get_default_channel_layout(channels);
2071 
2072  s->lfe_on = !!(ch_layout & AV_CH_LOW_FREQUENCY);
2073  s->channels = channels;
2074  s->fbw_channels = channels - s->lfe_on;
2075  s->lfe_channel = s->lfe_on ? s->fbw_channels + 1 : -1;
2076  if (s->lfe_on)
2077  ch_layout -= AV_CH_LOW_FREQUENCY;
2078 
2079  switch (ch_layout) {
2083  case AV_CH_LAYOUT_2_1: s->channel_mode = AC3_CHMODE_2F1R; break;
2085  case AV_CH_LAYOUT_QUAD:
2086  case AV_CH_LAYOUT_2_2: s->channel_mode = AC3_CHMODE_2F2R; break;
2087  case AV_CH_LAYOUT_5POINT0:
2089  default:
2090  return AVERROR(EINVAL);
2091  }
2092  s->has_center = (s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO;
2093  s->has_surround = s->channel_mode & 0x04;
2094 
2096  *channel_layout = ch_layout;
2097  if (s->lfe_on)
2098  *channel_layout |= AV_CH_LOW_FREQUENCY;
2099 
2100  return 0;
2101 }
2102 
2103 
2105 {
2106  AVCodecContext *avctx = s->avctx;
2107  int i, ret, max_sr;
2108 
2109  /* validate channel layout */
2110  if (!avctx->channel_layout) {
2111  av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
2112  "encoder will guess the layout, but it "
2113  "might be incorrect.\n");
2114  }
2115  ret = set_channel_info(s, avctx->channels, &avctx->channel_layout);
2116  if (ret) {
2117  av_log(avctx, AV_LOG_ERROR, "invalid channel layout\n");
2118  return ret;
2119  }
2120 
2121  /* validate sample rate */
2122  /* note: max_sr could be changed from 2 to 5 for E-AC-3 once we find a
2123  decoder that supports half sample rate so we can validate that
2124  the generated files are correct. */
2125  max_sr = s->eac3 ? 2 : 8;
2126  for (i = 0; i <= max_sr; i++) {
2127  if ((ff_ac3_sample_rate_tab[i % 3] >> (i / 3)) == avctx->sample_rate)
2128  break;
2129  }
2130  if (i > max_sr) {
2131  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
2132  return AVERROR(EINVAL);
2133  }
2134  s->sample_rate = avctx->sample_rate;
2135  s->bit_alloc.sr_shift = i / 3;
2136  s->bit_alloc.sr_code = i % 3;
2137  s->bitstream_id = s->eac3 ? 16 : 8 + s->bit_alloc.sr_shift;
2138 
2139  /* select a default bit rate if not set by the user */
2140  if (!avctx->bit_rate) {
2141  switch (s->fbw_channels) {
2142  case 1: avctx->bit_rate = 96000; break;
2143  case 2: avctx->bit_rate = 192000; break;
2144  case 3: avctx->bit_rate = 320000; break;
2145  case 4: avctx->bit_rate = 384000; break;
2146  case 5: avctx->bit_rate = 448000; break;
2147  }
2148  }
2149 
2150  /* validate bit rate */
2151  if (s->eac3) {
2152  int max_br, min_br, wpf, min_br_dist, min_br_code;
2153  int num_blks_code, num_blocks, frame_samples;
2154 
2155  /* calculate min/max bitrate */
2156  /* TODO: More testing with 3 and 2 blocks. All E-AC-3 samples I've
2157  found use either 6 blocks or 1 block, even though 2 or 3 blocks
2158  would work as far as the bit rate is concerned. */
2159  for (num_blks_code = 3; num_blks_code >= 0; num_blks_code--) {
2160  num_blocks = ((int[]){ 1, 2, 3, 6 })[num_blks_code];
2161  frame_samples = AC3_BLOCK_SIZE * num_blocks;
2162  max_br = 2048 * s->sample_rate / frame_samples * 16;
2163  min_br = ((s->sample_rate + (frame_samples-1)) / frame_samples) * 16;
2164  if (avctx->bit_rate <= max_br)
2165  break;
2166  }
2167  if (avctx->bit_rate < min_br || avctx->bit_rate > max_br) {
2168  av_log(avctx, AV_LOG_ERROR, "invalid bit rate. must be %d to %d "
2169  "for this sample rate\n", min_br, max_br);
2170  return AVERROR(EINVAL);
2171  }
2172  s->num_blks_code = num_blks_code;
2173  s->num_blocks = num_blocks;
2174 
2175  /* calculate words-per-frame for the selected bitrate */
2176  wpf = (avctx->bit_rate / 16) * frame_samples / s->sample_rate;
2177  av_assert1(wpf > 0 && wpf <= 2048);
2178 
2179  /* find the closest AC-3 bitrate code to the selected bitrate.
2180  this is needed for lookup tables for bandwidth and coupling
2181  parameter selection */
2182  min_br_code = -1;
2183  min_br_dist = INT_MAX;
2184  for (i = 0; i < 19; i++) {
2185  int br_dist = abs(ff_ac3_bitrate_tab[i] * 1000 - avctx->bit_rate);
2186  if (br_dist < min_br_dist) {
2187  min_br_dist = br_dist;
2188  min_br_code = i;
2189  }
2190  }
2191 
2192  /* make sure the minimum frame size is below the average frame size */
2193  s->frame_size_code = min_br_code << 1;
2194  while (wpf > 1 && wpf * s->sample_rate / AC3_FRAME_SIZE * 16 > avctx->bit_rate)
2195  wpf--;
2196  s->frame_size_min = 2 * wpf;
2197  } else {
2198  int best_br = 0, best_code = 0, best_diff = INT_MAX;
2199  for (i = 0; i < 19; i++) {
2200  int br = (ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift) * 1000;
2201  int diff = abs(br - avctx->bit_rate);
2202  if (diff < best_diff) {
2203  best_br = br;
2204  best_code = i;
2205  best_diff = diff;
2206  }
2207  if (!best_diff)
2208  break;
2209  }
2210  avctx->bit_rate = best_br;
2211  s->frame_size_code = best_code << 1;
2213  s->num_blks_code = 0x3;
2214  s->num_blocks = 6;
2215  }
2216  s->bit_rate = avctx->bit_rate;
2217  s->frame_size = s->frame_size_min;
2218 
2219  /* validate cutoff */
2220  if (avctx->cutoff < 0) {
2221  av_log(avctx, AV_LOG_ERROR, "invalid cutoff frequency\n");
2222  return AVERROR(EINVAL);
2223  }
2224  s->cutoff = avctx->cutoff;
2225  if (s->cutoff > (s->sample_rate >> 1))
2226  s->cutoff = s->sample_rate >> 1;
2227 
2228  ret = ff_ac3_validate_metadata(s);
2229  if (ret)
2230  return ret;
2231 
2234 
2237 
2238  return 0;
2239 }
2240 
2241 
2242 /*
2243  * Set bandwidth for all channels.
2244  * The user can optionally supply a cutoff frequency. Otherwise an appropriate
2245  * default value will be used.
2246  */
2248 {
2249  int blk, ch, cpl_start;
2250 
2251  if (s->cutoff) {
2252  /* calculate bandwidth based on user-specified cutoff frequency */
2253  int fbw_coeffs;
2254  fbw_coeffs = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
2255  s->bandwidth_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
2256  } else {
2257  /* use default bandwidth setting */
2259  }
2260 
2261  /* set number of coefficients for each channel */
2262  for (ch = 1; ch <= s->fbw_channels; ch++) {
2263  s->start_freq[ch] = 0;
2264  for (blk = 0; blk < s->num_blocks; blk++)
2265  s->blocks[blk].end_freq[ch] = s->bandwidth_code * 3 + 73;
2266  }
2267  /* LFE channel always has 7 coefs */
2268  if (s->lfe_on) {
2269  s->start_freq[s->lfe_channel] = 0;
2270  for (blk = 0; blk < s->num_blocks; blk++)
2271  s->blocks[blk].end_freq[ch] = 7;
2272  }
2273 
2274  /* initialize coupling strategy */
2275  if (s->cpl_enabled) {
2276  if (s->options.cpl_start != AC3ENC_OPT_AUTO) {
2277  cpl_start = s->options.cpl_start;
2278  } else {
2280  if (cpl_start < 0) {
2282  s->cpl_enabled = 0;
2283  else
2284  cpl_start = 15;
2285  }
2286  }
2287  }
2288  if (s->cpl_enabled) {
2289  int i, cpl_start_band, cpl_end_band;
2290  uint8_t *cpl_band_sizes = s->cpl_band_sizes;
2291 
2292  cpl_end_band = s->bandwidth_code / 4 + 3;
2293  cpl_start_band = av_clip(cpl_start, 0, FFMIN(cpl_end_band-1, 15));
2294 
2295  s->num_cpl_subbands = cpl_end_band - cpl_start_band;
2296 
2297  s->num_cpl_bands = 1;
2298  *cpl_band_sizes = 12;
2299  for (i = cpl_start_band + 1; i < cpl_end_band; i++) {
2301  *cpl_band_sizes += 12;
2302  } else {
2303  s->num_cpl_bands++;
2304  cpl_band_sizes++;
2305  *cpl_band_sizes = 12;
2306  }
2307  }
2308 
2309  s->start_freq[CPL_CH] = cpl_start_band * 12 + 37;
2310  s->cpl_end_freq = cpl_end_band * 12 + 37;
2311  for (blk = 0; blk < s->num_blocks; blk++)
2312  s->blocks[blk].end_freq[CPL_CH] = s->cpl_end_freq;
2313  }
2314 }
2315 
2316 
2318 {
2319  AVCodecContext *avctx = s->avctx;
2320  int blk, ch;
2321  int channels = s->channels + 1; /* includes coupling channel */
2322  int channel_blocks = channels * s->num_blocks;
2323  int total_coefs = AC3_MAX_COEFS * channel_blocks;
2324 
2325  if (s->allocate_sample_buffers(s))
2326  goto alloc_fail;
2327 
2328  FF_ALLOC_OR_GOTO(avctx, s->bap_buffer, total_coefs *
2329  sizeof(*s->bap_buffer), alloc_fail);
2330  FF_ALLOC_OR_GOTO(avctx, s->bap1_buffer, total_coefs *
2331  sizeof(*s->bap1_buffer), alloc_fail);
2332  FF_ALLOCZ_OR_GOTO(avctx, s->mdct_coef_buffer, total_coefs *
2333  sizeof(*s->mdct_coef_buffer), alloc_fail);
2334  FF_ALLOC_OR_GOTO(avctx, s->exp_buffer, total_coefs *
2335  sizeof(*s->exp_buffer), alloc_fail);
2336  FF_ALLOC_OR_GOTO(avctx, s->grouped_exp_buffer, channel_blocks * 128 *
2337  sizeof(*s->grouped_exp_buffer), alloc_fail);
2338  FF_ALLOC_OR_GOTO(avctx, s->psd_buffer, total_coefs *
2339  sizeof(*s->psd_buffer), alloc_fail);
2340  FF_ALLOC_OR_GOTO(avctx, s->band_psd_buffer, channel_blocks * 64 *
2341  sizeof(*s->band_psd_buffer), alloc_fail);
2342  FF_ALLOC_OR_GOTO(avctx, s->mask_buffer, channel_blocks * 64 *
2343  sizeof(*s->mask_buffer), alloc_fail);
2344  FF_ALLOC_OR_GOTO(avctx, s->qmant_buffer, total_coefs *
2345  sizeof(*s->qmant_buffer), alloc_fail);
2346  if (s->cpl_enabled) {
2347  FF_ALLOC_OR_GOTO(avctx, s->cpl_coord_exp_buffer, channel_blocks * 16 *
2348  sizeof(*s->cpl_coord_exp_buffer), alloc_fail);
2349  FF_ALLOC_OR_GOTO(avctx, s->cpl_coord_mant_buffer, channel_blocks * 16 *
2350  sizeof(*s->cpl_coord_mant_buffer), alloc_fail);
2351  }
2352  for (blk = 0; blk < s->num_blocks; blk++) {
2353  AC3Block *block = &s->blocks[blk];
2354  FF_ALLOCZ_OR_GOTO(avctx, block->mdct_coef, channels * sizeof(*block->mdct_coef),
2355  alloc_fail);
2356  FF_ALLOCZ_OR_GOTO(avctx, block->exp, channels * sizeof(*block->exp),
2357  alloc_fail);
2358  FF_ALLOCZ_OR_GOTO(avctx, block->grouped_exp, channels * sizeof(*block->grouped_exp),
2359  alloc_fail);
2360  FF_ALLOCZ_OR_GOTO(avctx, block->psd, channels * sizeof(*block->psd),
2361  alloc_fail);
2362  FF_ALLOCZ_OR_GOTO(avctx, block->band_psd, channels * sizeof(*block->band_psd),
2363  alloc_fail);
2364  FF_ALLOCZ_OR_GOTO(avctx, block->mask, channels * sizeof(*block->mask),
2365  alloc_fail);
2366  FF_ALLOCZ_OR_GOTO(avctx, block->qmant, channels * sizeof(*block->qmant),
2367  alloc_fail);
2368  if (s->cpl_enabled) {
2369  FF_ALLOCZ_OR_GOTO(avctx, block->cpl_coord_exp, channels * sizeof(*block->cpl_coord_exp),
2370  alloc_fail);
2371  FF_ALLOCZ_OR_GOTO(avctx, block->cpl_coord_mant, channels * sizeof(*block->cpl_coord_mant),
2372  alloc_fail);
2373  }
2374 
2375  for (ch = 0; ch < channels; ch++) {
2376  /* arrangement: block, channel, coeff */
2377  block->grouped_exp[ch] = &s->grouped_exp_buffer[128 * (blk * channels + ch)];
2378  block->psd[ch] = &s->psd_buffer [AC3_MAX_COEFS * (blk * channels + ch)];
2379  block->band_psd[ch] = &s->band_psd_buffer [64 * (blk * channels + ch)];
2380  block->mask[ch] = &s->mask_buffer [64 * (blk * channels + ch)];
2381  block->qmant[ch] = &s->qmant_buffer [AC3_MAX_COEFS * (blk * channels + ch)];
2382  if (s->cpl_enabled) {
2383  block->cpl_coord_exp[ch] = &s->cpl_coord_exp_buffer [16 * (blk * channels + ch)];
2384  block->cpl_coord_mant[ch] = &s->cpl_coord_mant_buffer[16 * (blk * channels + ch)];
2385  }
2386 
2387  /* arrangement: channel, block, coeff */
2388  block->exp[ch] = &s->exp_buffer [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2389  block->mdct_coef[ch] = &s->mdct_coef_buffer [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2390  }
2391  }
2392 
2393  if (!s->fixed_point) {
2394  FF_ALLOCZ_OR_GOTO(avctx, s->fixed_coef_buffer, total_coefs *
2395  sizeof(*s->fixed_coef_buffer), alloc_fail);
2396  for (blk = 0; blk < s->num_blocks; blk++) {
2397  AC3Block *block = &s->blocks[blk];
2398  FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, channels *
2399  sizeof(*block->fixed_coef), alloc_fail);
2400  for (ch = 0; ch < channels; ch++)
2401  block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2402  }
2403  } else {
2404  for (blk = 0; blk < s->num_blocks; blk++) {
2405  AC3Block *block = &s->blocks[blk];
2406  FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, channels *
2407  sizeof(*block->fixed_coef), alloc_fail);
2408  for (ch = 0; ch < channels; ch++)
2409  block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch];
2410  }
2411  }
2412 
2413  return 0;
2414 alloc_fail:
2415  return AVERROR(ENOMEM);
2416 }
2417 
2418 
2420 {
2421  AC3EncodeContext *s = avctx->priv_data;
2422  int ret, frame_size_58;
2423 
2424  s->avctx = avctx;
2425 
2426  s->eac3 = avctx->codec_id == AV_CODEC_ID_EAC3;
2427 
2429 
2430  ret = validate_options(s);
2431  if (ret)
2432  return ret;
2433 
2434  avctx->frame_size = AC3_BLOCK_SIZE * s->num_blocks;
2435  avctx->delay = AC3_BLOCK_SIZE;
2436 
2437  s->bitstream_mode = avctx->audio_service_type;
2439  s->bitstream_mode = 0x7;
2440 
2441  s->bits_written = 0;
2442  s->samples_written = 0;
2443 
2444  /* calculate crc_inv for both possible frame sizes */
2445  frame_size_58 = (( s->frame_size >> 2) + ( s->frame_size >> 4)) << 1;
2446  s->crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
2447  if (s->bit_alloc.sr_code == 1) {
2448  frame_size_58 = (((s->frame_size+2) >> 2) + ((s->frame_size+2) >> 4)) << 1;
2449  s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
2450  }
2451 
2452  /* set function pointers */
2457  } else if (CONFIG_AC3_ENCODER || CONFIG_EAC3_ENCODER) {
2461  }
2462  if (CONFIG_EAC3_ENCODER && s->eac3)
2464  else
2466 
2467  set_bandwidth(s);
2468 
2469  exponent_init(s);
2470 
2471  bit_alloc_init(s);
2472 
2473  ret = s->mdct_init(s);
2474  if (ret)
2475  goto init_fail;
2476 
2477  ret = allocate_buffers(s);
2478  if (ret)
2479  goto init_fail;
2480 
2481  ff_dsputil_init(&s->dsp, avctx);
2484 
2485  dprint_options(s);
2486 
2487  return 0;
2488 init_fail:
2489  ff_ac3_encode_close(avctx);
2490  return ret;
2491 }
static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
Initialize mantissa counts.
Definition: ac3enc.c:994
uint8_t new_rematrixing_strategy
send new rematrixing flags in this block
Definition: ac3enc.h:140
Definition: start.py:1
uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]
exponent strategies
Definition: ac3enc.h:245
uint32_t poly
Definition: crc.c:217
int eac3_mixing_metadata
Definition: ac3enc.h:115
const uint8_t ff_ac3_bap_tab[64]
Definition: ac3tab.c:268
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2675
float v
const char * s
Definition: avisynth_c.h:668
#define AC3_MAX_CODED_FRAME_SIZE
Definition: ac3.h:30
int dialogue_level
Definition: ac3enc.h:95
void(* mdct_end)(struct AC3EncodeContext *s)
Definition: ac3enc.h:253
static av_cold int set_channel_info(AC3EncodeContext *s, int channels, uint64_t *channel_layout)
Definition: ac3enc.c:2059
static void ac3_output_frame_header(AC3EncodeContext *s)
Definition: ac3enc.c:1327
int db_per_bit_code
dB/bit code (dbpbcod)
Definition: ac3enc.h:220
static const uint8_t exp_strategy_reuse_tab[4][6]
Table used to select exponent strategy based on exponent reuse block interval.
Definition: ac3enc.c:345
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:275
int slow_decay_code
slow decay code (sdcycod)
Definition: ac3enc.h:218
Encoding Options used by AVOption.
Definition: ac3enc.h:93
const uint8_t ff_ac3_slow_decay_tab[4]
Definition: ac3tab.c:278
void(* update_bap_counts)(uint16_t mant_cnt[16], uint8_t *bap, int len)
Update bap counts using the supplied array of bap.
Definition: ac3dsp.h:117
int ff_ac3_fixed_allocate_sample_buffers(AC3EncodeContext *s)
float loro_surround_mix_level
Definition: ac3enc.h:110
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:172
static void compute_exp_strategy(AC3EncodeContext *s)
Definition: ac3enc.c:356
int channel_coupling
Definition: ac3enc.h:121
static int asym_quant(int c, int e, int qbits)
Asymmetric quantization on 2^qbits levels.
Definition: ac3enc.c:1180
int dolby_surround_ex_mode
Definition: ac3enc.h:112
static uint8_t exponent_group_tab[2][3][256]
LUT for number of exponent groups.
Definition: ac3enc.c:73
#define AV_CH_LAYOUT_SURROUND
uint8_t ** cpl_coord_exp
coupling coord exponents (cplcoexp)
Definition: ac3enc.h:137
#define AC3_MAX_COEFS
Definition: ac3.h:34
int bandwidth_code
bandwidth code (0 to 60) (chbwcod)
Definition: ac3enc.h:204
const uint16_t ff_ac3_frame_size_tab[38][3]
Possible frame sizes.
Definition: ac3tab.c:35
uint8_t * grouped_exp_buffer
Definition: ac3enc.h:237
static av_cold int allocate_buffers(AC3EncodeContext *s)
Definition: ac3enc.c:2317
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:154
av_cold void ff_ac3_common_init(void)
Initialize some tables.
Definition: ac3.c:220
#define LEVEL_PLUS_1POINT5DB
Definition: ac3.h:56
int16_t ** psd
psd per frequency bin
Definition: ac3enc.h:133
int frame_size_code
frame size code (frmsizecod)
Definition: ac3enc.h:182
int frame_bits
all frame bits except exponents and mantissas
Definition: ac3enc.h:227
#define av_bswap16
Definition: sh4/bswap.h:31
static void bit_alloc_init(AC3EncodeContext *s)
Definition: ac3enc.c:757
void ff_ac3_process_exponents(AC3EncodeContext *s)
Calculate final exponents from the supplied MDCT coefficients and exponent shift. ...
Definition: ac3enc.c:635
#define EXP_REUSE
Definition: ac3.h:47
const uint16_t ff_ac3_sample_rate_tab[3]
Definition: ac3tab.c:127
#define AV_CH_LAYOUT_4POINT0
uint8_t ** cpl_coord_mant
coupling coord mantissas (cplcomant)
Definition: ac3enc.h:138
uint16_t ** qmant
quantized mantissas
Definition: ac3enc.h:136
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
int start_freq[AC3_MAX_CHANNELS]
start frequency bin (strtmant)
Definition: ac3enc.h:205
#define AV_CH_LAYOUT_STEREO
const uint16_t ff_ac3_slow_gain_tab[4]
Definition: ac3tab.c:286
PutBitContext pb
bitstream writer context
Definition: ac3enc.h:161
#define blk(i)
Definition: sha.c:169
#define EXP_D25
Definition: ac3.h:51
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
static const float cmixlev_options[CMIXLEV_NUM_OPTIONS]
Definition: ac3enc.c:53
int(* mdct_init)(struct AC3EncodeContext *s)
Definition: ac3enc.h:254
int num_cpl_channels
number of channels in coupling
Definition: ac3enc.h:146
AC3BitAllocParameters bit_alloc
bit allocation parameters
Definition: ac3enc.h:222
#define AV_CH_LAYOUT_5POINT0
static int count_exponent_bits(AC3EncodeContext *s)
Definition: ac3enc.c:545
static void extract_exponents(AC3EncodeContext *s)
Definition: ac3enc.c:326
int ff_ac3_float_allocate_sample_buffers(AC3EncodeContext *s)
DSPContext dsp
Definition: ac3enc.h:162
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
int ff_ac3_validate_metadata(AC3EncodeContext *s)
Validate metadata options as set by AVOption system.
Definition: ac3enc.c:1831
initialize output if(nPeaks >3)%at least 3 peaks in spectrum for trying to find f0 nf0peaks
float ltrt_surround_mix_level
Definition: ac3enc.h:108
int new_cpl_leak
send new coupling leak info
Definition: ac3enc.h:150
int rematrixing_enabled
stereo rematrixing enabled
Definition: ac3enc.h:214
void ff_eac3_get_frame_exp_strategy(AC3EncodeContext *s)
Determine frame exponent strategy use and indices.
Definition: eac3enc.c:66
void(* extract_exponents)(uint8_t *exp, int32_t *coef, int nb_coefs)
Definition: ac3dsp.h:127
int channel_mode
channel mode (acmod)
Definition: ac3enc.h:193
int num_cpl_subbands
number of coupling subbands (ncplsubnd)
Definition: ac3enc.h:210
float surround_mix_level
Definition: ac3enc.h:98
enum AVSampleFormat sample_fmt
audio sample format
uint8_t
#define av_cold
Definition: attributes.h:78
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
static void count_frame_bits(AC3EncodeContext *s)
Definition: ac3enc.c:793
AVOptions.
window constants for m
static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS]
Definition: ac3enc.c:63
uint8_t rematrixing_flags[4]
rematrixing flags
Definition: ac3enc.h:142
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:261
#define EXP_D15
Definition: ac3.h:50
int fbw_channels
number of full-bandwidth channels (nfchans)
Definition: ac3enc.h:187
uint8_t new_cpl_coords[AC3_MAX_CHANNELS]
send new coupling coordinates (cplcoe)
Definition: ac3enc.h:147
static av_cold void set_bandwidth(AC3EncodeContext *s)
Definition: ac3enc.c:2247
#define b
Definition: input.c:42
end end
const uint8_t ff_ac3_enc_channel_map[8][2][6]
Table to remap channels from SMPTE order to AC-3 order.
Definition: ac3tab.c:110
#define emms_c()
av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
Finalize encoding and free any memory allocated by the encoder.
Definition: ac3enc.c:2015
uint8_t * bap1_buffer
Definition: ac3enc.h:233
#define AV_CH_LOW_FREQUENCY
int slow_gain_code
slow gain code (sgaincod)
Definition: ac3enc.h:217
uint8_t cpl_master_exp[AC3_MAX_CHANNELS]
coupling coord master exponents (mstrcplco)
Definition: ac3enc.h:148
#define CRC16_POLY
CRC-16 Polynomial.
Definition: ac3enc.c:1573
void(* bit_alloc_calc_bap)(int16_t *mask, int16_t *psd, int start, int end, int snr_offset, int floor, const uint8_t *bap_tab, uint8_t *bap)
Calculate bit allocation pointers.
Definition: ac3dsp.h:106
uint8_t ** exp
original exponents
Definition: ac3enc.h:131
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
int num_rematrixing_bands
number of rematrixing bands
Definition: ac3enc.h:141
static av_cold int validate_options(AC3EncodeContext *s)
Definition: ac3enc.c:2104
AC3DSPContext ac3dsp
AC-3 optimized functions.
Definition: ac3enc.h:164
int loro_center_mix_level
Lo/Ro center mix level code.
Definition: ac3enc.h:200
int num_cpl_bands
number of coupling bands (ncplbnd)
Definition: ac3enc.h:211
static int bit_alloc(AC3EncodeContext *s, int snr_offset)
Run the bit allocation with a given SNR offset.
Definition: ac3enc.c:1062
void ff_ac3_fixed_mdct_end(AC3EncodeContext *s)
static void dprint_options(AC3EncodeContext *s)
Definition: ac3enc.c:1674
int lfe_channel
channel index of the LFE channel
Definition: ac3enc.h:190
int mant2_cnt
Definition: ac3enc.c:49
int ref_bap_set
indicates if ref_bap pointers have been set
Definition: ac3enc.h:250
#define EXP_DIFF_THRESHOLD
Exponent Difference Threshold.
Definition: ac3enc.c:340
static av_cold void exponent_init(AC3EncodeContext *s)
Definition: ac3enc.c:304
static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef, uint8_t *exp, uint8_t *bap, int16_t *qmant, int start_freq, int end_freq)
Quantize a set of mantissas for a single channel in a single block.
Definition: ac3enc.c:1204
int new_snr_offsets
send new SNR offsets
Definition: ac3enc.h:149
void(* output_frame_header)(struct AC3EncodeContext *s)
Definition: ac3enc.h:260
frame
Definition: stft.m:14
int loro_surround_mix_level
Lo/Ro surround mix level code.
Definition: ac3enc.h:201
CoefType ** mdct_coef
MDCT coefficients.
Definition: ac3enc.h:129
int16_t * qmant4_ptr
mantissa pointers for bap=1,2,4
Definition: ac3enc.c:48
#define AV_CH_LAYOUT_5POINT1
uint8_t channel_in_cpl[AC3_MAX_CHANNELS]
channel in coupling (chincpl)
Definition: ac3enc.h:145
int16_t * qmant1_ptr
Definition: ac3enc.c:48
int eac3_info_metadata
Definition: ac3enc.h:116
int mixing_level
Definition: ac3enc.h:101
#define AC3ENC_OPT_SMALL_ROOM
Definition: ac3enc.h:83
int num_blks_code
number of blocks code (numblkscod)
Definition: ac3enc.h:178
struct AC3Mant AC3Mant
const uint64_t ff_ac3_channel_layouts[19]
List of supported channel layouts.
Definition: ac3enc.c:79
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:199
static int sym_quant(int c, int e, int levels)
Symmetric quantization on &#39;levels&#39; levels.
Definition: ac3enc.c:1164
const uint8_t ff_ac3_fast_decay_tab[4]
Definition: ac3tab.c:282
AC3EncOptions options
encoding options
Definition: ac3enc.h:159
int16_t ** band_psd
psd per critical band
Definition: ac3enc.h:134
float ltrt_center_mix_level
Definition: ac3enc.h:107
static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy, int cpl)
Update the exponents so that they are the ones the decoder will decode.
Definition: ac3enc.c:422
int channels
total number of channels (nchans)
Definition: ac3enc.h:188
const char * r
Definition: vf_curves.c:94
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:31
int flags
CODEC_FLAG_*.
int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd, int start, int end, int fast_gain, int is_lfe, int dba_mode, int dba_nsegs, uint8_t *dba_offsets, uint8_t *dba_lengths, uint8_t *dba_values, int16_t *mask)
Calculate the masking curve.
Definition: ac3.c:123
uint8_t * buf
Definition: put_bits.h:44
uint16_t crc_inv[2]
Definition: ac3enc.h:183
int cpl_on
coupling turned on for this frame
Definition: ac3enc.h:208
simple assert() macros that are a bit more flexible than ISO C assert().
#define AV_CH_LAYOUT_QUAD
int16_t * mask_buffer
Definition: ac3enc.h:240
#define CONFIG_AC3_ENCODER
Definition: config.h:1091
int16_t * psd_buffer
Definition: ac3enc.h:238
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
int fixed_point
indicates if fixed-point encoder is being used
Definition: ac3enc.h:170
int ltrt_surround_mix_level
Lt/Rt surround mix level code.
Definition: ac3enc.h:199
int new_cpl_strategy
send new coupling strategy
Definition: ac3enc.h:143
int surround_mix_level
surround mix level code
Definition: ac3enc.h:197
static void put_bits(J2kEncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:160
#define LEVEL_MINUS_3DB
Definition: ac3.h:58
int cpl_in_use
coupling in use for this block (cplinu)
Definition: ac3enc.h:144
external API header
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:82
int cpl_enabled
coupling enabled for all frames
Definition: ac3enc.h:209
static void output_frame_end(AC3EncodeContext *s)
Definition: ac3enc.c:1610
#define EXTMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:62
Definition: ac3enc.c:47
uint64_t channel_layout
Audio channel layout.
#define LEVEL_MINUS_4POINT5DB
Definition: ac3.h:59
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:73
#define AC3_BLOCK_SIZE
Definition: ac3.h:35
static void output_audio_block(AC3EncodeContext *s, int blk)
Definition: ac3enc.c:1383
const uint16_t ff_ac3_bitrate_tab[19]
Definition: ac3tab.c:130
static int count_mantissa_bits(AC3EncodeContext *s)
Definition: ac3enc.c:1036
#define AV_CH_LAYOUT_2_1
#define AV_CH_LAYOUT_2_2
Data for a single audio block.
Definition: ac3enc.h:128
#define AC3ENC_OPT_ON
Definition: ac3enc.h:76
common internal API header
int floor_code
floor code (floorcod)
Definition: ac3enc.h:221
int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
Definition: ac3enc.c:1144
#define AC3ENC_OPT_DOWNMIX_LORO
Definition: ac3enc.h:85
int bitstream_mode
bitstream mode (bsmod)
Definition: ac3enc.h:173
#define AC3ENC_OPT_ADCONV_STANDARD
Definition: ac3enc.h:86
int has_surround
indicates if there are one or more surround channels
Definition: ac3enc.h:192
int bit_rate
the average bitrate
audio channel layout utility functions
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FFMIN(a, b)
Definition: common.h:58
int eac3
indicates if this is E-AC-3 vs. AC-3
Definition: ac3enc.h:171
static const uint8_t ac3_bandwidth_tab[5][3][19]
LUT to select the bandwidth code based on the bit rate, sample rate, and number of full-bandwidth cha...
Definition: ac3enc.c:107
float loro_center_mix_level
Definition: ac3enc.h:109
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:242
ret
Definition: avfilter.c:821
int mant4_cnt
mantissa counts for bap=1,2,4
Definition: ac3enc.c:49
int ff_ac3_float_mdct_init(AC3EncodeContext *s)
Initialize MDCT tables.
Definition: ac3enc_float.c:68
int32_t
const uint16_t ff_ac3_fast_gain_tab[8]
Definition: ac3tab.c:298
int ad_converter_type
Definition: ac3enc.h:114
void ff_eac3_exponent_init(void)
Initialize E-AC-3 exponent tables.
Definition: eac3enc.c:50
void ff_ac3_adjust_frame_size(AC3EncodeContext *s)
Adjust the frame size to make the average bit rate match the target bit rate.
Definition: ac3enc.c:181
#define AC3ENC_OPT_AUTO
Definition: ac3enc.h:74
#define diff(a, as, b, bs)
Definition: vf_phase.c:80
int exponent_bits
number of bits used for exponents
Definition: ac3enc.h:228
int stereo_rematrixing
Definition: ac3enc.h:120
#define AV_CH_LAYOUT_5POINT1_BACK
int coarse_snr_offset
coarse SNR offsets (csnroffst)
Definition: ac3enc.h:223
Definition: ac3.h:69
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:47
int16_t ** mask
masking curve
Definition: ac3enc.h:135
AVFloatDSPContext fdsp
Definition: ac3enc.h:163
SampleType ** planar_samples
Definition: ac3enc.h:231
int fast_decay_code
fast decay code (fdcycod)
Definition: ac3enc.h:219
int16_t * qmant_buffer
Definition: ac3enc.h:241
for k
int frame_size
Number of samples per channel in an audio frame.
#define AC3ENC_OPT_MODE_OFF
Definition: ac3enc.h:79
1i.*Xphase exp()
NULL
Definition: eval.c:55
#define AC3ENC_OPT_ADCONV_HDCD
Definition: ac3enc.h:87
#define CPL_CH
coupling channel index
Definition: ac3.h:32
const uint8_t ff_eac3_default_cpl_band_struct[18]
Table E2.16 Default Coupling Banding Structure.
Definition: ac3tab.c:144
uint8_t * ref_bap[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]
bit allocation pointers (bap)
Definition: ac3enc.h:249
void ff_eac3_output_frame_header(AC3EncodeContext *s)
Write the E-AC-3 frame header to the output bitstream.
Definition: eac3enc.c:126
int audio_production_info
Definition: ac3enc.h:100
enum AVCodecID codec_id
int sample_rate
samples per second
int dolby_surround_mode
Definition: ac3enc.h:99
static const int8_t ac3_coupling_start_tab[6][3][19]
LUT to select the coupling start band based on the bit rate, sample rate, and number of full-bandwidt...
Definition: ac3enc.c:140
main external API structure.
int fast_gain_code[AC3_MAX_CHANNELS]
fast gain codes (signal-to-mask ratio) (fgaincod)
Definition: ac3enc.h:224
int sample_rate
sampling frequency, in Hz
Definition: ac3enc.h:176
CoefType * mdct_coef_buffer
Definition: ac3enc.h:234
#define LEVEL_ZERO
Definition: ac3.h:62
#define LEVEL_ONE
Definition: ac3.h:63
int has_center
indicates if there is a center channel
Definition: ac3enc.h:191
int bit_rate
target bit rate, in bits-per-second
Definition: ac3enc.h:175
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
Definition: ac3enc.c:1576
int(* allocate_sample_buffers)(struct AC3EncodeContext *s)
Definition: ac3enc.h:257
const uint8_t * channel_map
channel map used to reorder channels
Definition: ac3enc.h:194
uint8_t * exp_buffer
Definition: ac3enc.h:236
int frame_bits_fixed
number of non-coefficient bits for fixed parameters
Definition: ac3enc.h:226
int end_freq[AC3_MAX_CHANNELS]
end frequency bin (endmant)
Definition: ac3enc.h:151
#define FLT_OPTION_THRESHOLD
Definition: ac3enc.c:1789
int(* compute_mantissa_size)(uint16_t mant_cnt[6][16])
Calculate the number of bits needed to encode a set of mantissas.
Definition: ac3dsp.h:125
static int validate_float_option(float v, const float *v_list, int v_list_size)
Definition: ac3enc.c:1791
synthesis window for stochastic i
#define AV_WB16(p, darg)
Definition: intreadwrite.h:237
int cpl_start
Definition: ac3enc.h:122
uint8_t * cpl_coord_exp_buffer
Definition: ac3enc.h:242
int ltrt_center_mix_level
Lt/Rt center mix level code.
Definition: ac3enc.h:198
#define AV_CH_LAYOUT_5POINT0_BACK
int center_mix_level
center mix level code
Definition: ac3enc.h:196
#define AC3_MAX_BLOCKS
Definition: ac3.h:36
AC-3 encoder private context.
Definition: ac3enc.h:157
void ff_ac3_output_frame(AC3EncodeContext *s, unsigned char *frame)
Write the frame to the output bitstream.
Definition: ac3enc.c:1659
static void count_frame_bits_fixed(AC3EncodeContext *s)
Definition: ac3enc.c:651
#define snprintf
Definition: snprintf.h:34
AC3Block blocks[AC3_MAX_BLOCKS]
per-block info
Definition: ac3enc.h:168
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:294
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Buffer references ownership and permissions
SampleType * windowed_samples
Definition: ac3enc.h:230
int mant1_cnt
Definition: ac3enc.c:49
int preferred_stereo_downmix
Definition: ac3enc.h:106
void ff_ac3_quantize_mantissas(AC3EncodeContext *s)
Quantize mantissas using coefficients, exponents, and bit allocation pointers.
Definition: ac3enc.c:1298
void(* ac3_exponent_min)(uint8_t *exp, int num_reuse_blocks, int nb_coefs)
Set each encoded exponent in a block to the minimum of itself and the exponents in the same frequency...
Definition: ac3dsp.h:43
int num_blocks
number of blocks per frame
Definition: ac3enc.h:179
static void encode_exponents(AC3EncodeContext *s)
Definition: ac3enc.c:495
static int flags
Definition: cpu.c:23
#define CMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:52
float center_mix_level
Definition: ac3enc.h:97
#define EXP_NEW
Definition: ac3.h:48
static void reset_block_bap(AC3EncodeContext *s)
Definition: ac3enc.c:969
int extended_bsi_2
Definition: ac3enc.h:111
#define AC3_FRAME_SIZE
Definition: ac3.h:37
int frame_size
current frame size in bytes
Definition: ac3enc.h:181
#define SURMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:57
int room_type
Definition: ac3enc.h:102
#define CONFIG_AC3_FIXED_ENCODER
Definition: config.h:1092
uint8_t ** grouped_exp
grouped exponents
Definition: ac3enc.h:132
int cpl_end_freq
coupling channel end frequency bin
Definition: ac3enc.h:206
#define AC3ENC_OPT_LARGE_ROOM
Definition: ac3enc.h:82
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3enc.h:212
#define AC3ENC_OPT_MODE_ON
Definition: ac3enc.h:78
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:81
static void validate_mix_level(void *log_ctx, const char *opt_name, float *opt_param, const float *list, int list_size, int default_value, int min_value, int *ctx_param)
Definition: ac3enc.c:1807
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
static double c[64]
me_cmp_func sad[6]
Definition: dsputil.h:151
static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS]
Definition: ac3enc.c:58
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:54
int64_t bits_written
bit count (used to avg. bitrate)
Definition: ac3enc.h:184
uint32_t AVCRC
Definition: crc.h:28
#define AC3ENC_OPT_NONE
Definition: ac3enc.h:73
int bitstream_id
bitstream id (bsid)
Definition: ac3enc.h:172
int16_t * band_psd_buffer
Definition: ac3enc.h:239
int dolby_headphone_mode
Definition: ac3enc.h:113
AVCodecContext * avctx
parent AVCodecContext
Definition: ac3enc.h:160
uint8_t exp_ref_block[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]
reference blocks for EXP_REUSE
Definition: ac3enc.h:248
int cutoff
Audio cutoff bandwidth (0 means "automatic")
int allow_per_frame_metadata
Definition: ac3enc.h:119
void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd, int16_t *band_psd)
Calculate the log power-spectral density of the input signal.
Definition: ac3.c:97
static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch, uint16_t mant_cnt[AC3_MAX_BLOCKS][16], int start, int end)
Update mantissa bit counts for all blocks in 1 channel in a given bandwidth range.
Definition: ac3enc.c:1016
int original
Definition: ac3enc.h:104
#define LEVEL_PLUS_3DB
Definition: ac3.h:55
#define AC3ENC_OPT_DOWNMIX_LTRT
Definition: ac3enc.h:84
int channels
number of audio channels
#define AC3ENC_OPT_NOT_INDICATED
Definition: ac3enc.h:77
static int cbr_bit_allocation(AC3EncodeContext *s)
Definition: ac3enc.c:1093
uint8_t * bap_buffer
Definition: ac3enc.h:232
int frame_size_min
minimum frame size in case rounding is necessary
Definition: ac3enc.h:180
#define LEVEL_MINUS_6DB
Definition: ac3.h:60
void ff_ac3_float_mdct_end(AC3EncodeContext *s)
Finalize MDCT and free allocated memory.
Definition: ac3enc_float.c:55
AC-3 encoder & E-AC-3 encoder common header.
static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
Definition: ac3enc.c:1593
#define LOCAL_ALIGNED_16(t, v,...)
void ff_ac3_apply_rematrixing(AC3EncodeContext *s)
Apply stereo rematrixing to coefficients based on rematrixing flags.
Definition: ac3enc.c:270
void INT64 start
Definition: avisynth_c.h:594
const uint8_t ff_ac3_rematrix_band_tab[5]
Table of bin locations for rematrixing bands reference: Section 7.5.2 Rematrixing : Frequency Band De...
Definition: ac3tab.c:139
int64_t samples_written
sample count (used to avg. bitrate)
Definition: ac3enc.h:185
uint8_t * cpl_coord_mant_buffer
Definition: ac3enc.h:243
int use_frame_exp_strategy
indicates use of frame exp strategy
Definition: ac3enc.h:247
#define FFSWAP(type, a, b)
Definition: common.h:61
static void bit_alloc_masking(AC3EncodeContext *s)
Definition: ac3enc.c:939
int ff_ac3_fixed_mdct_init(AC3EncodeContext *s)
void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int bit_exact)
Initialize a float DSP context.
Definition: float_dsp.c:118
void ff_ac3_group_exponents(AC3EncodeContext *s)
Group exponents.
Definition: ac3enc.c:577
const uint16_t ff_ac3_db_per_bit_tab[4]
Definition: ac3tab.c:290
int16_t * qmant2_ptr
Definition: ac3enc.c:48
#define CONFIG_EAC3_ENCODER
Definition: config.h:1095
#define AV_CH_LAYOUT_MONO
void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
Set the initial coupling strategy parameters prior to coupling analysis.
Definition: ac3enc.c:199
int cutoff
user-specified cutoff frequency, in Hz
Definition: ac3enc.h:203
E-AC-3 encoder.
int lfe_on
indicates if there is an LFE channel (lfeon)
Definition: ac3enc.h:189
int fine_snr_offset[AC3_MAX_CHANNELS]
fine SNR offsets (fsnroffst)
Definition: ac3enc.h:225
#define AC3ENC_OPT_OFF
Definition: ac3enc.h:75
int delay
Codec delay.
Common code between the AC-3 encoder and decoder.
int32_t * fixed_coef_buffer
Definition: ac3enc.h:235
#define EXP_D45
Definition: ac3.h:52
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
int extended_bsi_1
Definition: ac3enc.h:105
int copyright
Definition: ac3enc.h:103
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
int32_t ** fixed_coef
fixed-point MDCT coefficients
Definition: ac3enc.h:130
av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
Definition: ac3enc.c:2419
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
bitstream writer API