FFmpeg  4.0
ac3enc_template.c
Go to the documentation of this file.
1 /*
2  * AC-3 encoder float/fixed template
3  * Copyright (c) 2000 Fabrice Bellard
4  * Copyright (c) 2006-2011 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  * AC-3 encoder float/fixed template
27  */
28 
29 #include <stdint.h>
30 
31 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 
34 #include "audiodsp.h"
35 #include "internal.h"
36 #include "ac3enc.h"
37 #include "eac3enc.h"
38 
39 
41 {
42  int ch;
43 
44  FF_ALLOC_OR_GOTO(s->avctx, s->windowed_samples, AC3_WINDOW_SIZE *
45  sizeof(*s->windowed_samples), alloc_fail);
46  FF_ALLOC_ARRAY_OR_GOTO(s->avctx, s->planar_samples, s->channels, sizeof(*s->planar_samples),
47  alloc_fail);
48  for (ch = 0; ch < s->channels; ch++) {
49  FF_ALLOCZ_OR_GOTO(s->avctx, s->planar_samples[ch],
50  (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples),
51  alloc_fail);
52  }
53 
54  return 0;
55 alloc_fail:
56  return AVERROR(ENOMEM);
57 }
58 
59 
60 /*
61  * Copy input samples.
62  * Channels are reordered from FFmpeg's default order to AC-3 order.
63  */
65 {
66  int ch;
67 
68  /* copy and remap input samples */
69  for (ch = 0; ch < s->channels; ch++) {
70  /* copy last 256 samples of previous frame to the start of the current frame */
71  memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_BLOCK_SIZE * s->num_blocks],
72  AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0]));
73 
74  /* copy new samples for current frame */
75  memcpy(&s->planar_samples[ch][AC3_BLOCK_SIZE],
76  samples[s->channel_map[ch]],
77  AC3_BLOCK_SIZE * s->num_blocks * sizeof(s->planar_samples[0][0]));
78  }
79 }
80 
81 
82 /*
83  * Apply the MDCT to input samples to generate frequency coefficients.
84  * This applies the KBD window and normalizes the input to reduce precision
85  * loss due to fixed-point calculations.
86  */
88 {
89  int blk, ch;
90 
91  for (ch = 0; ch < s->channels; ch++) {
92  for (blk = 0; blk < s->num_blocks; blk++) {
93  AC3Block *block = &s->blocks[blk];
94  const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
95 
96 #if CONFIG_AC3ENC_FLOAT
97  s->fdsp->vector_fmul(s->windowed_samples, input_samples,
99 #else
100  s->ac3dsp.apply_window_int16(s->windowed_samples, input_samples,
102 
103  if (s->fixed_point)
104  block->coeff_shift[ch+1] = normalize_samples(s);
105 #endif
106 
107  s->mdct.mdct_calcw(&s->mdct, block->mdct_coef[ch+1],
108  s->windowed_samples);
109  }
110  }
111 }
112 
113 
114 /*
115  * Calculate coupling channel and coupling coordinates.
116  */
118 {
120 #if CONFIG_AC3ENC_FLOAT
121  LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
122 #else
123  int32_t (*fixed_cpl_coords)[AC3_MAX_CHANNELS][16] = cpl_coords;
124 #endif
125  int av_uninit(blk), ch, bnd, i, j;
126  CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}};
127  int cpl_start, num_cpl_coefs;
128 
129  memset(cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
130 #if CONFIG_AC3ENC_FLOAT
131  memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
132 #endif
133 
134  /* align start to 16-byte boundary. align length to multiple of 32.
135  note: coupling start bin % 4 will always be 1 */
136  cpl_start = s->start_freq[CPL_CH] - 1;
137  num_cpl_coefs = FFALIGN(s->num_cpl_subbands * 12 + 1, 32);
138  cpl_start = FFMIN(256, cpl_start + num_cpl_coefs) - num_cpl_coefs;
139 
140  /* calculate coupling channel from fbw channels */
141  for (blk = 0; blk < s->num_blocks; blk++) {
142  AC3Block *block = &s->blocks[blk];
143  CoefType *cpl_coef = &block->mdct_coef[CPL_CH][cpl_start];
144  if (!block->cpl_in_use)
145  continue;
146  memset(cpl_coef, 0, num_cpl_coefs * sizeof(*cpl_coef));
147  for (ch = 1; ch <= s->fbw_channels; ch++) {
148  CoefType *ch_coef = &block->mdct_coef[ch][cpl_start];
149  if (!block->channel_in_cpl[ch])
150  continue;
151  for (i = 0; i < num_cpl_coefs; i++)
152  cpl_coef[i] += ch_coef[i];
153  }
154 
155  /* coefficients must be clipped in order to be encoded */
156  clip_coefficients(&s->adsp, cpl_coef, num_cpl_coefs);
157  }
158 
159  /* calculate energy in each band in coupling channel and each fbw channel */
160  /* TODO: possibly use SIMD to speed up energy calculation */
161  bnd = 0;
162  i = s->start_freq[CPL_CH];
163  while (i < s->cpl_end_freq) {
164  int band_size = s->cpl_band_sizes[bnd];
165  for (ch = CPL_CH; ch <= s->fbw_channels; ch++) {
166  for (blk = 0; blk < s->num_blocks; blk++) {
167  AC3Block *block = &s->blocks[blk];
168  if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch]))
169  continue;
170  for (j = 0; j < band_size; j++) {
171  CoefType v = block->mdct_coef[ch][i+j];
172  MAC_COEF(energy[blk][ch][bnd], v, v);
173  }
174  }
175  }
176  i += band_size;
177  bnd++;
178  }
179 
180  /* calculate coupling coordinates for all blocks for all channels */
181  for (blk = 0; blk < s->num_blocks; blk++) {
182  AC3Block *block = &s->blocks[blk];
183  if (!block->cpl_in_use)
184  continue;
185  for (ch = 1; ch <= s->fbw_channels; ch++) {
186  if (!block->channel_in_cpl[ch])
187  continue;
188  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
189  cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd],
190  energy[blk][CPL_CH][bnd]);
191  }
192  }
193  }
194 
195  /* determine which blocks to send new coupling coordinates for */
196  for (blk = 0; blk < s->num_blocks; blk++) {
197  AC3Block *block = &s->blocks[blk];
198  AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL;
199 
200  memset(block->new_cpl_coords, 0, sizeof(block->new_cpl_coords));
201 
202  if (block->cpl_in_use) {
203  /* send new coordinates if this is the first block, if previous
204  * block did not use coupling but this block does, the channels
205  * using coupling has changed from the previous block, or the
206  * coordinate difference from the last block for any channel is
207  * greater than a threshold value. */
208  if (blk == 0 || !block0->cpl_in_use) {
209  for (ch = 1; ch <= s->fbw_channels; ch++)
210  block->new_cpl_coords[ch] = 1;
211  } else {
212  for (ch = 1; ch <= s->fbw_channels; ch++) {
213  if (!block->channel_in_cpl[ch])
214  continue;
215  if (!block0->channel_in_cpl[ch]) {
216  block->new_cpl_coords[ch] = 1;
217  } else {
218  CoefSumType coord_diff = 0;
219  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
220  coord_diff += FFABS(cpl_coords[blk-1][ch][bnd] -
221  cpl_coords[blk ][ch][bnd]);
222  }
223  coord_diff /= s->num_cpl_bands;
224  if (coord_diff > NEW_CPL_COORD_THRESHOLD)
225  block->new_cpl_coords[ch] = 1;
226  }
227  }
228  }
229  }
230  }
231 
232  /* calculate final coupling coordinates, taking into account reusing of
233  coordinates in successive blocks */
234  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
235  blk = 0;
236  while (blk < s->num_blocks) {
237  int av_uninit(blk1);
238  AC3Block *block = &s->blocks[blk];
239 
240  if (!block->cpl_in_use) {
241  blk++;
242  continue;
243  }
244 
245  for (ch = 1; ch <= s->fbw_channels; ch++) {
246  CoefSumType energy_ch, energy_cpl;
247  if (!block->channel_in_cpl[ch])
248  continue;
249  energy_cpl = energy[blk][CPL_CH][bnd];
250  energy_ch = energy[blk][ch][bnd];
251  blk1 = blk+1;
252  while (blk1 < s->num_blocks && !s->blocks[blk1].new_cpl_coords[ch]) {
253  if (s->blocks[blk1].cpl_in_use) {
254  energy_cpl += energy[blk1][CPL_CH][bnd];
255  energy_ch += energy[blk1][ch][bnd];
256  }
257  blk1++;
258  }
259  cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl);
260  }
261  blk = blk1;
262  }
263  }
264 
265  /* calculate exponents/mantissas for coupling coordinates */
266  for (blk = 0; blk < s->num_blocks; blk++) {
267  AC3Block *block = &s->blocks[blk];
268  if (!block->cpl_in_use)
269  continue;
270 
271 #if CONFIG_AC3ENC_FLOAT
272  s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1],
273  cpl_coords[blk][1],
274  s->fbw_channels * 16);
275 #endif
277  fixed_cpl_coords[blk][1],
278  s->fbw_channels * 16);
279 
280  for (ch = 1; ch <= s->fbw_channels; ch++) {
281  int bnd, min_exp, max_exp, master_exp;
282 
283  if (!block->new_cpl_coords[ch])
284  continue;
285 
286  /* determine master exponent */
287  min_exp = max_exp = block->cpl_coord_exp[ch][0];
288  for (bnd = 1; bnd < s->num_cpl_bands; bnd++) {
289  int exp = block->cpl_coord_exp[ch][bnd];
290  min_exp = FFMIN(exp, min_exp);
291  max_exp = FFMAX(exp, max_exp);
292  }
293  master_exp = ((max_exp - 15) + 2) / 3;
294  master_exp = FFMAX(master_exp, 0);
295  while (min_exp < master_exp * 3)
296  master_exp--;
297  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
298  block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] -
299  master_exp * 3, 0, 15);
300  }
301  block->cpl_master_exp[ch] = master_exp;
302 
303  /* quantize mantissas */
304  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
305  int cpl_exp = block->cpl_coord_exp[ch][bnd];
306  int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24;
307  if (cpl_exp == 15)
308  cpl_mant >>= 1;
309  else
310  cpl_mant -= 16;
311 
312  block->cpl_coord_mant[ch][bnd] = cpl_mant;
313  }
314  }
315  }
316 
317  if (CONFIG_EAC3_ENCODER && s->eac3)
319 }
320 
321 
322 /*
323  * Determine rematrixing flags for each block and band.
324  */
326 {
327  int nb_coefs;
328  int blk, bnd;
329  AC3Block *block, *block0 = NULL;
330 
332  return;
333 
334  for (blk = 0; blk < s->num_blocks; blk++) {
335  block = &s->blocks[blk];
336  block->new_rematrixing_strategy = !blk;
337 
338  block->num_rematrixing_bands = 4;
339  if (block->cpl_in_use) {
340  block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61);
341  block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37);
342  if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands)
343  block->new_rematrixing_strategy = 1;
344  }
345  nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
346 
347  if (!s->rematrixing_enabled) {
348  block0 = block;
349  continue;
350  }
351 
352  for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
353  /* calculate sum of squared coeffs for one band in one block */
354  int start = ff_ac3_rematrix_band_tab[bnd];
355  int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
356  CoefSumType sum[4];
357  sum_square_butterfly(s, sum, block->mdct_coef[1] + start,
358  block->mdct_coef[2] + start, end - start);
359 
360  /* compare sums to determine if rematrixing will be used for this band */
361  if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1]))
362  block->rematrixing_flags[bnd] = 1;
363  else
364  block->rematrixing_flags[bnd] = 0;
365 
366  /* determine if new rematrixing flags will be sent */
367  if (blk &&
368  block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) {
369  block->new_rematrixing_strategy = 1;
370  }
371  }
372  block0 = block;
373  }
374 }
375 
376 
378  const AVFrame *frame, int *got_packet_ptr)
379 {
381  int ret;
382 
384  ret = ff_ac3_validate_metadata(s);
385  if (ret)
386  return ret;
387  }
388 
389  if (s->bit_alloc.sr_code == 1 || s->eac3)
391 
393 
394  apply_mdct(s);
395 
396  if (s->fixed_point)
398 
399  clip_coefficients(&s->adsp, s->blocks[0].mdct_coef[1],
400  AC3_MAX_COEFS * s->num_blocks * s->channels);
401 
402  s->cpl_on = s->cpl_enabled;
404 
405  if (s->cpl_on)
407 
409 
410  if (!s->fixed_point)
412 
414 
416 
418  if (ret) {
419  av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
420  return ret;
421  }
422 
424 
426 
427  if ((ret = ff_alloc_packet2(avctx, avpkt, s->frame_size, 0)) < 0)
428  return ret;
429  ff_ac3_output_frame(s, avpkt->data);
430 
431  if (frame->pts != AV_NOPTS_VALUE)
433 
434  *got_packet_ptr = 1;
435  return 0;
436 }
uint8_t new_rematrixing_strategy
send new rematrixing flags in this block
Definition: ac3enc.h:145
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
AVFloatDSPContext * fdsp
Definition: ac3enc.h:168
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
int AC3_NAME() allocate_sample_buffers(AC3EncodeContext *s)
static void apply_mdct(AC3EncodeContext *s)
uint8_t ** cpl_coord_exp
coupling coord exponents (cplcoexp)
Definition: ac3enc.h:142
#define AC3_MAX_COEFS
Definition: ac3.h:35
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
#define AC3_WINDOW_SIZE
Definition: ac3.h:39
void ff_ac3_process_exponents(AC3EncodeContext *s)
Calculate final exponents from the supplied MDCT coefficients and exponent shift. ...
Definition: ac3enc.c:637
void ff_eac3_set_cpl_states(AC3EncodeContext *s)
Set coupling states.
Definition: eac3enc.c:95
uint8_t ** cpl_coord_mant
coupling coord mantissas (cplcomant)
Definition: ac3enc.h:143
int start_freq[AC3_MAX_CHANNELS]
start frequency bin (strtmant)
Definition: ac3enc.h:211
#define blk(i)
Definition: sha.c:185
AC3BitAllocParameters bit_alloc
bit allocation parameters
Definition: ac3enc.h:228
Macro definitions for various function/variable attributes.
int ff_ac3_validate_metadata(AC3EncodeContext *s)
Validate metadata options as set by AVOption system.
Definition: ac3enc.c:1833
int rematrixing_enabled
stereo rematrixing enabled
Definition: ac3enc.h:220
static void apply_channel_coupling(AC3EncodeContext *s)
static int16_t block[64]
Definition: dct.c:115
void(* extract_exponents)(uint8_t *exp, int32_t *coef, int nb_coefs)
Definition: ac3dsp.h:127
int channel_mode
channel mode (acmod)
Definition: ac3enc.h:199
int num_cpl_subbands
number of coupling subbands (ncplsubnd)
Definition: ac3enc.h:216
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
void(* apply_window_int16)(int16_t *output, const int16_t *input, const int16_t *window, unsigned int len)
Apply symmetric window in 16-bit fixed-point.
Definition: ac3dsp.h:151
uint8_t rematrixing_flags[4]
rematrixing flags
Definition: ac3enc.h:147
int fbw_channels
number of full-bandwidth channels (nfchans)
Definition: ac3enc.h:193
uint8_t new_cpl_coords[AC3_MAX_CHANNELS]
send new coupling coordinates (cplcoe)
Definition: ac3enc.h:152
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats...
Definition: float_dsp.h:38
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:311
static AVFrame * frame
uint8_t cpl_master_exp[AC3_MAX_CHANNELS]
coupling coord master exponents (mstrcplco)
Definition: ac3enc.h:153
int num_rematrixing_bands
number of rematrixing bands
Definition: ac3enc.h:146
AC3DSPContext ac3dsp
AC-3 optimized functions.
Definition: ac3enc.h:170
int num_cpl_bands
number of coupling bands (ncplbnd)
Definition: ac3enc.h:217
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
int64_t CoefSumType
Definition: ac3enc.h:72
CoefType ** mdct_coef
MDCT coefficients.
Definition: ac3enc.h:134
uint8_t channel_in_cpl[AC3_MAX_CHANNELS]
channel in coupling (chincpl)
Definition: ac3enc.h:150
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AC3EncOptions options
encoding options
Definition: ac3enc.h:164
#define AVERROR(e)
Definition: error.h:43
void(* mdct_calcw)(struct FFTContext *s, FFTDouble *output, const FFTSample *input)
Definition: fft.h:110
int channels
total number of channels (nchans)
Definition: ac3enc.h:194
int initial_padding
Audio only.
Definition: avcodec.h:3031
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:32
#define AC3_NAME(x)
Definition: ac3enc.h:65
int cpl_on
coupling turned on for this frame
Definition: ac3enc.h:214
int fixed_point
indicates if fixed-point encoder is being used
Definition: ac3enc.h:176
#define FFMAX(a, b)
Definition: common.h:94
int cpl_in_use
coupling in use for this block (cplinu)
Definition: ac3enc.h:149
int cpl_enabled
coupling enabled for all frames
Definition: ac3enc.h:215
int8_t exp
Definition: eval.c:72
#define AC3_BLOCK_SIZE
Definition: ac3.h:36
int16_t SampleType
Definition: ac3enc.h:70
Data for a single audio block.
Definition: ac3enc.h:133
common internal API header
int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
Definition: ac3enc.c:1146
#define FFMIN(a, b)
Definition: common.h:96
AudioDSPContext adsp
Definition: ac3enc.h:167
int eac3
indicates if this is E-AC-3 vs. AC-3
Definition: ac3enc.h:177
int32_t
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
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
FFTContext mdct
FFT context for MDCT calculation.
Definition: ac3enc.h:171
int AC3_NAME() encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
static void scale_coefficients(AC3EncodeContext *s)
Definition: ac3enc_fixed.c:64
const SampleType * mdct_window
MDCT window function array.
Definition: ac3enc.h:172
SampleType ** planar_samples
Definition: ac3enc.h:237
static void clip_coefficients(AudioDSPContext *adsp, int32_t *coef, unsigned int len)
Definition: ac3enc_fixed.c:87
#define CPL_CH
coupling channel index
Definition: ac3.h:33
static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl)
Definition: ac3enc_fixed.c:97
#define NEW_CPL_COORD_THRESHOLD
Definition: ac3enc.h:69
main external API structure.
Definition: avcodec.h:1518
const uint8_t * channel_map
channel map used to reorder channels
Definition: ac3enc.h:200
int end_freq[AC3_MAX_CHANNELS]
end frequency bin (endmant)
Definition: ac3enc.h:156
#define AC3_MAX_BLOCKS
Definition: ac3.h:37
AC-3 encoder private context.
Definition: ac3enc.h:162
void ff_ac3_output_frame(AC3EncodeContext *s, unsigned char *frame)
Write the frame to the output bitstream.
Definition: ac3enc.c:1661
AC3Block blocks[AC3_MAX_BLOCKS]
per-block info
Definition: ac3enc.h:174
SampleType * windowed_samples
Definition: ac3enc.h:236
void ff_ac3_quantize_mantissas(AC3EncodeContext *s)
Quantize mantissas using coefficients, exponents, and bit allocation pointers.
Definition: ac3enc.c:1300
int num_blocks
number of blocks per frame
Definition: ac3enc.h:185
#define FF_ALLOC_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)
Definition: internal.h:158
uint8_t coeff_shift[AC3_MAX_CHANNELS]
fixed-point coefficient shift values
Definition: ac3enc.h:144
#define AC3_FRAME_SIZE
Definition: ac3.h:38
int frame_size
current frame size in bytes
Definition: ac3enc.h:187
int cpl_end_freq
coupling channel end frequency bin
Definition: ac3enc.h:212
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3enc.h:218
common internal api header.
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
Definition: internal.h:140
AVCodecContext * avctx
parent AVCodecContext
Definition: ac3enc.h:165
static void compute_rematrixing_strategy(AC3EncodeContext *s)
void * priv_data
Definition: avcodec.h:1545
int allow_per_frame_metadata
Definition: ac3enc.h:124
static void copy_input_samples(AC3EncodeContext *s, SampleType **samples)
#define MAC_COEF(d, a, b)
Definition: ac3enc.h:66
static int normalize_samples(AC3EncodeContext *s)
Definition: ac3enc_fixed.c:50
#define av_uninit(x)
Definition: attributes.h:148
AC-3 encoder & E-AC-3 encoder common header.
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
void ff_ac3_apply_rematrixing(AC3EncodeContext *s)
Apply stereo rematrixing to coefficients based on rematrixing flags.
Definition: ac3enc.c:272
void INT64 start
Definition: avisynth_c.h:690
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
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: internal.h:280
static void sum_square_butterfly(AC3EncodeContext *s, int64_t sum[4], const int32_t *coef0, const int32_t *coef1, int len)
Definition: ac3enc_fixed.c:77
void ff_ac3_group_exponents(AC3EncodeContext *s)
Group exponents.
Definition: ac3enc.c:579
#define CONFIG_EAC3_ENCODER
Definition: config.h:1279
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:265
int32_t CoefType
Definition: ac3enc.h:71
void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
Set the initial coupling strategy parameters prior to coupling analysis.
Definition: ac3enc.c:201
E-AC-3 encoder.
This structure stores compressed data.
Definition: avcodec.h:1407
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: internal.h:149
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
void(* float_to_fixed24)(int32_t *dst, const float *src, unsigned int len)
Convert an array of float in range [-1.0,1.0] to int32_t with range [-(1<<24),(1<<24)].
Definition: ac3dsp.h:89