FFmpeg
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 
392  copy_input_samples(s, (SampleType **)frame->extended_data);
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
AVFloatDSPContext * fdsp
Definition: ac3enc.h:168
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
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
#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)
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
The exact code depends on how similar the blocks are and how related they are to the block
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
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 i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AC3EncOptions options
encoding options
Definition: ac3enc.h:164
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:3101
#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
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
void ff_ac3_adjust_frame_size(AC3EncodeContext *s)
Adjust the frame size to make the average bit rate match the target bit rate.
Definition: ac3enc.c:183
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:1570
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
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
SampleType * windowed_samples
Definition: ac3enc.h:236
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:1597
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.
Filter the word “frame” indicates either a video frame or a group of audio samples
#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:766
const uint8_t ff_ac3_rematrix_band_tab[5]
Table of bin locations for rematrixing bands reference: Section 7.5.2 Rematrixing : Frequency Band De...
Definition: ac3tab.c:141
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:288
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
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
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:1459
#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