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