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