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  if (!FF_ALLOC_TYPED_ARRAY(s->windowed_samples, AC3_WINDOW_SIZE) ||
45  !FF_ALLOC_TYPED_ARRAY(s->planar_samples, s->channels))
46  return AVERROR(ENOMEM);
47 
48  for (ch = 0; ch < s->channels; ch++) {
49  if (!(s->planar_samples[ch] = av_mallocz((AC3_FRAME_SIZE + AC3_BLOCK_SIZE) *
50  sizeof(**s->planar_samples))))
51  return AVERROR(ENOMEM);
52  }
53  return 0;
54 }
55 
56 
57 /*
58  * Copy input samples.
59  * Channels are reordered from FFmpeg's default order to AC-3 order.
60  */
62 {
63  int ch;
64 
65  /* copy and remap input samples */
66  for (ch = 0; ch < s->channels; ch++) {
67  /* copy last 256 samples of previous frame to the start of the current frame */
68  memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_BLOCK_SIZE * s->num_blocks],
69  AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0]));
70 
71  /* copy new samples for current frame */
72  memcpy(&s->planar_samples[ch][AC3_BLOCK_SIZE],
73  samples[s->channel_map[ch]],
74  AC3_BLOCK_SIZE * s->num_blocks * sizeof(s->planar_samples[0][0]));
75  }
76 }
77 
78 
79 /*
80  * Apply the MDCT to input samples to generate frequency coefficients.
81  * This applies the KBD window and normalizes the input to reduce precision
82  * loss due to fixed-point calculations.
83  */
85 {
86  int blk, ch;
87 
88  for (ch = 0; ch < s->channels; ch++) {
89  for (blk = 0; blk < s->num_blocks; blk++) {
90  AC3Block *block = &s->blocks[blk];
91  const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
92 
93 #if CONFIG_AC3ENC_FLOAT
94  s->fdsp->vector_fmul(s->windowed_samples, input_samples,
96 #else
97  s->ac3dsp.apply_window_int16(s->windowed_samples, input_samples,
99 
100  if (s->fixed_point)
101  block->coeff_shift[ch+1] = normalize_samples(s);
102 #endif
103 
104  s->mdct.mdct_calcw(&s->mdct, block->mdct_coef[ch+1],
105  s->windowed_samples);
106  }
107  }
108 }
109 
110 
111 /*
112  * Calculate coupling channel and coupling coordinates.
113  */
115 {
117 #if CONFIG_AC3ENC_FLOAT
118  LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
119 #else
120  int32_t (*fixed_cpl_coords)[AC3_MAX_CHANNELS][16] = cpl_coords;
121 #endif
122  int av_uninit(blk), ch, bnd, i, j;
123  CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}};
124  int cpl_start, num_cpl_coefs;
125 
126  memset(cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
127 #if CONFIG_AC3ENC_FLOAT
128  memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
129 #endif
130 
131  /* align start to 16-byte boundary. align length to multiple of 32.
132  note: coupling start bin % 4 will always be 1 */
133  cpl_start = s->start_freq[CPL_CH] - 1;
134  num_cpl_coefs = FFALIGN(s->num_cpl_subbands * 12 + 1, 32);
135  cpl_start = FFMIN(256, cpl_start + num_cpl_coefs) - num_cpl_coefs;
136 
137  /* calculate coupling channel from fbw channels */
138  for (blk = 0; blk < s->num_blocks; blk++) {
139  AC3Block *block = &s->blocks[blk];
140  CoefType *cpl_coef = &block->mdct_coef[CPL_CH][cpl_start];
141  if (!block->cpl_in_use)
142  continue;
143  memset(cpl_coef, 0, num_cpl_coefs * sizeof(*cpl_coef));
144  for (ch = 1; ch <= s->fbw_channels; ch++) {
145  CoefType *ch_coef = &block->mdct_coef[ch][cpl_start];
146  if (!block->channel_in_cpl[ch])
147  continue;
148  for (i = 0; i < num_cpl_coefs; i++)
149  cpl_coef[i] += ch_coef[i];
150  }
151 
152  /* coefficients must be clipped in order to be encoded */
153  clip_coefficients(&s->adsp, cpl_coef, num_cpl_coefs);
154  }
155 
156  /* calculate energy in each band in coupling channel and each fbw channel */
157  /* TODO: possibly use SIMD to speed up energy calculation */
158  bnd = 0;
159  i = s->start_freq[CPL_CH];
160  while (i < s->cpl_end_freq) {
161  int band_size = s->cpl_band_sizes[bnd];
162  for (ch = CPL_CH; ch <= s->fbw_channels; ch++) {
163  for (blk = 0; blk < s->num_blocks; blk++) {
164  AC3Block *block = &s->blocks[blk];
165  if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch]))
166  continue;
167  for (j = 0; j < band_size; j++) {
168  CoefType v = block->mdct_coef[ch][i+j];
169  MAC_COEF(energy[blk][ch][bnd], v, v);
170  }
171  }
172  }
173  i += band_size;
174  bnd++;
175  }
176 
177  /* calculate coupling coordinates for all blocks for all channels */
178  for (blk = 0; blk < s->num_blocks; blk++) {
179  AC3Block *block = &s->blocks[blk];
180  if (!block->cpl_in_use)
181  continue;
182  for (ch = 1; ch <= s->fbw_channels; ch++) {
183  if (!block->channel_in_cpl[ch])
184  continue;
185  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
186  cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd],
187  energy[blk][CPL_CH][bnd]);
188  }
189  }
190  }
191 
192  /* determine which blocks to send new coupling coordinates for */
193  for (blk = 0; blk < s->num_blocks; blk++) {
194  AC3Block *block = &s->blocks[blk];
195  AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL;
196 
197  memset(block->new_cpl_coords, 0, sizeof(block->new_cpl_coords));
198 
199  if (block->cpl_in_use) {
200  /* send new coordinates if this is the first block, if previous
201  * block did not use coupling but this block does, the channels
202  * using coupling has changed from the previous block, or the
203  * coordinate difference from the last block for any channel is
204  * greater than a threshold value. */
205  if (blk == 0 || !block0->cpl_in_use) {
206  for (ch = 1; ch <= s->fbw_channels; ch++)
207  block->new_cpl_coords[ch] = 1;
208  } else {
209  for (ch = 1; ch <= s->fbw_channels; ch++) {
210  if (!block->channel_in_cpl[ch])
211  continue;
212  if (!block0->channel_in_cpl[ch]) {
213  block->new_cpl_coords[ch] = 1;
214  } else {
215  CoefSumType coord_diff = 0;
216  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
217  coord_diff += FFABS(cpl_coords[blk-1][ch][bnd] -
218  cpl_coords[blk ][ch][bnd]);
219  }
220  coord_diff /= s->num_cpl_bands;
221  if (coord_diff > NEW_CPL_COORD_THRESHOLD)
222  block->new_cpl_coords[ch] = 1;
223  }
224  }
225  }
226  }
227  }
228 
229  /* calculate final coupling coordinates, taking into account reusing of
230  coordinates in successive blocks */
231  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
232  blk = 0;
233  while (blk < s->num_blocks) {
234  int av_uninit(blk1);
235  AC3Block *block = &s->blocks[blk];
236 
237  if (!block->cpl_in_use) {
238  blk++;
239  continue;
240  }
241 
242  for (ch = 1; ch <= s->fbw_channels; ch++) {
243  CoefSumType energy_ch, energy_cpl;
244  if (!block->channel_in_cpl[ch])
245  continue;
246  energy_cpl = energy[blk][CPL_CH][bnd];
247  energy_ch = energy[blk][ch][bnd];
248  blk1 = blk+1;
249  while (blk1 < s->num_blocks && !s->blocks[blk1].new_cpl_coords[ch]) {
250  if (s->blocks[blk1].cpl_in_use) {
251  energy_cpl += energy[blk1][CPL_CH][bnd];
252  energy_ch += energy[blk1][ch][bnd];
253  }
254  blk1++;
255  }
256  cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl);
257  }
258  blk = blk1;
259  }
260  }
261 
262  /* calculate exponents/mantissas for coupling coordinates */
263  for (blk = 0; blk < s->num_blocks; blk++) {
264  AC3Block *block = &s->blocks[blk];
265  if (!block->cpl_in_use)
266  continue;
267 
268 #if CONFIG_AC3ENC_FLOAT
269  s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1],
270  cpl_coords[blk][1],
271  s->fbw_channels * 16);
272 #endif
274  fixed_cpl_coords[blk][1],
275  s->fbw_channels * 16);
276 
277  for (ch = 1; ch <= s->fbw_channels; ch++) {
278  int bnd, min_exp, max_exp, master_exp;
279 
280  if (!block->new_cpl_coords[ch])
281  continue;
282 
283  /* determine master exponent */
284  min_exp = max_exp = block->cpl_coord_exp[ch][0];
285  for (bnd = 1; bnd < s->num_cpl_bands; bnd++) {
286  int exp = block->cpl_coord_exp[ch][bnd];
287  min_exp = FFMIN(exp, min_exp);
288  max_exp = FFMAX(exp, max_exp);
289  }
290  master_exp = ((max_exp - 15) + 2) / 3;
291  master_exp = FFMAX(master_exp, 0);
292  while (min_exp < master_exp * 3)
293  master_exp--;
294  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
295  block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] -
296  master_exp * 3, 0, 15);
297  }
298  block->cpl_master_exp[ch] = master_exp;
299 
300  /* quantize mantissas */
301  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
302  int cpl_exp = block->cpl_coord_exp[ch][bnd];
303  int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24;
304  if (cpl_exp == 15)
305  cpl_mant >>= 1;
306  else
307  cpl_mant -= 16;
308 
309  block->cpl_coord_mant[ch][bnd] = cpl_mant;
310  }
311  }
312  }
313 
314  if (CONFIG_EAC3_ENCODER && s->eac3)
316 }
317 
318 
319 /*
320  * Determine rematrixing flags for each block and band.
321  */
323 {
324  int nb_coefs;
325  int blk, bnd;
326  AC3Block *block, *block0 = NULL;
327 
329  return;
330 
331  for (blk = 0; blk < s->num_blocks; blk++) {
332  block = &s->blocks[blk];
333  block->new_rematrixing_strategy = !blk;
334 
335  block->num_rematrixing_bands = 4;
336  if (block->cpl_in_use) {
337  block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61);
338  block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37);
339  if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands)
340  block->new_rematrixing_strategy = 1;
341  }
342  nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
343 
344  if (!s->rematrixing_enabled) {
345  block0 = block;
346  continue;
347  }
348 
349  for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
350  /* calculate sum of squared coeffs for one band in one block */
351  int start = ff_ac3_rematrix_band_tab[bnd];
352  int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
353  CoefSumType sum[4];
354  sum_square_butterfly(s, sum, block->mdct_coef[1] + start,
355  block->mdct_coef[2] + start, end - start);
356 
357  /* compare sums to determine if rematrixing will be used for this band */
358  if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1]))
359  block->rematrixing_flags[bnd] = 1;
360  else
361  block->rematrixing_flags[bnd] = 0;
362 
363  /* determine if new rematrixing flags will be sent */
364  if (blk &&
365  block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) {
366  block->new_rematrixing_strategy = 1;
367  }
368  }
369  block0 = block;
370  }
371 }
372 
373 
375  const AVFrame *frame, int *got_packet_ptr)
376 {
378  int ret;
379 
381  ret = ff_ac3_validate_metadata(s);
382  if (ret)
383  return ret;
384  }
385 
386  if (s->bit_alloc.sr_code == 1 || s->eac3)
388 
389  copy_input_samples(s, (SampleType **)frame->extended_data);
390 
391  apply_mdct(s);
392 
393  if (s->fixed_point)
395 
396  clip_coefficients(&s->adsp, s->blocks[0].mdct_coef[1],
397  AC3_MAX_COEFS * s->num_blocks * s->channels);
398 
399  s->cpl_on = s->cpl_enabled;
401 
402  if (s->cpl_on)
404 
406 
407  if (!s->fixed_point)
409 
411 
413 
415  if (ret) {
416  av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
417  return ret;
418  }
419 
421 
423 
424  if ((ret = ff_alloc_packet2(avctx, avpkt, s->frame_size, 0)) < 0)
425  return ret;
426  ff_ac3_output_frame(s, avpkt->data);
427 
428  if (frame->pts != AV_NOPTS_VALUE)
430 
431  *got_packet_ptr = 1;
432  return 0;
433 }
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:308
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
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:140
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
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
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:33
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 AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:2060
#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:526
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
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.
AVCodecContext * avctx
parent AVCodecContext
Definition: ac3enc.h:165
static void compute_rematrixing_strategy(AC3EncodeContext *s)
void * priv_data
Definition: avcodec.h:553
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:154
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
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:261
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: packet.h:332
int i
Definition: input.c:406
#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