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"
34 #include "libavutil/channel_layout.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] = {
56  LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB
57 };
58 
59 #define SURMIXLEV_NUM_OPTIONS 3
60 static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = {
61  LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO
62 };
63 
64 #define EXTMIXLEV_NUM_OPTIONS 8
65 static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = {
66  LEVEL_PLUS_3DB, LEVEL_PLUS_1POINT5DB, LEVEL_ONE, LEVEL_MINUS_1POINT5DB,
67  LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB, LEVEL_ZERO
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] = {
82  AV_CH_LAYOUT_MONO,
83  AV_CH_LAYOUT_STEREO,
84  AV_CH_LAYOUT_2_1,
85  AV_CH_LAYOUT_SURROUND,
86  AV_CH_LAYOUT_2_2,
87  AV_CH_LAYOUT_QUAD,
88  AV_CH_LAYOUT_4POINT0,
89  AV_CH_LAYOUT_5POINT0,
90  AV_CH_LAYOUT_5POINT0_BACK,
91  (AV_CH_LAYOUT_MONO | AV_CH_LOW_FREQUENCY),
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),
98  AV_CH_LAYOUT_5POINT1,
99  AV_CH_LAYOUT_5POINT1_BACK,
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  */
183 void ff_ac3_adjust_frame_size(AC3EncodeContext *s)
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;
192  s->samples_written += AC3_BLOCK_SIZE * s->num_blocks;
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  */
201 void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
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  */
272 void ff_ac3_apply_rematrixing(AC3EncodeContext *s)
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  */
306 static av_cold void exponent_init(AC3EncodeContext *s)
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)
321  ff_eac3_exponent_init();
322 }
323 
324 
325 /*
326  * Extract exponents from the MDCT coefficients.
327  */
328 static void extract_exponents(AC3EncodeContext *s)
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  */
358 static void compute_exp_strategy(AC3EncodeContext *s)
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)
412  ff_eac3_get_frame_exp_strategy(s);
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  */
497 static void encode_exponents(AC3EncodeContext *s)
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  */
547 static int count_exponent_bits(AC3EncodeContext *s)
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  */
579 void ff_ac3_group_exponents(AC3EncodeContext *s)
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  */
637 void ff_ac3_process_exponents(AC3EncodeContext *s)
638 {
639  extract_exponents(s);
640 
641  compute_exp_strategy(s);
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  */
653 static void count_frame_bits_fixed(AC3EncodeContext *s)
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  */
759 static av_cold void bit_alloc_init(AC3EncodeContext *s)
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 */
778  s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->bit_alloc.sr_shift;
779  s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->bit_alloc.sr_shift;
780  s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code];
781  s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
782  s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code];
783  s->bit_alloc.cpl_fast_leak = 0;
784  s->bit_alloc.cpl_slow_leak = 0;
785 
786  count_frame_bits_fixed(s);
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  */
795 static void count_frame_bits(AC3EncodeContext *s)
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) {
804  if (s->channel_mode > AC3_CHMODE_STEREO)
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;
812  if (s->channel_mode < AC3_CHMODE_STEREO)
813  frame_bits++;
814  frame_bits++;
815  }
816  if (opt->eac3_info_metadata) {
817  frame_bits += 3 + 1 + 1;
818  if (s->channel_mode == AC3_CHMODE_STEREO)
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;
872  if (s->channel_mode == AC3_CHMODE_STEREO)
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  */
941 static void bit_alloc_masking(AC3EncodeContext *s)
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]);
955  ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch],
956  s->start_freq[ch], block->end_freq[ch],
957  ff_ac3_fast_gain_tab[s->fast_gain_code[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  */
971 static void reset_block_bap(AC3EncodeContext *s)
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  */
1018 static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch,
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  */
1038 static int count_mantissa_bits(AC3EncodeContext *s)
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  */
1095 static int cbr_bit_allocation(AC3EncodeContext *s)
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  */
1146 int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
1147 {
1148  count_frame_bits(s);
1149 
1150  s->exponent_bits = count_exponent_bits(s);
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  */
1300 void ff_ac3_quantize_mantissas(AC3EncodeContext *s)
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  */
1329 static void ac3_output_frame_header(AC3EncodeContext *s)
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  */
1385 static void output_audio_block(AC3EncodeContext *s, int blk)
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++)
1434  put_bits(&s->pb, 1, ff_eac3_default_cpl_band_struct[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  */
1612 static void output_frame_end(AC3EncodeContext *s)
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  */
1661 void ff_ac3_output_frame(AC3EncodeContext *s, unsigned char *frame)
1662 {
1663  int blk;
1664 
1665  init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);
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 
1676 static void dprint_options(AC3EncodeContext *s)
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",
1751  opt->ltrt_center_mix_level, s->ltrt_center_mix_level);
1752  ff_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n",
1753  opt->ltrt_surround_mix_level, s->ltrt_surround_mix_level);
1754  ff_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n",
1755  opt->loro_center_mix_level, s->loro_center_mix_level);
1756  ff_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n",
1757  opt->loro_surround_mix_level, s->loro_surround_mix_level);
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  */
1833 int ff_ac3_validate_metadata(AC3EncodeContext *s)
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 */
1845  if (s->channel_mode > AC3_CHMODE_STEREO && opt->preferred_stereo_downmix != AC3ENC_OPT_NONE) {
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 */
1862  if (avctx->audio_service_type != AV_AUDIO_SERVICE_TYPE_MAIN)
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 &&
1867  (opt->dolby_headphone_mode != AC3ENC_OPT_NONE || opt->dolby_surround_mode != AC3ENC_OPT_NONE))
1868  opt->eac3_info_metadata = 1;
1869  if (s->channel_mode >= AC3_CHMODE_2F2R && opt->dolby_surround_ex_mode != AC3ENC_OPT_NONE)
1870  opt->eac3_info_metadata = 1;
1871  if (opt->mixing_level != AC3ENC_OPT_NONE || opt->room_type != AC3ENC_OPT_NONE ||
1872  opt->ad_converter_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 */
1882  if (s->channel_mode >= AC3_CHMODE_2F2R && opt->dolby_surround_ex_mode != AC3ENC_OPT_NONE)
1883  opt->extended_bsi_2 = 1;
1884  if (s->channel_mode == AC3_CHMODE_STEREO && opt->dolby_headphone_mode != AC3ENC_OPT_NONE)
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,
1894  cmixlev_options, CMIXLEV_NUM_OPTIONS, 1, 0,
1895  &s->center_mix_level);
1896  }
1897  if (s->has_surround) {
1898  validate_mix_level(avctx, "surround_mix_level", &opt->surround_mix_level,
1899  surmixlev_options, SURMIXLEV_NUM_OPTIONS, 1, 0,
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 */
1907  if (opt->preferred_stereo_downmix == AC3ENC_OPT_NONE)
1908  opt->preferred_stereo_downmix = AC3ENC_OPT_NOT_INDICATED;
1909  if (!s->eac3 || s->has_center) {
1910  /* validate Lt/Rt center mix level */
1911  validate_mix_level(avctx, "ltrt_center_mix_level",
1912  &opt->ltrt_center_mix_level, extmixlev_options,
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",
1917  &opt->loro_center_mix_level, extmixlev_options,
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",
1924  &opt->ltrt_surround_mix_level, extmixlev_options,
1925  EXTMIXLEV_NUM_OPTIONS, 6, 3,
1926  &s->ltrt_surround_mix_level);
1927  /* validate Lo/Ro surround mix level */
1928  validate_mix_level(avctx, "loro_surround_mix_level",
1929  &opt->loro_surround_mix_level, extmixlev_options,
1930  EXTMIXLEV_NUM_OPTIONS, 6, 3,
1931  &s->loro_surround_mix_level);
1932  }
1933  }
1934 
1935  /* validate audio service type / channels combination */
1936  if ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_KARAOKE &&
1937  avctx->channels == 1) ||
1938  ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_COMMENTARY ||
1939  avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_EMERGENCY ||
1940  avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_VOICE_OVER)
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 */
1950  if (opt->dolby_headphone_mode == AC3ENC_OPT_NONE)
1951  opt->dolby_headphone_mode = AC3ENC_OPT_NOT_INDICATED;
1952  /* default dolby surround ex mode */
1953  if (opt->dolby_surround_ex_mode == AC3ENC_OPT_NONE)
1954  opt->dolby_surround_ex_mode = AC3ENC_OPT_NOT_INDICATED;
1955  /* default A/D converter type */
1956  if (opt->ad_converter_type == AC3ENC_OPT_NONE)
1957  opt->ad_converter_type = AC3ENC_OPT_ADCONV_STANDARD;
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) {
1972  if (opt->dolby_surround_mode == AC3ENC_OPT_NONE)
1973  opt->dolby_surround_mode = AC3ENC_OPT_NOT_INDICATED;
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)
1990  opt->room_type = AC3ENC_OPT_NOT_INDICATED;
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  if (!s->warned_alternate_bitstream) {
1997  av_log(avctx, AV_LOG_WARNING, "alternate bitstream syntax is "
1998  "not compatible with reduced samplerates. writing of "
1999  "extended bitstream information will be disabled.\n");
2000  s->warned_alternate_bitstream = 1;
2001  }
2002  } else {
2003  s->bitstream_id = 6;
2004  }
2005  }
2006 
2007  return 0;
2008 }
2009 
2010 
2011 /**
2012  * Finalize encoding and free any memory allocated by the encoder.
2013  *
2014  * @param avctx Codec context
2015  */
2016 av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
2017 {
2018  int blk, ch;
2019  AC3EncodeContext *s = avctx->priv_data;
2020 
2021  av_freep(&s->windowed_samples);
2022  if (s->planar_samples)
2023  for (ch = 0; ch < s->channels; ch++)
2024  av_freep(&s->planar_samples[ch]);
2025  av_freep(&s->planar_samples);
2026  av_freep(&s->bap_buffer);
2027  av_freep(&s->bap1_buffer);
2028  av_freep(&s->mdct_coef_buffer);
2029  av_freep(&s->fixed_coef_buffer);
2030  av_freep(&s->exp_buffer);
2031  av_freep(&s->grouped_exp_buffer);
2032  av_freep(&s->psd_buffer);
2033  av_freep(&s->band_psd_buffer);
2034  av_freep(&s->mask_buffer);
2035  av_freep(&s->qmant_buffer);
2036  av_freep(&s->cpl_coord_exp_buffer);
2037  av_freep(&s->cpl_coord_mant_buffer);
2038  av_freep(&s->fdsp);
2039  for (blk = 0; blk < s->num_blocks; blk++) {
2040  AC3Block *block = &s->blocks[blk];
2041  av_freep(&block->mdct_coef);
2042  av_freep(&block->fixed_coef);
2043  av_freep(&block->exp);
2044  av_freep(&block->grouped_exp);
2045  av_freep(&block->psd);
2046  av_freep(&block->band_psd);
2047  av_freep(&block->mask);
2048  av_freep(&block->qmant);
2049  av_freep(&block->cpl_coord_exp);
2050  av_freep(&block->cpl_coord_mant);
2051  }
2052 
2053  if (s->mdct_end)
2054  s->mdct_end(s);
2055 
2056  return 0;
2057 }
2058 
2059 
2060 /*
2061  * Set channel information during initialization.
2062  */
2063 static av_cold int set_channel_info(AC3EncodeContext *s, int channels,
2064  uint64_t *channel_layout)
2065 {
2066  int ch_layout;
2067 
2068  if (channels < 1 || channels > AC3_MAX_CHANNELS)
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) {
2084  case AV_CH_LAYOUT_MONO: s->channel_mode = AC3_CHMODE_MONO; break;
2085  case AV_CH_LAYOUT_STEREO: s->channel_mode = AC3_CHMODE_STEREO; break;
2086  case AV_CH_LAYOUT_SURROUND: s->channel_mode = AC3_CHMODE_3F; break;
2087  case AV_CH_LAYOUT_2_1: s->channel_mode = AC3_CHMODE_2F1R; break;
2088  case AV_CH_LAYOUT_4POINT0: s->channel_mode = AC3_CHMODE_3F1R; 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:
2092  case AV_CH_LAYOUT_5POINT0_BACK: s->channel_mode = AC3_CHMODE_3F2R; break;
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 
2099  s->channel_map = ff_ac3_enc_channel_map[s->channel_mode][s->lfe_on];
2100  *channel_layout = ch_layout;
2101  if (s->lfe_on)
2102  *channel_layout |= AV_CH_LOW_FREQUENCY;
2103 
2104  return 0;
2105 }
2106 
2107 
2108 static av_cold int validate_options(AC3EncodeContext *s)
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;
2218  s->frame_size_min = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
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 
2238  s->rematrixing_enabled = s->options.stereo_rematrixing &&
2239  (s->channel_mode == AC3_CHMODE_STEREO);
2240 
2241  s->cpl_enabled = s->options.channel_coupling &&
2242  s->channel_mode >= AC3_CHMODE_STEREO;
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  */
2253 static av_cold void set_bandwidth(AC3EncodeContext *s)
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 */
2264  s->bandwidth_code = ac3_bandwidth_tab[s->fbw_channels-1][s->bit_alloc.sr_code][s->frame_size_code/2];
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 {
2285  cpl_start = ac3_coupling_start_tab[s->channel_mode-2][s->bit_alloc.sr_code][s->frame_size_code/2];
2286  if (cpl_start < 0) {
2287  if (s->options.channel_coupling == AC3ENC_OPT_AUTO)
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++) {
2306  if (ff_eac3_default_cpl_band_struct[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 
2323 static av_cold int allocate_buffers(AC3EncodeContext *s)
2324 {
2325  int blk, ch;
2326  int channels = s->channels + 1; /* includes coupling channel */
2327  int channel_blocks = channels * s->num_blocks;
2328  int total_coefs = AC3_MAX_COEFS * channel_blocks;
2329 
2330  if (s->allocate_sample_buffers(s))
2331  return AVERROR(ENOMEM);
2332 
2333  if (!FF_ALLOC_TYPED_ARRAY(s->bap_buffer, total_coefs) ||
2334  !FF_ALLOC_TYPED_ARRAY(s->bap1_buffer, total_coefs) ||
2335  !FF_ALLOCZ_TYPED_ARRAY(s->mdct_coef_buffer, total_coefs) ||
2336  !FF_ALLOC_TYPED_ARRAY(s->exp_buffer, total_coefs) ||
2337  !FF_ALLOC_TYPED_ARRAY(s->grouped_exp_buffer, channel_blocks * 128) ||
2338  !FF_ALLOC_TYPED_ARRAY(s->psd_buffer, total_coefs) ||
2339  !FF_ALLOC_TYPED_ARRAY(s->band_psd_buffer, channel_blocks * 64) ||
2340  !FF_ALLOC_TYPED_ARRAY(s->mask_buffer, channel_blocks * 64) ||
2341  !FF_ALLOC_TYPED_ARRAY(s->qmant_buffer, total_coefs))
2342  return AVERROR(ENOMEM);
2343 
2344  if (s->cpl_enabled) {
2345  if (!FF_ALLOC_TYPED_ARRAY(s->cpl_coord_exp_buffer, channel_blocks * 16) ||
2346  !FF_ALLOC_TYPED_ARRAY(s->cpl_coord_mant_buffer, channel_blocks * 16))
2347  return AVERROR(ENOMEM);
2348  }
2349  for (blk = 0; blk < s->num_blocks; blk++) {
2350  AC3Block *block = &s->blocks[blk];
2351 
2352  if (!FF_ALLOCZ_TYPED_ARRAY(block->mdct_coef, channels) ||
2353  !FF_ALLOCZ_TYPED_ARRAY(block->exp, channels) ||
2354  !FF_ALLOCZ_TYPED_ARRAY(block->grouped_exp, channels) ||
2355  !FF_ALLOCZ_TYPED_ARRAY(block->psd, channels) ||
2356  !FF_ALLOCZ_TYPED_ARRAY(block->band_psd, channels) ||
2357  !FF_ALLOCZ_TYPED_ARRAY(block->mask, channels) ||
2358  !FF_ALLOCZ_TYPED_ARRAY(block->qmant, channels))
2359  return AVERROR(ENOMEM);
2360 
2361  if (s->cpl_enabled) {
2362  if (!FF_ALLOCZ_TYPED_ARRAY(block->cpl_coord_exp, channels) ||
2363  !FF_ALLOCZ_TYPED_ARRAY(block->cpl_coord_mant, channels))
2364  return AVERROR(ENOMEM);
2365  }
2366 
2367  for (ch = 0; ch < channels; ch++) {
2368  /* arrangement: block, channel, coeff */
2369  block->grouped_exp[ch] = &s->grouped_exp_buffer[128 * (blk * channels + ch)];
2370  block->psd[ch] = &s->psd_buffer [AC3_MAX_COEFS * (blk * channels + ch)];
2371  block->band_psd[ch] = &s->band_psd_buffer [64 * (blk * channels + ch)];
2372  block->mask[ch] = &s->mask_buffer [64 * (blk * channels + ch)];
2373  block->qmant[ch] = &s->qmant_buffer [AC3_MAX_COEFS * (blk * channels + ch)];
2374  if (s->cpl_enabled) {
2375  block->cpl_coord_exp[ch] = &s->cpl_coord_exp_buffer [16 * (blk * channels + ch)];
2376  block->cpl_coord_mant[ch] = &s->cpl_coord_mant_buffer[16 * (blk * channels + ch)];
2377  }
2378 
2379  /* arrangement: channel, block, coeff */
2380  block->exp[ch] = &s->exp_buffer [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2381  block->mdct_coef[ch] = &s->mdct_coef_buffer [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2382  }
2383  }
2384 
2385  if (!s->fixed_point) {
2386  if (!FF_ALLOCZ_TYPED_ARRAY(s->fixed_coef_buffer, total_coefs))
2387  return AVERROR(ENOMEM);
2388  for (blk = 0; blk < s->num_blocks; blk++) {
2389  AC3Block *block = &s->blocks[blk];
2390  if (!FF_ALLOCZ_TYPED_ARRAY(block->fixed_coef, channels))
2391  return AVERROR(ENOMEM);
2392  for (ch = 0; ch < channels; ch++)
2393  block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2394  }
2395  } else {
2396  for (blk = 0; blk < s->num_blocks; blk++) {
2397  AC3Block *block = &s->blocks[blk];
2398  if (!FF_ALLOCZ_TYPED_ARRAY(block->fixed_coef, channels))
2399  return AVERROR(ENOMEM);
2400  for (ch = 0; ch < channels; ch++)
2401  block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch];
2402  }
2403  }
2404 
2405  return 0;
2406 }
2407 
2408 
2409 av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
2410 {
2411  AC3EncodeContext *s = avctx->priv_data;
2412  int ret, frame_size_58;
2413 
2414  s->avctx = avctx;
2415 
2416  s->eac3 = avctx->codec_id == AV_CODEC_ID_EAC3;
2417 
2418  ret = validate_options(s);
2419  if (ret)
2420  return ret;
2421 
2422  avctx->frame_size = AC3_BLOCK_SIZE * s->num_blocks;
2423  avctx->initial_padding = AC3_BLOCK_SIZE;
2424 
2425  s->bitstream_mode = avctx->audio_service_type;
2426  if (s->bitstream_mode == AV_AUDIO_SERVICE_TYPE_KARAOKE)
2427  s->bitstream_mode = 0x7;
2428 
2429  s->bits_written = 0;
2430  s->samples_written = 0;
2431 
2432  /* calculate crc_inv for both possible frame sizes */
2433  frame_size_58 = (( s->frame_size >> 2) + ( s->frame_size >> 4)) << 1;
2434  s->crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
2435  if (s->bit_alloc.sr_code == 1) {
2436  frame_size_58 = (((s->frame_size+2) >> 2) + ((s->frame_size+2) >> 4)) << 1;
2437  s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
2438  }
2439 
2440  /* set function pointers */
2441  if (CONFIG_AC3_FIXED_ENCODER && s->fixed_point) {
2442  s->mdct_end = ff_ac3_fixed_mdct_end;
2443  s->mdct_init = ff_ac3_fixed_mdct_init;
2444  s->allocate_sample_buffers = ff_ac3_fixed_allocate_sample_buffers;
2445  } else if (CONFIG_AC3_ENCODER || CONFIG_EAC3_ENCODER) {
2446  s->mdct_end = ff_ac3_float_mdct_end;
2447  s->mdct_init = ff_ac3_float_mdct_init;
2448  s->allocate_sample_buffers = ff_ac3_float_allocate_sample_buffers;
2449  }
2450  if (CONFIG_EAC3_ENCODER && s->eac3)
2451  s->output_frame_header = ff_eac3_output_frame_header;
2452  else
2453  s->output_frame_header = ac3_output_frame_header;
2454 
2455  set_bandwidth(s);
2456 
2457  exponent_init(s);
2458 
2459  bit_alloc_init(s);
2460 
2461  ret = s->mdct_init(s);
2462  if (ret)
2463  return ret;
2464 
2465  ret = allocate_buffers(s);
2466  if (ret)
2467  return ret;
2468 
2469  ff_audiodsp_init(&s->adsp);
2470  ff_me_cmp_init(&s->mecc, avctx);
2471  ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
2472 
2473  dprint_options(s);
2474 
2475  return 0;
2476 }
count_mantissa_bits_init
static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
Initialize mantissa counts.
Definition: ac3enc.c:996
ff_me_cmp_init
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:1035
AC3Block::new_rematrixing_strategy
uint8_t new_rematrixing_strategy
send new rematrixing flags in this block
Definition: ac3enc.h:145
NULL
#define NULL
Definition: coverity.c:32
AC3EncodeContext::exp_strategy
uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]
exponent strategies
Definition: ac3enc.h:251
AC3EncOptions::eac3_mixing_metadata
int eac3_mixing_metadata
Definition: ac3enc.h:120
ff_ac3_bap_tab
const uint8_t ff_ac3_bap_tab[64]
Definition: ac3tab.c:270
AC3_MAX_CODED_FRAME_SIZE
#define AC3_MAX_CODED_FRAME_SIZE
Definition: ac3.h:30
AC3EncodeContext::fdsp
AVFloatDSPContext * fdsp
Definition: ac3enc.h:168
AC3EncOptions::dialogue_level
int dialogue_level
Definition: ac3enc.h:100
AC3EncodeContext::mdct_end
void(* mdct_end)(struct AC3EncodeContext *s)
Definition: ac3enc.h:261
set_channel_info
static av_cold int set_channel_info(AC3EncodeContext *s, int channels, uint64_t *channel_layout)
Definition: ac3enc.c:2063
ac3_output_frame_header
static void ac3_output_frame_header(AC3EncodeContext *s)
Definition: ac3enc.c:1329
AC3EncodeContext::db_per_bit_code
int db_per_bit_code
dB/bit code (dbpbcod)
Definition: ac3enc.h:226
exp_strategy_reuse_tab
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
AC3EncodeContext::slow_decay_code
int slow_decay_code
slow decay code (sdcycod)
Definition: ac3enc.h:224
AC3EncOptions
Encoding Options used by AVOption.
Definition: ac3enc.h:98
ff_ac3_slow_decay_tab
const uint8_t ff_ac3_slow_decay_tab[4]
Definition: ac3tab.c:280
AC3DSPContext::update_bap_counts
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
ff_ac3_fixed_allocate_sample_buffers
int ff_ac3_fixed_allocate_sample_buffers(AC3EncodeContext *s)
AC3EncOptions::loro_surround_mix_level
float loro_surround_mix_level
Definition: ac3enc.h:115
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:258
compute_exp_strategy
static void compute_exp_strategy(AC3EncodeContext *s)
Definition: ac3enc.c:358
AC3EncOptions::channel_coupling
int channel_coupling
Definition: ac3enc.h:126
ret
ret
Definition: filter_design.txt:187
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
asym_quant
static int asym_quant(int c, int e, int qbits)
Asymmetric quantization on 2^qbits levels.
Definition: ac3enc.c:1182
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
AC3EncOptions::dolby_surround_ex_mode
int dolby_surround_ex_mode
Definition: ac3enc.h:117
exponent_group_tab
static uint8_t exponent_group_tab[2][3][256]
LUT for number of exponent groups.
Definition: ac3enc.c:75
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
AV_CH_LAYOUT_SURROUND
#define AV_CH_LAYOUT_SURROUND
Definition: channel_layout.h:94
AC3Block::cpl_coord_exp
uint8_t ** cpl_coord_exp
coupling coord exponents (cplcoexp)
Definition: ac3enc.h:142
AC3_MAX_COEFS
#define AC3_MAX_COEFS
Definition: ac3.h:35
AC3EncodeContext::bandwidth_code
int bandwidth_code
bandwidth code (0 to 60) (chbwcod)
Definition: ac3enc.h:210
ff_ac3_frame_size_tab
const uint16_t ff_ac3_frame_size_tab[38][3]
Possible frame sizes.
Definition: ac3tab.c:37
AC3EncodeContext::grouped_exp_buffer
uint8_t * grouped_exp_buffer
Definition: ac3enc.h:243
allocate_buffers
static av_cold int allocate_buffers(AC3EncodeContext *s)
Definition: ac3enc.c:2323
LEVEL_PLUS_1POINT5DB
#define LEVEL_PLUS_1POINT5DB
Definition: ac3.h:105
AC3Block::psd
int16_t ** psd
psd per frequency bin
Definition: ac3enc.h:138
AC3EncodeContext::frame_size_code
int frame_size_code
frame size code (frmsizecod)
Definition: ac3enc.h:188
AC3EncodeContext::frame_bits
int frame_bits
all frame bits except exponents and mantissas
Definition: ac3enc.h:233
av_bswap16
#define av_bswap16
Definition: bswap.h:31
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:140
a
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
ff_ac3_process_exponents
void ff_ac3_process_exponents(AC3EncodeContext *s)
Calculate final exponents from the supplied MDCT coefficients and exponent shift. ...
Definition: ac3enc.c:637
EXP_REUSE
#define EXP_REUSE
Definition: ac3.h:48
AV_CH_LAYOUT_4POINT0
#define AV_CH_LAYOUT_4POINT0
Definition: channel_layout.h:96
AC3Block::cpl_coord_mant
uint8_t ** cpl_coord_mant
coupling coord mantissas (cplcomant)
Definition: ac3enc.h:143
AC3Block::qmant
uint16_t ** qmant
quantized mantissas
Definition: ac3enc.h:141
AC3EncodeContext::start_freq
int start_freq[AC3_MAX_CHANNELS]
start frequency bin (strtmant)
Definition: ac3enc.h:211
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
ff_ac3_slow_gain_tab
const uint16_t ff_ac3_slow_gain_tab[4]
Definition: ac3tab.c:288
AC3EncodeContext::pb
PutBitContext pb
bitstream writer context
Definition: ac3enc.h:166
blk
#define blk(i)
Definition: sha.c:185
EXP_D25
#define EXP_D25
Definition: ac3.h:52
cmixlev_options
static const float cmixlev_options[CMIXLEV_NUM_OPTIONS]
Definition: ac3enc.c:55
AC3EncodeContext::mdct_init
int(* mdct_init)(struct AC3EncodeContext *s)
Definition: ac3enc.h:262
AC3Block::num_cpl_channels
int num_cpl_channels
number of channels in coupling
Definition: ac3enc.h:151
AC3EncodeContext::bit_alloc
AC3BitAllocParameters bit_alloc
bit allocation parameters
Definition: ac3enc.h:228
AV_CH_LAYOUT_5POINT0
#define AV_CH_LAYOUT_5POINT0
Definition: channel_layout.h:100
count_exponent_bits
static int count_exponent_bits(AC3EncodeContext *s)
Definition: ac3enc.c:547
extract_exponents
static void extract_exponents(AC3EncodeContext *s)
Definition: ac3enc.c:328
attributes.h
Macro definitions for various function/variable attributes.
ff_ac3_float_allocate_sample_buffers
int ff_ac3_float_allocate_sample_buffers(AC3EncodeContext *s)
AV_AUDIO_SERVICE_TYPE_EMERGENCY
Definition: avcodec.h:246
AVCodecContext::audio_service_type
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1251
ff_ac3_validate_metadata
int ff_ac3_validate_metadata(AC3EncodeContext *s)
Validate metadata options as set by AVOption system.
Definition: ac3enc.c:1833
AC3EncOptions::ltrt_surround_mix_level
float ltrt_surround_mix_level
Definition: ac3enc.h:113
AC3Block::new_cpl_leak
int new_cpl_leak
send new coupling leak info
Definition: ac3enc.h:155
AC3EncodeContext::rematrixing_enabled
int rematrixing_enabled
stereo rematrixing enabled
Definition: ac3enc.h:220
ff_eac3_get_frame_exp_strategy
void ff_eac3_get_frame_exp_strategy(AC3EncodeContext *s)
Determine frame exponent strategy use and indices.
Definition: eac3enc.c:68
AC3DSPContext::extract_exponents
void(* extract_exponents)(uint8_t *exp, int32_t *coef, int nb_coefs)
Definition: ac3dsp.h:127
AC3EncodeContext::channel_mode
int channel_mode
channel mode (acmod)
Definition: ac3enc.h:199
AC3EncodeContext::num_cpl_subbands
int num_cpl_subbands
number of coupling subbands (ncplsubnd)
Definition: ac3enc.h:216
AC3EncOptions::surround_mix_level
float surround_mix_level
Definition: ac3enc.h:103
AV_AUDIO_SERVICE_TYPE_MAIN
Definition: avcodec.h:240
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:88
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
count_frame_bits
static void count_frame_bits(AC3EncodeContext *s)
Definition: ac3enc.c:795
opt.h
AVOptions.
extmixlev_options
static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS]
Definition: ac3enc.c:65
AC3Block::rematrixing_flags
uint8_t rematrixing_flags[4]
rematrixing flags
Definition: ac3enc.h:147
EXP_D15
#define EXP_D15
Definition: ac3.h:51
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
AC3EncodeContext::fbw_channels
int fbw_channels
number of full-bandwidth channels (nfchans)
Definition: ac3enc.h:193
AC3Block::new_cpl_coords
uint8_t new_cpl_coords[AC3_MAX_CHANNELS]
send new coupling coordinates (cplcoe)
Definition: ac3enc.h:152
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
c
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
set_bandwidth
static av_cold void set_bandwidth(AC3EncodeContext *s)
Definition: ac3enc.c:2253
ff_ac3_enc_channel_map
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
ff_ac3_encode_close
av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
Finalize encoding and free any memory allocated by the encoder.
Definition: ac3enc.c:2016
AC3EncodeContext::bap1_buffer
uint8_t * bap1_buffer
Definition: ac3enc.h:239
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:52
AC3EncodeContext::slow_gain_code
int slow_gain_code
slow gain code (sgaincod)
Definition: ac3enc.h:223
crc.h
Public header for CRC hash function implementation.
AC3Block::cpl_master_exp
uint8_t cpl_master_exp[AC3_MAX_CHANNELS]
coupling coord master exponents (mstrcplco)
Definition: ac3enc.h:153
CRC16_POLY
#define CRC16_POLY
CRC-16 Polynomial.
Definition: ac3enc.c:1575
AC3DSPContext::bit_alloc_calc_bap
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
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
AC3Block::exp
uint8_t ** exp
original exponents
Definition: ac3enc.h:136
AC3Block::num_rematrixing_bands
int num_rematrixing_bands
number of rematrixing bands
Definition: ac3enc.h:146
validate_options
static av_cold int validate_options(AC3EncodeContext *s)
Definition: ac3enc.c:2108
LEVEL_MINUS_1POINT5DB
#define LEVEL_MINUS_1POINT5DB
Definition: ac3.h:106
AC3EncodeContext::ac3dsp
AC3DSPContext ac3dsp
AC-3 optimized functions.
Definition: ac3enc.h:170
AC3EncodeContext::loro_center_mix_level
int loro_center_mix_level
Lo/Ro center mix level code.
Definition: ac3enc.h:206
AC3EncodeContext::num_cpl_bands
int num_cpl_bands
number of coupling bands (ncplbnd)
Definition: ac3enc.h:217
channels
channels
Definition: aptx.h:33
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
bit_alloc
static int bit_alloc(AC3EncodeContext *s, int snr_offset)
Run the bit allocation with a given SNR offset.
Definition: ac3enc.c:1064
ff_ac3_fixed_mdct_end
void ff_ac3_fixed_mdct_end(AC3EncodeContext *s)
Finalize MDCT and free allocated memory.
Definition: ac3enc_fixed.c:118
dprint_options
static void dprint_options(AC3EncodeContext *s)
Definition: ac3enc.c:1676
AC3EncodeContext::lfe_channel
int lfe_channel
channel index of the LFE channel
Definition: ac3enc.h:196
AC3Mant::mant2_cnt
int mant2_cnt
Definition: ac3enc.c:51
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AC3EncodeContext::ref_bap_set
int ref_bap_set
indicates if ref_bap pointers have been set
Definition: ac3enc.h:256
EXP_DIFF_THRESHOLD
#define EXP_DIFF_THRESHOLD
Exponent Difference Threshold.
Definition: ac3enc.c:342
exponent_init
static av_cold void exponent_init(AC3EncodeContext *s)
Definition: ac3enc.c:306
quantize_mantissas_blk_ch
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
AC3Block::new_snr_offsets
int new_snr_offsets
send new SNR offsets
Definition: ac3enc.h:154
AC3EncodeContext::output_frame_header
void(* output_frame_header)(struct AC3EncodeContext *s)
Definition: ac3enc.h:268
AC3EncodeContext::loro_surround_mix_level
int loro_surround_mix_level
Lo/Ro surround mix level code.
Definition: ac3enc.h:207
AC3Block::mdct_coef
CoefType ** mdct_coef
MDCT coefficients.
Definition: ac3enc.h:134
AC3Mant::qmant4_ptr
int16_t * qmant4_ptr
mantissa pointers for bap=1,2,4
Definition: ac3enc.c:50
AV_CH_LAYOUT_5POINT1
#define AV_CH_LAYOUT_5POINT1
Definition: channel_layout.h:101
AC3Block::channel_in_cpl
uint8_t channel_in_cpl[AC3_MAX_CHANNELS]
channel in coupling (chincpl)
Definition: ac3enc.h:150
AC3Mant::qmant1_ptr
int16_t * qmant1_ptr
Definition: ac3enc.c:50
AC3EncOptions::eac3_info_metadata
int eac3_info_metadata
Definition: ac3enc.h:121
AC3EncOptions::mixing_level
int mixing_level
Definition: ac3enc.h:106
AC3ENC_OPT_SMALL_ROOM
#define AC3ENC_OPT_SMALL_ROOM
Definition: ac3enc.h:87
AC3EncodeContext::num_blks_code
int num_blks_code
number of blocks code (numblkscod)
Definition: ac3enc.h:184
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
ff_ac3_channel_layouts
const uint64_t ff_ac3_channel_layouts[19]
List of supported channel layouts.
Definition: ac3enc.c:81
put_bits_ptr
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:347
sym_quant
static int sym_quant(int c, int e, int levels)
Symmetric quantization on &#39;levels&#39; levels.
Definition: ac3enc.c:1166
ff_ac3_fast_decay_tab
const uint8_t ff_ac3_fast_decay_tab[4]
Definition: ac3tab.c:284
AC3EncodeContext::options
AC3EncOptions options
encoding options
Definition: ac3enc.h:164
AC3Block::band_psd
int16_t ** band_psd
psd per critical band
Definition: ac3enc.h:139
AC3EncOptions::ltrt_center_mix_level
float ltrt_center_mix_level
Definition: ac3enc.h:112
encode_exponents_blk_ch
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
AC3EncodeContext::channels
int channels
total number of channels (nchans)
Definition: ac3enc.h:194
r
const char * r
Definition: vf_curves.c:114
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:2060
AC3_MAX_CHANNELS
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:32
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
ff_ac3_bit_alloc_calc_mask
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
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:52
AC3EncodeContext::crc_inv
uint16_t crc_inv[2]
Definition: ac3enc.h:189
AC3EncodeContext::cpl_on
int cpl_on
coupling turned on for this frame
Definition: ac3enc.h:214
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
AV_CH_LAYOUT_QUAD
#define AV_CH_LAYOUT_QUAD
Definition: channel_layout.h:99
AC3EncodeContext::mask_buffer
int16_t * mask_buffer
Definition: ac3enc.h:246
AC3EncodeContext::psd_buffer
int16_t * psd_buffer
Definition: ac3enc.h:244
AC3EncodeContext::fixed_point
int fixed_point
indicates if fixed-point encoder is being used
Definition: ac3enc.h:176
av_get_sample_fmt_name
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
AC3EncodeContext::ltrt_surround_mix_level
int ltrt_surround_mix_level
Lt/Rt surround mix level code.
Definition: ac3enc.h:205
AC3Block::new_cpl_strategy
int new_cpl_strategy
send new coupling strategy
Definition: ac3enc.h:148
AC3EncodeContext::surround_mix_level
int surround_mix_level
surround mix level code
Definition: ac3enc.h:203
AV_AUDIO_SERVICE_TYPE_COMMENTARY
Definition: avcodec.h:245
LEVEL_MINUS_3DB
#define LEVEL_MINUS_3DB
Definition: ac3.h:107
AC3Block::cpl_in_use
int cpl_in_use
coupling in use for this block (cplinu)
Definition: ac3enc.h:149
av_strlcpy
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
AC3EncodeContext::cpl_enabled
int cpl_enabled
coupling enabled for all frames
Definition: ac3enc.h:215
exp
int8_t exp
Definition: eval.c:72
output_frame_end
static void output_frame_end(AC3EncodeContext *s)
Definition: ac3enc.c:1612
EXTMIXLEV_NUM_OPTIONS
#define EXTMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:64
AC3Mant
Definition: ac3enc.c:49
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
LEVEL_MINUS_4POINT5DB
#define LEVEL_MINUS_4POINT5DB
Definition: ac3.h:108
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:81
AC3_BLOCK_SIZE
#define AC3_BLOCK_SIZE
Definition: ac3.h:36
output_audio_block
static void output_audio_block(AC3EncodeContext *s, int blk)
Definition: ac3enc.c:1385
ff_ac3_bitrate_tab
const uint16_t ff_ac3_bitrate_tab[19]
Definition: ac3tab.c:132
count_mantissa_bits
static int count_mantissa_bits(AC3EncodeContext *s)
Definition: ac3enc.c:1038
AV_CH_LAYOUT_2_1
#define AV_CH_LAYOUT_2_1
Definition: channel_layout.h:93
AV_CH_LAYOUT_2_2
#define AV_CH_LAYOUT_2_2
Definition: channel_layout.h:98
AC3Block
Data for a single audio block.
Definition: ac3enc.h:133
AC3ENC_OPT_ON
#define AC3ENC_OPT_ON
Definition: ac3enc.h:79
internal.h
common internal API header
AC3EncodeContext::floor_code
int floor_code
floor code (floorcod)
Definition: ac3enc.h:227
ff_ac3_compute_bit_allocation
int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
Definition: ac3enc.c:1146
AC3ENC_OPT_DOWNMIX_LORO
#define AC3ENC_OPT_DOWNMIX_LORO
Definition: ac3enc.h:89
AC3EncodeContext::bitstream_mode
int bitstream_mode
bitstream mode (bsmod)
Definition: ac3enc.h:179
AC3ENC_OPT_ADCONV_STANDARD
#define AC3ENC_OPT_ADCONV_STANDARD
Definition: ac3enc.h:91
AC3EncodeContext::has_surround
int has_surround
indicates if there are one or more surround channels
Definition: ac3enc.h:198
b
#define b
Definition: input.c:41
channel_layout.h
audio channel layout utility functions
AV_AUDIO_SERVICE_TYPE_KARAOKE
Definition: avcodec.h:248
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
AC3EncodeContext::adsp
AudioDSPContext adsp
Definition: ac3enc.h:167
AC3EncodeContext::eac3
int eac3
indicates if this is E-AC-3 vs. AC-3
Definition: ac3enc.h:177
ac3_bandwidth_tab
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
AC3EncOptions::loro_center_mix_level
float loro_center_mix_level
Definition: ac3enc.h:114
ff_ac3dsp_init
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:422
AC3Mant::mant4_cnt
int mant4_cnt
mantissa counts for bap=1,2,4
Definition: ac3enc.c:51
ff_ac3_float_mdct_init
int ff_ac3_float_mdct_init(AC3EncodeContext *s)
Initialize MDCT tables.
Definition: ac3enc_float.c:110
int32_t
int32_t
Definition: audio_convert.c:194
ff_ac3_fast_gain_tab
const uint16_t ff_ac3_fast_gain_tab[8]
Definition: ac3tab.c:300
AC3EncOptions::ad_converter_type
int ad_converter_type
Definition: ac3enc.h:119
av_crc
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
frame
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
Definition: filter_design.txt:255
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_ac3_adjust_frame_size
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
AC3ENC_OPT_AUTO
#define AC3ENC_OPT_AUTO
Definition: ac3enc.h:77
AC3EncodeContext::exponent_bits
int exponent_bits
number of bits used for exponents
Definition: ac3enc.h:234
AC3EncOptions::stereo_rematrixing
int stereo_rematrixing
Definition: ac3enc.h:125
AV_CH_LAYOUT_5POINT1_BACK
#define AV_CH_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:103
AC3EncodeContext::coarse_snr_offset
int coarse_snr_offset
coarse SNR offsets (csnroffst)
Definition: ac3enc.h:229
DBA_NONE
Definition: ac3.h:118
AC3Block::mask
int16_t ** mask
masking curve
Definition: ac3enc.h:140
if
if(ret)
Definition: filter_design.txt:179
av_get_channel_layout_string
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.
Definition: channel_layout.c:217
AC3EncodeContext::planar_samples
SampleType ** planar_samples
Definition: ac3enc.h:237
AC3EncodeContext::fast_decay_code
int fast_decay_code
fast decay code (fdcycod)
Definition: ac3enc.h:225
me_cmp.h
AC3EncodeContext::qmant_buffer
int16_t * qmant_buffer
Definition: ac3enc.h:247
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
AC3ENC_OPT_MODE_OFF
#define AC3ENC_OPT_MODE_OFF
Definition: ac3enc.h:82
AC3ENC_OPT_ADCONV_HDCD
#define AC3ENC_OPT_ADCONV_HDCD
Definition: ac3enc.h:92
CPL_CH
#define CPL_CH
coupling channel index
Definition: ac3.h:33
ff_eac3_default_cpl_band_struct
const uint8_t ff_eac3_default_cpl_band_struct[18]
Table E2.16 Default Coupling Banding Structure.
Definition: ac3tab.c:146
AC3EncodeContext::ref_bap
uint8_t * ref_bap[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]
bit allocation pointers (bap)
Definition: ac3enc.h:255
ff_eac3_output_frame_header
void ff_eac3_output_frame_header(AC3EncodeContext *s)
Write the E-AC-3 frame header to the output bitstream.
Definition: eac3enc.c:128
avcodec.h
Libavcodec external API header.
AC3EncOptions::audio_production_info
int audio_production_info
Definition: ac3enc.h:105
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:536
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1186
AC3EncOptions::dolby_surround_mode
int dolby_surround_mode
Definition: ac3enc.h:104
ac3_coupling_start_tab
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
AVCodecContext
main external API structure.
Definition: avcodec.h:526
AC3EncodeContext::fast_gain_code
int fast_gain_code[AC3_MAX_CHANNELS]
fast gain codes (signal-to-mask ratio) (fgaincod)
Definition: ac3enc.h:230
AC3EncodeContext::sample_rate
int sample_rate
sampling frequency, in Hz
Definition: ac3enc.h:182
AC3EncodeContext::mdct_coef_buffer
CoefType * mdct_coef_buffer
Definition: ac3enc.h:240
AV_AUDIO_SERVICE_TYPE_VOICE_OVER
Definition: avcodec.h:247
LEVEL_ZERO
#define LEVEL_ZERO
Definition: ac3.h:111
list
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
Definition: filter_design.txt:23
LEVEL_ONE
#define LEVEL_ONE
Definition: ac3.h:112
AC3EncodeContext::has_center
int has_center
indicates if there is a center channel
Definition: ac3enc.h:197
AC3EncodeContext::bit_rate
int bit_rate
target bit rate, in bits-per-second
Definition: ac3enc.h:181
mul_poly
static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
Definition: ac3enc.c:1578
AV_CODEC_ID_EAC3
Definition: codec_id.h:458
AC3EncodeContext::allocate_sample_buffers
int(* allocate_sample_buffers)(struct AC3EncodeContext *s)
Definition: ac3enc.h:265
AC3EncodeContext::channel_map
const uint8_t * channel_map
channel map used to reorder channels
Definition: ac3enc.h:200
AC3EncodeContext::exp_buffer
uint8_t * exp_buffer
Definition: ac3enc.h:242
AC3EncodeContext::frame_bits_fixed
int frame_bits_fixed
number of non-coefficient bits for fixed parameters
Definition: ac3enc.h:232
AC3EncodeContext::warned_alternate_bitstream
int warned_alternate_bitstream
Definition: ac3enc.h:258
AC3Block::end_freq
int end_freq[AC3_MAX_CHANNELS]
end frequency bin (endmant)
Definition: ac3enc.h:156
FLT_OPTION_THRESHOLD
#define FLT_OPTION_THRESHOLD
Definition: ac3enc.c:1791
AC3DSPContext::compute_mantissa_size
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
validate_float_option
static int validate_float_option(float v, const float *v_list, int v_list_size)
Definition: ac3enc.c:1793
AC3EncOptions::cpl_start
int cpl_start
Definition: ac3enc.h:127
AC3EncodeContext::cpl_coord_exp_buffer
uint8_t * cpl_coord_exp_buffer
Definition: ac3enc.h:248
AC3EncodeContext::ltrt_center_mix_level
int ltrt_center_mix_level
Lt/Rt center mix level code.
Definition: ac3enc.h:204
AV_CH_LAYOUT_5POINT0_BACK
#define AV_CH_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:102
ff_eac3_exponent_init
av_cold void ff_eac3_exponent_init(void)
Initialize E-AC-3 exponent tables.
Definition: eac3enc.c:52
AC3EncodeContext::center_mix_level
int center_mix_level
center mix level code
Definition: ac3enc.h:202
AC3_MAX_BLOCKS
#define AC3_MAX_BLOCKS
Definition: ac3.h:37
AC3EncodeContext
AC-3 encoder private context.
Definition: ac3enc.h:162
ff_ac3_output_frame
void ff_ac3_output_frame(AC3EncodeContext *s, unsigned char *frame)
Write the frame to the output bitstream.
Definition: ac3enc.c:1661
count_frame_bits_fixed
static void count_frame_bits_fixed(AC3EncodeContext *s)
Definition: ac3enc.c:653
snprintf
#define snprintf
Definition: snprintf.h:34
AC3EncodeContext::blocks
AC3Block blocks[AC3_MAX_BLOCKS]
per-block info
Definition: ac3enc.h:174
ff_ac3_floor_tab
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:296
AC3EncodeContext::windowed_samples
SampleType * windowed_samples
Definition: ac3enc.h:236
AC3Mant::mant1_cnt
int mant1_cnt
Definition: ac3enc.c:51
AC3EncOptions::preferred_stereo_downmix
int preferred_stereo_downmix
Definition: ac3enc.h:111
ff_ac3_quantize_mantissas
void ff_ac3_quantize_mantissas(AC3EncodeContext *s)
Quantize mantissas using coefficients, exponents, and bit allocation pointers.
Definition: ac3enc.c:1300
AC3DSPContext::ac3_exponent_min
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
AC3EncodeContext::num_blocks
int num_blocks
number of blocks per frame
Definition: ac3enc.h:185
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:560
encode_exponents
static void encode_exponents(AC3EncodeContext *s)
Definition: ac3enc.c:497
CMIXLEV_NUM_OPTIONS
#define CMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:54
MECmpContext::sad
me_cmp_func sad[6]
Definition: me_cmp.h:56
AC3EncOptions::center_mix_level
float center_mix_level
Definition: ac3enc.h:102
EXP_NEW
#define EXP_NEW
Definition: ac3.h:49
reset_block_bap
static void reset_block_bap(AC3EncodeContext *s)
Definition: ac3enc.c:971
bit_alloc_init
static av_cold void bit_alloc_init(AC3EncodeContext *s)
Definition: ac3enc.c:759
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AC3EncOptions::extended_bsi_2
int extended_bsi_2
Definition: ac3enc.h:116
AC3_FRAME_SIZE
#define AC3_FRAME_SIZE
Definition: ac3.h:38
AC3EncodeContext::frame_size
int frame_size
current frame size in bytes
Definition: ac3enc.h:187
SURMIXLEV_NUM_OPTIONS
#define SURMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:59
AC3EncOptions::room_type
int room_type
Definition: ac3enc.h:107
AC3Block::grouped_exp
uint8_t ** grouped_exp
grouped exponents
Definition: ac3enc.h:137
AC3EncodeContext::cpl_end_freq
int cpl_end_freq
coupling channel end frequency bin
Definition: ac3enc.h:212
AC3ENC_OPT_LARGE_ROOM
#define AC3ENC_OPT_LARGE_ROOM
Definition: ac3enc.h:86
AC3EncodeContext::cpl_band_sizes
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3enc.h:218
AC3EncodeContext::mecc
MECmpContext mecc
Definition: ac3enc.h:169
internal.h
common internal api header.
AC3ENC_OPT_MODE_ON
#define AC3ENC_OPT_MODE_ON
Definition: ac3enc.h:81
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:115
validate_mix_level
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
surmixlev_options
static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS]
Definition: ac3enc.c:60
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
AC3EncodeContext::bits_written
int64_t bits_written
bit count (used to avg. bitrate)
Definition: ac3enc.h:190
AC3ENC_OPT_NONE
#define AC3ENC_OPT_NONE
Definition: ac3enc.h:76
AC3EncodeContext::bitstream_id
int bitstream_id
bitstream id (bsid)
Definition: ac3enc.h:178
AC3EncodeContext::band_psd_buffer
int16_t * band_psd_buffer
Definition: ac3enc.h:245
AC3EncOptions::dolby_headphone_mode
int dolby_headphone_mode
Definition: ac3enc.h:118
AC3EncodeContext::avctx
AVCodecContext * avctx
parent AVCodecContext
Definition: ac3enc.h:165
AC3EncodeContext::exp_ref_block
uint8_t exp_ref_block[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]
reference blocks for EXP_REUSE
Definition: ac3enc.h:254
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
AVCodecContext::cutoff
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:1230
AC3EncOptions::allow_per_frame_metadata
int allow_per_frame_metadata
Definition: ac3enc.h:124
ff_ac3_bit_alloc_calc_psd
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
count_mantissa_bits_update_ch
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
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
AC3EncOptions::original
int original
Definition: ac3enc.h:109
LEVEL_PLUS_3DB
#define LEVEL_PLUS_3DB
Definition: ac3.h:104
AC3ENC_OPT_DOWNMIX_LTRT
#define AC3ENC_OPT_DOWNMIX_LTRT
Definition: ac3enc.h:88
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
AC3ENC_OPT_NOT_INDICATED
#define AC3ENC_OPT_NOT_INDICATED
Definition: ac3enc.h:80
cbr_bit_allocation
static int cbr_bit_allocation(AC3EncodeContext *s)
Definition: ac3enc.c:1095
AC3EncodeContext::bap_buffer
uint8_t * bap_buffer
Definition: ac3enc.h:238
AC3EncodeContext::frame_size_min
int frame_size_min
minimum frame size in case rounding is necessary
Definition: ac3enc.h:186
LEVEL_MINUS_6DB
#define LEVEL_MINUS_6DB
Definition: ac3.h:109
ff_ac3_float_mdct_end
void ff_ac3_float_mdct_end(AC3EncodeContext *s)
Finalize MDCT and free allocated memory.
Definition: ac3enc_float.c:97
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
ac3enc.h
AC-3 encoder & E-AC-3 encoder common header.
av_get_default_channel_layout
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
Definition: channel_layout.c:231
pow_poly
static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
Definition: ac3enc.c:1595
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
ff_ac3_apply_rematrixing
void ff_ac3_apply_rematrixing(AC3EncodeContext *s)
Apply stereo rematrixing to coefficients based on rematrixing flags.
Definition: ac3enc.c:272
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ff_ac3_rematrix_band_tab
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
AC3EncodeContext::samples_written
int64_t samples_written
sample count (used to avg. bitrate)
Definition: ac3enc.h:191
ff_ac3_sample_rate_tab
const int ff_ac3_sample_rate_tab[]
Definition: ac3tab.c:129
AC3EncodeContext::cpl_coord_mant_buffer
uint8_t * cpl_coord_mant_buffer
Definition: ac3enc.h:249
AC3EncodeContext::use_frame_exp_strategy
int use_frame_exp_strategy
indicates use of frame exp strategy
Definition: ac3enc.h:253
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:141
bit_alloc_masking
static void bit_alloc_masking(AC3EncodeContext *s)
Definition: ac3enc.c:941
ff_ac3_fixed_mdct_init
int ff_ac3_fixed_mdct_init(AC3EncodeContext *s)
Initialize MDCT tables.
Definition: ac3enc_fixed.c:130
ff_ac3_group_exponents
void ff_ac3_group_exponents(AC3EncodeContext *s)
Group exponents.
Definition: ac3enc.c:579
AV_CRC_16_ANSI
Definition: crc.h:51
ff_ac3_db_per_bit_tab
const uint16_t ff_ac3_db_per_bit_tab[4]
Definition: ac3tab.c:292
AC3Mant::qmant2_ptr
int16_t * qmant2_ptr
Definition: ac3enc.c:50
AVERROR
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
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
ff_ac3_compute_coupling_strategy
void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
Set the initial coupling strategy parameters prior to coupling analysis.
Definition: ac3enc.c:201
AC3EncodeContext::cutoff
int cutoff
user-specified cutoff frequency, in Hz
Definition: ac3enc.h:209
eac3enc.h
E-AC-3 encoder.
AC3EncodeContext::lfe_on
int lfe_on
indicates if there is an LFE channel (lfeon)
Definition: ac3enc.h:195
AC3EncodeContext::fine_snr_offset
int fine_snr_offset[AC3_MAX_CHANNELS]
fine SNR offsets (fsnroffst)
Definition: ac3enc.h:231
AC3ENC_OPT_OFF
#define AC3ENC_OPT_OFF
Definition: ac3enc.h:78
ac3.h
Common code between the AC-3 encoder and decoder.
AVCRC
uint32_t AVCRC
Definition: crc.h:47
AC3EncodeContext::fixed_coef_buffer
int32_t * fixed_coef_buffer
Definition: ac3enc.h:241
EXP_D45
#define EXP_D45
Definition: ac3.h:53
i
int i
Definition: input.c:407
AC3EncOptions::extended_bsi_1
int extended_bsi_1
Definition: ac3enc.h:110
AC3EncOptions::copyright
int copyright
Definition: ac3enc.h:108
AC3Block::fixed_coef
int32_t ** fixed_coef
fixed-point MDCT coefficients
Definition: ac3enc.h:135
ff_ac3_encode_init
av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
Definition: ac3enc.c:2409
put_bits.h
bitstream writer API
Generated on Thu Oct 22 2020 19:21:37 for FFmpeg by   doxygen 1.8.11