FFmpeg  4.3
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,
98  s->mdct_window, AC3_WINDOW_SIZE);
99 #else
100  s->ac3dsp.apply_window_int16(s->windowed_samples, input_samples,
101  s->mdct_window, AC3_WINDOW_SIZE);
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
276  s->ac3dsp.extract_exponents(block->cpl_coord_exp[1],
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 
331  if (s->channel_mode != AC3_CHMODE_STEREO)
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 
383  if (s->options.allow_per_frame_metadata) {
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 }
allocate_sample_buffers
int AC3_NAME() allocate_sample_buffers(AC3EncodeContext *s)
Definition: ac3enc_template.c:40
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
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
copy_input_samples
static void copy_input_samples(AC3EncodeContext *s, SampleType **samples)
Definition: ac3enc_template.c:64
AC3Block::channel_in_cpl
uint8_t channel_in_cpl[AC3_MAX_CHANNELS]
channel in coupling (chincpl)
Definition: ac3enc.h:150
ff_ac3_quantize_mantissas
void ff_ac3_quantize_mantissas(AC3EncodeContext *s)
Quantize mantissas using coefficients, exponents, and bit allocation pointers.
Definition: ac3enc.c:1300
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
internal.h
AC3_MAX_COEFS
#define AC3_MAX_COEFS
Definition: ac3.h:35
samples
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new samples
Definition: fate.txt:139
ff_ac3_apply_rematrixing
void ff_ac3_apply_rematrixing(AC3EncodeContext *s)
Apply stereo rematrixing to coefficients based on rematrixing flags.
Definition: ac3enc.c:272
encode_frame
int AC3_NAME() encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: ac3enc_template.c:377
ff_ac3_validate_metadata
int ff_ac3_validate_metadata(AC3EncodeContext *s)
Validate metadata options as set by AVOption system.
Definition: ac3enc.c:1833
ff_eac3_set_cpl_states
void ff_eac3_set_cpl_states(AC3EncodeContext *s)
Set coupling states.
Definition: eac3enc.c:95
ff_ac3_group_exponents
void ff_ac3_group_exponents(AC3EncodeContext *s)
Group exponents.
Definition: ac3enc.c:579
AC3_MAX_BLOCKS
#define AC3_MAX_BLOCKS
Definition: ac3.h:37
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
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
ff_samples_to_time_base
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:256
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
s
#define s(width, name)
Definition: cbs_vp9.c:257
SampleType
int16_t SampleType
Definition: ac3enc.h:70
blk
#define blk(i)
Definition: sha.c:185
int32_t
int32_t
Definition: audio_convert.c:194
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
ch
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 &&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
NULL
#define NULL
Definition: coverity.c:32
ac3enc.h
CoefSumType
int64_t CoefSumType
Definition: ac3enc.h:72
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
CPL_CH
#define CPL_CH
coupling channel index
Definition: ac3.h:33
AC3_CHMODE_STEREO
@ AC3_CHMODE_STEREO
Definition: ac3.h:126
AC3EncodeContext
AC-3 encoder private context.
Definition: ac3enc.h:162
exp
int8_t exp
Definition: eval.c:72
AC3Block
Data for a single audio block.
Definition: ac3enc.h:133
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
clip_coefficients
static void clip_coefficients(AudioDSPContext *adsp, int32_t *coef, unsigned int len)
Definition: ac3enc_fixed.c:87
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
apply_channel_coupling
static void apply_channel_coupling(AC3EncodeContext *s)
Definition: ac3enc_template.c:117
ff_ac3_compute_bit_allocation
int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
Definition: ac3enc.c:1146
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
calc_cpl_coord
static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl)
Definition: ac3enc_fixed.c:97
attributes.h
eac3enc.h
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
AC3_NAME
#define AC3_NAME(x)
Definition: ac3enc.h:65
CONFIG_EAC3_ENCODER
#define CONFIG_EAC3_ENCODER
Definition: config.h:1355
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
internal.h
AC3Block::rematrixing_flags
uint8_t rematrixing_flags[4]
rematrixing flags
Definition: ac3enc.h:147
compute_rematrixing_strategy
static void compute_rematrixing_strategy(AC3EncodeContext *s)
Definition: ac3enc_template.c:325
AC3EncodeContext::num_blocks
int num_blocks
number of blocks per frame
Definition: ac3enc.h:185
sum_square_butterfly
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
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
ret
ret
Definition: filter_design.txt:187
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:264
scale_coefficients
static void scale_coefficients(AC3EncodeContext *s)
Definition: ac3enc_fixed.c:64
AC3EncodeContext::cpl_end_freq
int cpl_end_freq
coupling channel end frequency bin
Definition: ac3enc.h:212
AC3Block::num_rematrixing_bands
int num_rematrixing_bands
number of rematrixing bands
Definition: ac3enc.h:146
AVCodecContext
main external API structure.
Definition: avcodec.h:526
FF_ALLOC_ARRAY_OR_GOTO
#define FF_ALLOC_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)
Definition: internal.h:158
apply_mdct
static void apply_mdct(AC3EncodeContext *s)
Definition: ac3enc_template.c:87
CoefType
int32_t CoefType
Definition: ac3enc.h:71
AC3_FRAME_SIZE
#define AC3_FRAME_SIZE
Definition: ac3.h:38
FF_ALLOC_OR_GOTO
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
Definition: internal.h:140
audiodsp.h
MAC_COEF
#define MAC_COEF(d, a, b)
Definition: ac3enc.h:66
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AC3EncodeContext::avctx
AVCodecContext * avctx
parent AVCodecContext
Definition: ac3enc.h:165
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
normalize_samples
static int normalize_samples(AC3EncodeContext *s)
Definition: ac3enc_fixed.c:50
FF_ALLOCZ_OR_GOTO
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: internal.h:149
ff_alloc_packet2
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
AC3_WINDOW_SIZE
#define AC3_WINDOW_SIZE
Definition: ac3.h:39
AC3Block::cpl_in_use
int cpl_in_use
coupling in use for this block (cplinu)
Definition: ac3enc.h:149
AC3_BLOCK_SIZE
#define AC3_BLOCK_SIZE
Definition: ac3.h:36
NEW_CPL_COORD_THRESHOLD
#define NEW_CPL_COORD_THRESHOLD
Definition: ac3enc.h:69