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>
7 * This file is part of FFmpeg.
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.
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.
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
26 * AC-3 encoder float/fixed template
31 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
39 /* prototypes for static functions in ac3enc_fixed.c and ac3enc_float.c */
41 static void scale_coefficients(AC3EncodeContext
*s
);
43 static int normalize_samples(AC3EncodeContext
*s
);
45 static void clip_coefficients(AudioDSPContext
*adsp
, CoefType
*coef
,
48 static CoefType
calc_cpl_coord(CoefSumType energy_ch
, CoefSumType energy_cpl
);
50 static void sum_square_butterfly(AC3EncodeContext
*s
, CoefSumType sum
[4],
51 const CoefType
*coef0
, const CoefType
*coef1
,
54 int AC3_NAME(allocate_sample_buffers
)(AC3EncodeContext
*s
)
58 FF_ALLOC_OR_GOTO(s
->avctx
, s
->windowed_samples
, AC3_WINDOW_SIZE
*
59 sizeof(*s
->windowed_samples
), alloc_fail
);
60 FF_ALLOC_ARRAY_OR_GOTO(s
->avctx
, s
->planar_samples
, s
->channels
, sizeof(*s
->planar_samples
),
62 for (ch
= 0; ch
< s
->channels
; ch
++) {
63 FF_ALLOCZ_OR_GOTO(s
->avctx
, s
->planar_samples
[ch
],
64 (AC3_FRAME_SIZE
+AC3_BLOCK_SIZE
) * sizeof(**s
->planar_samples
),
70 return AVERROR(ENOMEM
);
76 * Channels are reordered from FFmpeg's default order to AC-3 order.
78 static void copy_input_samples(AC3EncodeContext
*s
, SampleType
**samples
)
82 /* copy and remap input samples */
83 for (ch
= 0; ch
< s
->channels
; ch
++) {
84 /* copy last 256 samples of previous frame to the start of the current frame */
85 memcpy(&s
->planar_samples
[ch
][0], &s
->planar_samples
[ch
][AC3_BLOCK_SIZE
* s
->num_blocks
],
86 AC3_BLOCK_SIZE
* sizeof(s
->planar_samples
[0][0]));
88 /* copy new samples for current frame */
89 memcpy(&s
->planar_samples
[ch
][AC3_BLOCK_SIZE
],
90 samples
[s
->channel_map
[ch
]],
91 AC3_BLOCK_SIZE
* s
->num_blocks
* sizeof(s
->planar_samples
[0][0]));
97 * Apply the MDCT to input samples to generate frequency coefficients.
98 * This applies the KBD window and normalizes the input to reduce precision
99 * loss due to fixed-point calculations.
101 static void apply_mdct(AC3EncodeContext
*s
)
105 for (ch
= 0; ch
< s
->channels
; ch
++) {
106 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
107 AC3Block
*block
= &s
->blocks
[blk
];
108 const SampleType
*input_samples
= &s
->planar_samples
[ch
][blk
* AC3_BLOCK_SIZE
];
110 #if CONFIG_AC3ENC_FLOAT
111 s
->fdsp
->vector_fmul(s
->windowed_samples
, input_samples
,
112 s
->mdct_window
, AC3_WINDOW_SIZE
);
114 s
->ac3dsp
.apply_window_int16(s
->windowed_samples
, input_samples
,
115 s
->mdct_window
, AC3_WINDOW_SIZE
);
119 block
->coeff_shift
[ch
+1] = normalize_samples(s
);
121 s
->mdct
.mdct_calcw(&s
->mdct
, block
->mdct_coef
[ch
+1],
122 s
->windowed_samples
);
129 * Calculate coupling channel and coupling coordinates.
131 static void apply_channel_coupling(AC3EncodeContext
*s
)
133 LOCAL_ALIGNED_16(CoefType
, cpl_coords
, [AC3_MAX_BLOCKS
], [AC3_MAX_CHANNELS
][16]);
134 #if CONFIG_AC3ENC_FLOAT
135 LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords
, [AC3_MAX_BLOCKS
], [AC3_MAX_CHANNELS
][16]);
137 int32_t (*fixed_cpl_coords
)[AC3_MAX_CHANNELS
][16] = cpl_coords
;
139 int av_uninit(blk
), ch
, bnd
, i
, j
;
140 CoefSumType energy
[AC3_MAX_BLOCKS
][AC3_MAX_CHANNELS
][16] = {{{0}}};
141 int cpl_start
, num_cpl_coefs
;
143 memset(cpl_coords
, 0, AC3_MAX_BLOCKS
* sizeof(*cpl_coords
));
144 #if CONFIG_AC3ENC_FLOAT
145 memset(fixed_cpl_coords
, 0, AC3_MAX_BLOCKS
* sizeof(*cpl_coords
));
148 /* align start to 16-byte boundary. align length to multiple of 32.
149 note: coupling start bin % 4 will always be 1 */
150 cpl_start
= s
->start_freq
[CPL_CH
] - 1;
151 num_cpl_coefs
= FFALIGN(s
->num_cpl_subbands
* 12 + 1, 32);
152 cpl_start
= FFMIN(256, cpl_start
+ num_cpl_coefs
) - num_cpl_coefs
;
154 /* calculate coupling channel from fbw channels */
155 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
156 AC3Block
*block
= &s
->blocks
[blk
];
157 CoefType
*cpl_coef
= &block
->mdct_coef
[CPL_CH
][cpl_start
];
158 if (!block
->cpl_in_use
)
160 memset(cpl_coef
, 0, num_cpl_coefs
* sizeof(*cpl_coef
));
161 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
162 CoefType
*ch_coef
= &block
->mdct_coef
[ch
][cpl_start
];
163 if (!block
->channel_in_cpl
[ch
])
165 for (i
= 0; i
< num_cpl_coefs
; i
++)
166 cpl_coef
[i
] += ch_coef
[i
];
169 /* coefficients must be clipped in order to be encoded */
170 clip_coefficients(&s
->adsp
, cpl_coef
, num_cpl_coefs
);
173 /* calculate energy in each band in coupling channel and each fbw channel */
174 /* TODO: possibly use SIMD to speed up energy calculation */
176 i
= s
->start_freq
[CPL_CH
];
177 while (i
< s
->cpl_end_freq
) {
178 int band_size
= s
->cpl_band_sizes
[bnd
];
179 for (ch
= CPL_CH
; ch
<= s
->fbw_channels
; ch
++) {
180 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
181 AC3Block
*block
= &s
->blocks
[blk
];
182 if (!block
->cpl_in_use
|| (ch
> CPL_CH
&& !block
->channel_in_cpl
[ch
]))
184 for (j
= 0; j
< band_size
; j
++) {
185 CoefType v
= block
->mdct_coef
[ch
][i
+j
];
186 MAC_COEF(energy
[blk
][ch
][bnd
], v
, v
);
194 /* calculate coupling coordinates for all blocks for all channels */
195 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
196 AC3Block
*block
= &s
->blocks
[blk
];
197 if (!block
->cpl_in_use
)
199 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
200 if (!block
->channel_in_cpl
[ch
])
202 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
203 cpl_coords
[blk
][ch
][bnd
] = calc_cpl_coord(energy
[blk
][ch
][bnd
],
204 energy
[blk
][CPL_CH
][bnd
]);
209 /* determine which blocks to send new coupling coordinates for */
210 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
211 AC3Block
*block
= &s
->blocks
[blk
];
212 AC3Block
*block0
= blk
? &s
->blocks
[blk
-1] : NULL
;
214 memset(block
->new_cpl_coords
, 0, sizeof(block
->new_cpl_coords
));
216 if (block
->cpl_in_use
) {
217 /* send new coordinates if this is the first block, if previous
218 * block did not use coupling but this block does, the channels
219 * using coupling has changed from the previous block, or the
220 * coordinate difference from the last block for any channel is
221 * greater than a threshold value. */
222 if (blk
== 0 || !block0
->cpl_in_use
) {
223 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
224 block
->new_cpl_coords
[ch
] = 1;
226 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
227 if (!block
->channel_in_cpl
[ch
])
229 if (!block0
->channel_in_cpl
[ch
]) {
230 block
->new_cpl_coords
[ch
] = 1;
232 CoefSumType coord_diff
= 0;
233 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
234 coord_diff
+= FFABS(cpl_coords
[blk
-1][ch
][bnd
] -
235 cpl_coords
[blk
][ch
][bnd
]);
237 coord_diff
/= s
->num_cpl_bands
;
238 if (coord_diff
> NEW_CPL_COORD_THRESHOLD
)
239 block
->new_cpl_coords
[ch
] = 1;
246 /* calculate final coupling coordinates, taking into account reusing of
247 coordinates in successive blocks */
248 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
250 while (blk
< s
->num_blocks
) {
252 AC3Block
*block
= &s
->blocks
[blk
];
254 if (!block
->cpl_in_use
) {
259 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
260 CoefSumType energy_ch
, energy_cpl
;
261 if (!block
->channel_in_cpl
[ch
])
263 energy_cpl
= energy
[blk
][CPL_CH
][bnd
];
264 energy_ch
= energy
[blk
][ch
][bnd
];
266 while (blk1
< s
->num_blocks
&& !s
->blocks
[blk1
].new_cpl_coords
[ch
]) {
267 if (s
->blocks
[blk1
].cpl_in_use
) {
268 energy_cpl
+= energy
[blk1
][CPL_CH
][bnd
];
269 energy_ch
+= energy
[blk1
][ch
][bnd
];
273 cpl_coords
[blk
][ch
][bnd
] = calc_cpl_coord(energy_ch
, energy_cpl
);
279 /* calculate exponents/mantissas for coupling coordinates */
280 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
281 AC3Block
*block
= &s
->blocks
[blk
];
282 if (!block
->cpl_in_use
)
285 #if CONFIG_AC3ENC_FLOAT
286 s
->ac3dsp
.float_to_fixed24(fixed_cpl_coords
[blk
][1],
288 s
->fbw_channels
* 16);
290 s
->ac3dsp
.extract_exponents(block
->cpl_coord_exp
[1],
291 fixed_cpl_coords
[blk
][1],
292 s
->fbw_channels
* 16);
294 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
295 int bnd
, min_exp
, max_exp
, master_exp
;
297 if (!block
->new_cpl_coords
[ch
])
300 /* determine master exponent */
301 min_exp
= max_exp
= block
->cpl_coord_exp
[ch
][0];
302 for (bnd
= 1; bnd
< s
->num_cpl_bands
; bnd
++) {
303 int exp
= block
->cpl_coord_exp
[ch
][bnd
];
304 min_exp
= FFMIN(exp
, min_exp
);
305 max_exp
= FFMAX(exp
, max_exp
);
307 master_exp
= ((max_exp
- 15) + 2) / 3;
308 master_exp
= FFMAX(master_exp
, 0);
309 while (min_exp
< master_exp
* 3)
311 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
312 block
->cpl_coord_exp
[ch
][bnd
] = av_clip(block
->cpl_coord_exp
[ch
][bnd
] -
313 master_exp
* 3, 0, 15);
315 block
->cpl_master_exp
[ch
] = master_exp
;
317 /* quantize mantissas */
318 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
319 int cpl_exp
= block
->cpl_coord_exp
[ch
][bnd
];
320 int cpl_mant
= (fixed_cpl_coords
[blk
][ch
][bnd
] << (5 + cpl_exp
+ master_exp
* 3)) >> 24;
326 block
->cpl_coord_mant
[ch
][bnd
] = cpl_mant
;
331 if (CONFIG_EAC3_ENCODER
&& s
->eac3
)
332 ff_eac3_set_cpl_states(s
);
337 * Determine rematrixing flags for each block and band.
339 static void compute_rematrixing_strategy(AC3EncodeContext
*s
)
343 AC3Block
*block
, *block0
= NULL
;
345 if (s
->channel_mode
!= AC3_CHMODE_STEREO
)
348 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
349 block
= &s
->blocks
[blk
];
350 block
->new_rematrixing_strategy
= !blk
;
352 block
->num_rematrixing_bands
= 4;
353 if (block
->cpl_in_use
) {
354 block
->num_rematrixing_bands
-= (s
->start_freq
[CPL_CH
] <= 61);
355 block
->num_rematrixing_bands
-= (s
->start_freq
[CPL_CH
] == 37);
356 if (blk
&& block
->num_rematrixing_bands
!= block0
->num_rematrixing_bands
)
357 block
->new_rematrixing_strategy
= 1;
359 nb_coefs
= FFMIN(block
->end_freq
[1], block
->end_freq
[2]);
361 if (!s
->rematrixing_enabled
) {
366 for (bnd
= 0; bnd
< block
->num_rematrixing_bands
; bnd
++) {
367 /* calculate sum of squared coeffs for one band in one block */
368 int start
= ff_ac3_rematrix_band_tab
[bnd
];
369 int end
= FFMIN(nb_coefs
, ff_ac3_rematrix_band_tab
[bnd
+1]);
371 sum_square_butterfly(s
, sum
, block
->mdct_coef
[1] + start
,
372 block
->mdct_coef
[2] + start
, end
- start
);
374 /* compare sums to determine if rematrixing will be used for this band */
375 if (FFMIN(sum
[2], sum
[3]) < FFMIN(sum
[0], sum
[1]))
376 block
->rematrixing_flags
[bnd
] = 1;
378 block
->rematrixing_flags
[bnd
] = 0;
380 /* determine if new rematrixing flags will be sent */
382 block
->rematrixing_flags
[bnd
] != block0
->rematrixing_flags
[bnd
]) {
383 block
->new_rematrixing_strategy
= 1;
391 int AC3_NAME(encode_frame
)(AVCodecContext
*avctx
, AVPacket
*avpkt
,
392 const AVFrame
*frame
, int *got_packet_ptr
)
394 AC3EncodeContext
*s
= avctx
->priv_data
;
397 if (s
->options
.allow_per_frame_metadata
) {
398 ret
= ff_ac3_validate_metadata(s
);
403 if (s
->bit_alloc
.sr_code
== 1 || s
->eac3
)
404 ff_ac3_adjust_frame_size(s
);
406 copy_input_samples(s
, (SampleType
**)frame
->extended_data
);
411 scale_coefficients(s
);
413 clip_coefficients(&s
->adsp
, s
->blocks
[0].mdct_coef
[1],
414 AC3_MAX_COEFS
* s
->num_blocks
* s
->channels
);
416 s
->cpl_on
= s
->cpl_enabled
;
417 ff_ac3_compute_coupling_strategy(s
);
420 apply_channel_coupling(s
);
422 compute_rematrixing_strategy(s
);
425 scale_coefficients(s
);
427 ff_ac3_apply_rematrixing(s
);
429 ff_ac3_process_exponents(s
);
431 ret
= ff_ac3_compute_bit_allocation(s
);
433 av_log(avctx
, AV_LOG_ERROR
, "Bit allocation failed. Try increasing the bitrate.\n");
437 ff_ac3_group_exponents(s
);
439 ff_ac3_quantize_mantissas(s
);
441 if ((ret
= ff_alloc_packet2(avctx
, avpkt
, s
->frame_size
)) < 0)
443 ff_ac3_output_frame(s
, avpkt
->data
);
445 if (frame
->pts
!= AV_NOPTS_VALUE
)
446 avpkt
->pts
= frame
->pts
- ff_samples_to_time_base(avctx
, avctx
->initial_padding
);