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 #include "libavutil/mem_internal.h"
34 
35 #include "audiodsp.h"
36 #include "internal.h"
37 #include "ac3enc.h"
38 #include "eac3enc.h"
39 
40 
42 {
43  int ch;
44 
47  return AVERROR(ENOMEM);
48 
49  for (ch = 0; ch < s->channels; ch++) {
51  sizeof(**s->planar_samples))))
52  return AVERROR(ENOMEM);
53  }
54  return 0;
55 }
56 
57 
58 /*
59  * Copy input samples.
60  * Channels are reordered from FFmpeg's default order to AC-3 order.
61  */
63 {
64  int ch;
65 
66  /* copy and remap input samples */
67  for (ch = 0; ch < s->channels; ch++) {
68  /* copy last 256 samples of previous frame to the start of the current frame */
69  memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_BLOCK_SIZE * s->num_blocks],
70  AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0]));
71 
72  /* copy new samples for current frame */
73  memcpy(&s->planar_samples[ch][AC3_BLOCK_SIZE],
74  samples[s->channel_map[ch]],
75  AC3_BLOCK_SIZE * s->num_blocks * sizeof(s->planar_samples[0][0]));
76  }
77 }
78 
79 
80 /*
81  * Apply the MDCT to input samples to generate frequency coefficients.
82  * This applies the KBD window and normalizes the input to reduce precision
83  * loss due to fixed-point calculations.
84  */
86 {
87  int blk, ch;
88 
89  for (ch = 0; ch < s->channels; ch++) {
90  for (blk = 0; blk < s->num_blocks; blk++) {
91  AC3Block *block = &s->blocks[blk];
92  const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
93 
94  s->fdsp->vector_fmul(s->windowed_samples, input_samples,
97  &input_samples[AC3_BLOCK_SIZE],
98  s->mdct_window, AC3_BLOCK_SIZE);
99 
100  s->mdct.mdct_calc(&s->mdct, block->mdct_coef[ch+1],
101  s->windowed_samples);
102  }
103  }
104 }
105 
106 
107 /*
108  * Calculate coupling channel and coupling coordinates.
109  */
111 {
113 #if AC3ENC_FLOAT
114  LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
115 #else
116  int32_t (*fixed_cpl_coords)[AC3_MAX_CHANNELS][16] = cpl_coords;
117 #endif
118  int av_uninit(blk), ch, bnd, i, j;
119  CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}};
120  int cpl_start, num_cpl_coefs;
121 
122  memset(cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
123 #if AC3ENC_FLOAT
124  memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
125 #endif
126 
127  /* align start to 16-byte boundary. align length to multiple of 32.
128  note: coupling start bin % 4 will always be 1 */
129  cpl_start = s->start_freq[CPL_CH] - 1;
130  num_cpl_coefs = FFALIGN(s->num_cpl_subbands * 12 + 1, 32);
131  cpl_start = FFMIN(256, cpl_start + num_cpl_coefs) - num_cpl_coefs;
132 
133  /* calculate coupling channel from fbw channels */
134  for (blk = 0; blk < s->num_blocks; blk++) {
135  AC3Block *block = &s->blocks[blk];
136  CoefType *cpl_coef = &block->mdct_coef[CPL_CH][cpl_start];
137  if (!block->cpl_in_use)
138  continue;
139  memset(cpl_coef, 0, num_cpl_coefs * sizeof(*cpl_coef));
140  for (ch = 1; ch <= s->fbw_channels; ch++) {
141  CoefType *ch_coef = &block->mdct_coef[ch][cpl_start];
142  if (!block->channel_in_cpl[ch])
143  continue;
144  for (i = 0; i < num_cpl_coefs; i++)
145  cpl_coef[i] += ch_coef[i];
146  }
147 
148  /* coefficients must be clipped in order to be encoded */
149  clip_coefficients(&s->adsp, cpl_coef, num_cpl_coefs);
150  }
151 
152  /* calculate energy in each band in coupling channel and each fbw channel */
153  /* TODO: possibly use SIMD to speed up energy calculation */
154  bnd = 0;
155  i = s->start_freq[CPL_CH];
156  while (i < s->cpl_end_freq) {
157  int band_size = s->cpl_band_sizes[bnd];
158  for (ch = CPL_CH; ch <= s->fbw_channels; ch++) {
159  for (blk = 0; blk < s->num_blocks; blk++) {
160  AC3Block *block = &s->blocks[blk];
161  if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch]))
162  continue;
163  for (j = 0; j < band_size; j++) {
164  CoefType v = block->mdct_coef[ch][i+j];
165  MAC_COEF(energy[blk][ch][bnd], v, v);
166  }
167  }
168  }
169  i += band_size;
170  bnd++;
171  }
172 
173  /* calculate coupling coordinates for all blocks for all channels */
174  for (blk = 0; blk < s->num_blocks; blk++) {
175  AC3Block *block = &s->blocks[blk];
176  if (!block->cpl_in_use)
177  continue;
178  for (ch = 1; ch <= s->fbw_channels; ch++) {
179  if (!block->channel_in_cpl[ch])
180  continue;
181  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
182  cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd],
183  energy[blk][CPL_CH][bnd]);
184  }
185  }
186  }
187 
188  /* determine which blocks to send new coupling coordinates for */
189  for (blk = 0; blk < s->num_blocks; blk++) {
190  AC3Block *block = &s->blocks[blk];
191  AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL;
192 
193  memset(block->new_cpl_coords, 0, sizeof(block->new_cpl_coords));
194 
195  if (block->cpl_in_use) {
196  /* send new coordinates if this is the first block, if previous
197  * block did not use coupling but this block does, the channels
198  * using coupling has changed from the previous block, or the
199  * coordinate difference from the last block for any channel is
200  * greater than a threshold value. */
201  if (blk == 0 || !block0->cpl_in_use) {
202  for (ch = 1; ch <= s->fbw_channels; ch++)
203  block->new_cpl_coords[ch] = 1;
204  } else {
205  for (ch = 1; ch <= s->fbw_channels; ch++) {
206  if (!block->channel_in_cpl[ch])
207  continue;
208  if (!block0->channel_in_cpl[ch]) {
209  block->new_cpl_coords[ch] = 1;
210  } else {
211  CoefSumType coord_diff = 0;
212  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
213  coord_diff += FFABS(cpl_coords[blk-1][ch][bnd] -
214  cpl_coords[blk ][ch][bnd]);
215  }
216  coord_diff /= s->num_cpl_bands;
217  if (coord_diff > NEW_CPL_COORD_THRESHOLD)
218  block->new_cpl_coords[ch] = 1;
219  }
220  }
221  }
222  }
223  }
224 
225  /* calculate final coupling coordinates, taking into account reusing of
226  coordinates in successive blocks */
227  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
228  blk = 0;
229  while (blk < s->num_blocks) {
230  int av_uninit(blk1);
231  AC3Block *block = &s->blocks[blk];
232 
233  if (!block->cpl_in_use) {
234  blk++;
235  continue;
236  }
237 
238  for (ch = 1; ch <= s->fbw_channels; ch++) {
239  CoefSumType energy_ch, energy_cpl;
240  if (!block->channel_in_cpl[ch])
241  continue;
242  energy_cpl = energy[blk][CPL_CH][bnd];
243  energy_ch = energy[blk][ch][bnd];
244  blk1 = blk+1;
245  while (blk1 < s->num_blocks && !s->blocks[blk1].new_cpl_coords[ch]) {
246  if (s->blocks[blk1].cpl_in_use) {
247  energy_cpl += energy[blk1][CPL_CH][bnd];
248  energy_ch += energy[blk1][ch][bnd];
249  }
250  blk1++;
251  }
252  cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl);
253  }
254  blk = blk1;
255  }
256  }
257 
258  /* calculate exponents/mantissas for coupling coordinates */
259  for (blk = 0; blk < s->num_blocks; blk++) {
260  AC3Block *block = &s->blocks[blk];
261  if (!block->cpl_in_use)
262  continue;
263 
264 #if AC3ENC_FLOAT
265  s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1],
266  cpl_coords[blk][1],
267  s->fbw_channels * 16);
268 #endif
270  fixed_cpl_coords[blk][1],
271  s->fbw_channels * 16);
272 
273  for (ch = 1; ch <= s->fbw_channels; ch++) {
274  int bnd, min_exp, max_exp, master_exp;
275 
276  if (!block->new_cpl_coords[ch])
277  continue;
278 
279  /* determine master exponent */
280  min_exp = max_exp = block->cpl_coord_exp[ch][0];
281  for (bnd = 1; bnd < s->num_cpl_bands; bnd++) {
282  int exp = block->cpl_coord_exp[ch][bnd];
283  min_exp = FFMIN(exp, min_exp);
284  max_exp = FFMAX(exp, max_exp);
285  }
286  master_exp = ((max_exp - 15) + 2) / 3;
287  master_exp = FFMAX(master_exp, 0);
288  while (min_exp < master_exp * 3)
289  master_exp--;
290  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
291  block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] -
292  master_exp * 3, 0, 15);
293  }
294  block->cpl_master_exp[ch] = master_exp;
295 
296  /* quantize mantissas */
297  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
298  int cpl_exp = block->cpl_coord_exp[ch][bnd];
299  int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24;
300  if (cpl_exp == 15)
301  cpl_mant >>= 1;
302  else
303  cpl_mant -= 16;
304 
305  block->cpl_coord_mant[ch][bnd] = cpl_mant;
306  }
307  }
308  }
309 
310  if (AC3ENC_FLOAT && CONFIG_EAC3_ENCODER && s->eac3)
312 }
313 
314 
315 /*
316  * Determine rematrixing flags for each block and band.
317  */
319 {
320  int nb_coefs;
321  int blk, bnd;
322  AC3Block *block, *block0 = NULL;
323 
325  return;
326 
327  for (blk = 0; blk < s->num_blocks; blk++) {
328  block = &s->blocks[blk];
329  block->new_rematrixing_strategy = !blk;
330 
331  block->num_rematrixing_bands = 4;
332  if (block->cpl_in_use) {
333  block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61);
334  block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37);
335  if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands)
336  block->new_rematrixing_strategy = 1;
337  }
338  nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
339 
340  if (!s->rematrixing_enabled) {
341  block0 = block;
342  continue;
343  }
344 
345  for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
346  /* calculate sum of squared coeffs for one band in one block */
347  int start = ff_ac3_rematrix_band_tab[bnd];
348  int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
349  CoefSumType sum[4];
350  sum_square_butterfly(s, sum, block->mdct_coef[1] + start,
351  block->mdct_coef[2] + start, end - start);
352 
353  /* compare sums to determine if rematrixing will be used for this band */
354  if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1]))
355  block->rematrixing_flags[bnd] = 1;
356  else
357  block->rematrixing_flags[bnd] = 0;
358 
359  /* determine if new rematrixing flags will be sent */
360  if (blk &&
361  block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) {
362  block->new_rematrixing_strategy = 1;
363  }
364  }
365  block0 = block;
366  }
367 }
368 
369 
371  const AVFrame *frame, int *got_packet_ptr)
372 {
374  int ret;
375 
377  ret = ff_ac3_validate_metadata(s);
378  if (ret)
379  return ret;
380  }
381 
382  if (s->bit_alloc.sr_code == 1 || (AC3ENC_FLOAT && s->eac3))
384 
385  copy_input_samples(s, (SampleType **)frame->extended_data);
386 
387  apply_mdct(s);
388 
389  s->cpl_on = s->cpl_enabled;
391 
392  if (s->cpl_on)
394 
396 
397 #if AC3ENC_FLOAT
399 #endif
400 
401  return ff_ac3_encode_frame_common_end(avctx, avpkt, frame, got_packet_ptr);
402 }
uint8_t new_rematrixing_strategy
send new rematrixing flags in this block
Definition: ac3enc.h:144
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
static void apply_mdct(AC3EncodeContext *s)
static int allocate_sample_buffers(AC3EncodeContext *s)
uint8_t ** cpl_coord_exp
coupling coord exponents (cplcoexp)
Definition: ac3enc.h:142
#define AC3ENC_FLOAT
Definition: ac3enc.h:43
#define AC3_WINDOW_SIZE
Definition: ac3.h:39
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:102
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:214
#define blk(i)
Definition: sha.c:185
AC3BitAllocParameters bit_alloc
bit allocation parameters
Definition: ac3enc.h:231
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:1862
int rematrixing_enabled
stereo rematrixing enabled
Definition: ac3enc.h:223
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:130
static void apply_channel_coupling(AC3EncodeContext *s)
void(* extract_exponents)(uint8_t *exp, int32_t *coef, int nb_coefs)
Definition: ac3dsp.h:94
int channel_mode
channel mode (acmod)
Definition: ac3enc.h:202
int num_cpl_subbands
number of coupling subbands (ncplsubnd)
Definition: ac3enc.h:219
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:146
int fbw_channels
number of full-bandwidth channels (nfchans)
Definition: ac3enc.h:196
uint8_t new_cpl_coords[AC3_MAX_CHANNELS]
send new coupling coordinates (cplcoe)
Definition: ac3enc.h:151
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
uint8_t cpl_master_exp[AC3_MAX_CHANNELS]
coupling coord master exponents (mstrcplco)
Definition: ac3enc.h:152
void(* vector_fmul_reverse)(int *dst, const int *src0, const int *src1, int len)
Definition: fixed_dsp.h:116
AVFixedDSPContext * fdsp
Definition: ac3enc.h:170
int num_rematrixing_bands
number of rematrixing bands
Definition: ac3enc.h:145
AC3DSPContext ac3dsp
AC-3 optimized functions.
Definition: ac3enc.h:173
int num_cpl_bands
number of coupling bands (ncplbnd)
Definition: ac3enc.h:220
#define FFALIGN(x, a)
Definition: macros.h:48
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:149
AC3EncOptions options
encoding options
Definition: ac3enc.h:163
int channels
total number of channels (nchans)
Definition: ac3enc.h:197
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
Definition: ac3.h:32
#define AC3_NAME(x)
Definition: ac3enc.h:65
void(* mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:104
int cpl_on
coupling turned on for this frame
Definition: ac3enc.h:217
#define FFMAX(a, b)
Definition: common.h:94
int cpl_in_use
coupling in use for this block (cplinu)
Definition: ac3enc.h:148
int cpl_enabled
coupling enabled for all frames
Definition: ac3enc.h:218
int8_t exp
Definition: eval.c:72
#define AC3_BLOCK_SIZE
Definition: ac3.h:36
int32_t SampleType
Definition: ac3enc.h:70
Data for a single audio block.
Definition: ac3enc.h:133
common internal API header
#define FFMIN(a, b)
Definition: common.h:96
AudioDSPContext adsp
Definition: ac3enc.h:166
int eac3
indicates if this is E-AC-3 vs. AC-3
Definition: ac3enc.h:180
static void scale_coefficients(AC3EncodeContext *s)
Definition: ac3enc_float.c:50
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:185
FFTContext mdct
FFT context for MDCT calculation.
Definition: ac3enc.h:174
int AC3_NAME() encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
const SampleType * mdct_window
MDCT window function array.
Definition: ac3enc.h:175
SampleType ** planar_samples
Definition: ac3enc.h:240
static void clip_coefficients(AudioDSPContext *adsp, int32_t *coef, unsigned int len)
Definition: ac3enc_fixed.c:58
#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:68
#define NEW_CPL_COORD_THRESHOLD
Definition: ac3enc.h:69
main external API structure.
Definition: avcodec.h:531
const uint8_t * channel_map
channel map used to reorder channels
Definition: ac3enc.h:203
void(* vector_fmul)(int *dst, const int *src0, const int *src1, int len)
Fixed-point multiplication that calculates the entry wise product of two vectors of integers and stor...
Definition: fixed_dsp.h:113
int end_freq[AC3_MAX_CHANNELS]
end frequency bin (endmant)
Definition: ac3enc.h:155
#define AC3_MAX_BLOCKS
Definition: ac3.h:37
AC-3 encoder private context.
Definition: ac3enc.h:161
AC3Block blocks[AC3_MAX_BLOCKS]
per-block info
Definition: ac3enc.h:177
SampleType * windowed_samples
Definition: ac3enc.h:239
int num_blocks
number of blocks per frame
Definition: ac3enc.h:188
#define AC3_FRAME_SIZE
Definition: ac3.h:38
int ff_ac3_encode_frame_common_end(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: ac3enc.c:1674
int cpl_end_freq
coupling channel end frequency bin
Definition: ac3enc.h:215
uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]
number of coeffs in each coupling band
Definition: ac3enc.h:221
common internal api header.
AVCodecContext * avctx
parent AVCodecContext
Definition: ac3enc.h:164
static void compute_rematrixing_strategy(AC3EncodeContext *s)
void * priv_data
Definition: avcodec.h:558
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
#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
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 void sum_square_butterfly(AC3EncodeContext *s, int64_t sum[4], const int32_t *coef0, const int32_t *coef1, int len)
Definition: ac3enc_fixed.c:48
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:103
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:203
E-AC-3 encoder.
This structure stores compressed data.
Definition: packet.h:340
int i
Definition: input.c:407
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:56