ffmpeg / libavcodec / ac3enc.c @ e6e98234
History | View | Annotate | Download (58.2 KB)
1 |
/*
|
---|---|
2 |
* The simplest AC-3 encoder
|
3 |
* Copyright (c) 2000 Fabrice Bellard
|
4 |
* Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
|
5 |
* Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
|
6 |
*
|
7 |
* This file is part of Libav.
|
8 |
*
|
9 |
* Libav 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 |
* Libav 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 Libav; 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 |
* The simplest AC-3 encoder.
|
27 |
*/
|
28 |
|
29 |
//#define DEBUG
|
30 |
//#define ASSERT_LEVEL 2
|
31 |
|
32 |
#include "libavutil/audioconvert.h" |
33 |
#include "libavutil/avassert.h" |
34 |
#include "libavutil/crc.h" |
35 |
#include "avcodec.h" |
36 |
#include "put_bits.h" |
37 |
#include "dsputil.h" |
38 |
#include "ac3dsp.h" |
39 |
#include "ac3.h" |
40 |
#include "audioconvert.h" |
41 |
|
42 |
|
43 |
#ifndef CONFIG_AC3ENC_FLOAT
|
44 |
#define CONFIG_AC3ENC_FLOAT 0 |
45 |
#endif
|
46 |
|
47 |
|
48 |
/** Maximum number of exponent groups. +1 for separate DC exponent. */
|
49 |
#define AC3_MAX_EXP_GROUPS 85 |
50 |
|
51 |
/* stereo rematrixing algorithms */
|
52 |
#define AC3_REMATRIXING_IS_STATIC 0x1 |
53 |
#define AC3_REMATRIXING_SUMS 0 |
54 |
#define AC3_REMATRIXING_NONE 1 |
55 |
#define AC3_REMATRIXING_ALWAYS 3 |
56 |
|
57 |
/** Scale a float value by 2^bits and convert to an integer. */
|
58 |
#define SCALE_FLOAT(a, bits) lrintf((a) * (float)(1 << (bits))) |
59 |
|
60 |
|
61 |
#if CONFIG_AC3ENC_FLOAT
|
62 |
#include "ac3enc_float.h" |
63 |
#else
|
64 |
#include "ac3enc_fixed.h" |
65 |
#endif
|
66 |
|
67 |
|
68 |
/**
|
69 |
* Data for a single audio block.
|
70 |
*/
|
71 |
typedef struct AC3Block { |
72 |
uint8_t **bap; ///< bit allocation pointers (bap)
|
73 |
CoefType **mdct_coef; ///< MDCT coefficients
|
74 |
int32_t **fixed_coef; ///< fixed-point MDCT coefficients
|
75 |
uint8_t **exp; ///< original exponents
|
76 |
uint8_t **grouped_exp; ///< grouped exponents
|
77 |
int16_t **psd; ///< psd per frequency bin
|
78 |
int16_t **band_psd; ///< psd per critical band
|
79 |
int16_t **mask; ///< masking curve
|
80 |
uint16_t **qmant; ///< quantized mantissas
|
81 |
uint8_t coeff_shift[AC3_MAX_CHANNELS]; ///< fixed-point coefficient shift values
|
82 |
uint8_t new_rematrixing_strategy; ///< send new rematrixing flags in this block
|
83 |
uint8_t rematrixing_flags[4]; ///< rematrixing flags |
84 |
} AC3Block; |
85 |
|
86 |
/**
|
87 |
* AC-3 encoder private context.
|
88 |
*/
|
89 |
typedef struct AC3EncodeContext { |
90 |
PutBitContext pb; ///< bitstream writer context
|
91 |
DSPContext dsp; |
92 |
AC3DSPContext ac3dsp; ///< AC-3 optimized functions
|
93 |
AC3MDCTContext mdct; ///< MDCT context
|
94 |
|
95 |
AC3Block blocks[AC3_MAX_BLOCKS]; ///< per-block info
|
96 |
|
97 |
int bitstream_id; ///< bitstream id (bsid) |
98 |
int bitstream_mode; ///< bitstream mode (bsmod) |
99 |
|
100 |
int bit_rate; ///< target bit rate, in bits-per-second |
101 |
int sample_rate; ///< sampling frequency, in Hz |
102 |
|
103 |
int frame_size_min; ///< minimum frame size in case rounding is necessary |
104 |
int frame_size; ///< current frame size in bytes |
105 |
int frame_size_code; ///< frame size code (frmsizecod) |
106 |
uint16_t crc_inv[2];
|
107 |
int bits_written; ///< bit count (used to avg. bitrate) |
108 |
int samples_written; ///< sample count (used to avg. bitrate) |
109 |
|
110 |
int fbw_channels; ///< number of full-bandwidth channels (nfchans) |
111 |
int channels; ///< total number of channels (nchans) |
112 |
int lfe_on; ///< indicates if there is an LFE channel (lfeon) |
113 |
int lfe_channel; ///< channel index of the LFE channel |
114 |
int channel_mode; ///< channel mode (acmod) |
115 |
const uint8_t *channel_map; ///< channel map used to reorder channels |
116 |
|
117 |
int cutoff; ///< user-specified cutoff frequency, in Hz |
118 |
int bandwidth_code[AC3_MAX_CHANNELS]; ///< bandwidth code (0 to 60) (chbwcod) |
119 |
int nb_coefs[AC3_MAX_CHANNELS];
|
120 |
|
121 |
int rematrixing; ///< determines how rematrixing strategy is calculated |
122 |
int num_rematrixing_bands; ///< number of rematrixing bands |
123 |
|
124 |
/* bitrate allocation control */
|
125 |
int slow_gain_code; ///< slow gain code (sgaincod) |
126 |
int slow_decay_code; ///< slow decay code (sdcycod) |
127 |
int fast_decay_code; ///< fast decay code (fdcycod) |
128 |
int db_per_bit_code; ///< dB/bit code (dbpbcod) |
129 |
int floor_code; ///< floor code (floorcod) |
130 |
AC3BitAllocParameters bit_alloc; ///< bit allocation parameters
|
131 |
int coarse_snr_offset; ///< coarse SNR offsets (csnroffst) |
132 |
int fast_gain_code[AC3_MAX_CHANNELS]; ///< fast gain codes (signal-to-mask ratio) (fgaincod) |
133 |
int fine_snr_offset[AC3_MAX_CHANNELS]; ///< fine SNR offsets (fsnroffst) |
134 |
int frame_bits_fixed; ///< number of non-coefficient bits for fixed parameters |
135 |
int frame_bits; ///< all frame bits except exponents and mantissas |
136 |
int exponent_bits; ///< number of bits used for exponents |
137 |
|
138 |
/* mantissa encoding */
|
139 |
int mant1_cnt, mant2_cnt, mant4_cnt; ///< mantissa counts for bap=1,2,4 |
140 |
uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
|
141 |
|
142 |
SampleType **planar_samples; |
143 |
uint8_t *bap_buffer; |
144 |
uint8_t *bap1_buffer; |
145 |
CoefType *mdct_coef_buffer; |
146 |
int32_t *fixed_coef_buffer; |
147 |
uint8_t *exp_buffer; |
148 |
uint8_t *grouped_exp_buffer; |
149 |
int16_t *psd_buffer; |
150 |
int16_t *band_psd_buffer; |
151 |
int16_t *mask_buffer; |
152 |
uint16_t *qmant_buffer; |
153 |
|
154 |
uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< exponent strategies
|
155 |
|
156 |
DECLARE_ALIGNED(16, SampleType, windowed_samples)[AC3_WINDOW_SIZE];
|
157 |
} AC3EncodeContext; |
158 |
|
159 |
|
160 |
/* prototypes for functions in ac3enc_fixed.c and ac3enc_float.c */
|
161 |
|
162 |
static av_cold void mdct_end(AC3MDCTContext *mdct); |
163 |
|
164 |
static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, |
165 |
int nbits);
|
166 |
|
167 |
static void mdct512(AC3MDCTContext *mdct, CoefType *out, SampleType *in); |
168 |
|
169 |
static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input, |
170 |
const SampleType *window, unsigned int len); |
171 |
|
172 |
static int normalize_samples(AC3EncodeContext *s); |
173 |
|
174 |
static void scale_coefficients(AC3EncodeContext *s); |
175 |
|
176 |
|
177 |
/**
|
178 |
* LUT for number of exponent groups.
|
179 |
* exponent_group_tab[exponent strategy-1][number of coefficients]
|
180 |
*/
|
181 |
static uint8_t exponent_group_tab[3][256]; |
182 |
|
183 |
|
184 |
/**
|
185 |
* List of supported channel layouts.
|
186 |
*/
|
187 |
static const int64_t ac3_channel_layouts[] = { |
188 |
AV_CH_LAYOUT_MONO, |
189 |
AV_CH_LAYOUT_STEREO, |
190 |
AV_CH_LAYOUT_2_1, |
191 |
AV_CH_LAYOUT_SURROUND, |
192 |
AV_CH_LAYOUT_2_2, |
193 |
AV_CH_LAYOUT_QUAD, |
194 |
AV_CH_LAYOUT_4POINT0, |
195 |
AV_CH_LAYOUT_5POINT0, |
196 |
AV_CH_LAYOUT_5POINT0_BACK, |
197 |
(AV_CH_LAYOUT_MONO | AV_CH_LOW_FREQUENCY), |
198 |
(AV_CH_LAYOUT_STEREO | AV_CH_LOW_FREQUENCY), |
199 |
(AV_CH_LAYOUT_2_1 | AV_CH_LOW_FREQUENCY), |
200 |
(AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY), |
201 |
(AV_CH_LAYOUT_2_2 | AV_CH_LOW_FREQUENCY), |
202 |
(AV_CH_LAYOUT_QUAD | AV_CH_LOW_FREQUENCY), |
203 |
(AV_CH_LAYOUT_4POINT0 | AV_CH_LOW_FREQUENCY), |
204 |
AV_CH_LAYOUT_5POINT1, |
205 |
AV_CH_LAYOUT_5POINT1_BACK, |
206 |
0
|
207 |
}; |
208 |
|
209 |
|
210 |
/**
|
211 |
* Adjust the frame size to make the average bit rate match the target bit rate.
|
212 |
* This is only needed for 11025, 22050, and 44100 sample rates.
|
213 |
*/
|
214 |
static void adjust_frame_size(AC3EncodeContext *s) |
215 |
{ |
216 |
while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
|
217 |
s->bits_written -= s->bit_rate; |
218 |
s->samples_written -= s->sample_rate; |
219 |
} |
220 |
s->frame_size = s->frame_size_min + |
221 |
2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
|
222 |
s->bits_written += s->frame_size * 8;
|
223 |
s->samples_written += AC3_FRAME_SIZE; |
224 |
} |
225 |
|
226 |
|
227 |
/**
|
228 |
* Deinterleave input samples.
|
229 |
* Channels are reordered from Libav's default order to AC-3 order.
|
230 |
*/
|
231 |
static void deinterleave_input_samples(AC3EncodeContext *s, |
232 |
const SampleType *samples)
|
233 |
{ |
234 |
int ch, i;
|
235 |
|
236 |
/* deinterleave and remap input samples */
|
237 |
for (ch = 0; ch < s->channels; ch++) { |
238 |
const SampleType *sptr;
|
239 |
int sinc;
|
240 |
|
241 |
/* copy last 256 samples of previous frame to the start of the current frame */
|
242 |
memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_FRAME_SIZE],
|
243 |
AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0])); |
244 |
|
245 |
/* deinterleave */
|
246 |
sinc = s->channels; |
247 |
sptr = samples + s->channel_map[ch]; |
248 |
for (i = AC3_BLOCK_SIZE; i < AC3_FRAME_SIZE+AC3_BLOCK_SIZE; i++) {
|
249 |
s->planar_samples[ch][i] = *sptr; |
250 |
sptr += sinc; |
251 |
} |
252 |
} |
253 |
} |
254 |
|
255 |
|
256 |
/**
|
257 |
* Apply the MDCT to input samples to generate frequency coefficients.
|
258 |
* This applies the KBD window and normalizes the input to reduce precision
|
259 |
* loss due to fixed-point calculations.
|
260 |
*/
|
261 |
static void apply_mdct(AC3EncodeContext *s) |
262 |
{ |
263 |
int blk, ch;
|
264 |
|
265 |
for (ch = 0; ch < s->channels; ch++) { |
266 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
267 |
AC3Block *block = &s->blocks[blk]; |
268 |
const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
|
269 |
|
270 |
apply_window(&s->dsp, s->windowed_samples, input_samples, s->mdct.window, AC3_WINDOW_SIZE); |
271 |
|
272 |
block->coeff_shift[ch] = normalize_samples(s); |
273 |
|
274 |
mdct512(&s->mdct, block->mdct_coef[ch], s->windowed_samples); |
275 |
} |
276 |
} |
277 |
} |
278 |
|
279 |
|
280 |
/**
|
281 |
* Initialize stereo rematrixing.
|
282 |
* If the strategy does not change for each frame, set the rematrixing flags.
|
283 |
*/
|
284 |
static void rematrixing_init(AC3EncodeContext *s) |
285 |
{ |
286 |
if (s->channel_mode == AC3_CHMODE_STEREO)
|
287 |
s->rematrixing = AC3_REMATRIXING_SUMS; |
288 |
else
|
289 |
s->rematrixing = AC3_REMATRIXING_NONE; |
290 |
/* NOTE: AC3_REMATRIXING_ALWAYS might be used in
|
291 |
the future in conjunction with channel coupling. */
|
292 |
|
293 |
if (s->rematrixing & AC3_REMATRIXING_IS_STATIC) {
|
294 |
int flag = (s->rematrixing == AC3_REMATRIXING_ALWAYS);
|
295 |
s->blocks[0].new_rematrixing_strategy = 1; |
296 |
memset(s->blocks[0].rematrixing_flags, flag,
|
297 |
sizeof(s->blocks[0].rematrixing_flags)); |
298 |
} |
299 |
} |
300 |
|
301 |
|
302 |
/**
|
303 |
* Determine rematrixing flags for each block and band.
|
304 |
*/
|
305 |
static void compute_rematrixing_strategy(AC3EncodeContext *s) |
306 |
{ |
307 |
int nb_coefs;
|
308 |
int blk, bnd, i;
|
309 |
AC3Block *block, *block0; |
310 |
|
311 |
s->num_rematrixing_bands = 4;
|
312 |
|
313 |
if (s->rematrixing & AC3_REMATRIXING_IS_STATIC)
|
314 |
return;
|
315 |
|
316 |
nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]); |
317 |
|
318 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
319 |
block = &s->blocks[blk]; |
320 |
block->new_rematrixing_strategy = !blk; |
321 |
for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) { |
322 |
/* calculate calculate sum of squared coeffs for one band in one block */
|
323 |
int start = ff_ac3_rematrix_band_tab[bnd];
|
324 |
int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]); |
325 |
CoefSumType sum[4] = {0,}; |
326 |
for (i = start; i < end; i++) {
|
327 |
CoefType lt = block->mdct_coef[0][i];
|
328 |
CoefType rt = block->mdct_coef[1][i];
|
329 |
CoefType md = lt + rt; |
330 |
CoefType sd = lt - rt; |
331 |
MAC_COEF(sum[0], lt, lt);
|
332 |
MAC_COEF(sum[1], rt, rt);
|
333 |
MAC_COEF(sum[2], md, md);
|
334 |
MAC_COEF(sum[3], sd, sd);
|
335 |
} |
336 |
|
337 |
/* compare sums to determine if rematrixing will be used for this band */
|
338 |
if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1])) |
339 |
block->rematrixing_flags[bnd] = 1;
|
340 |
else
|
341 |
block->rematrixing_flags[bnd] = 0;
|
342 |
|
343 |
/* determine if new rematrixing flags will be sent */
|
344 |
if (blk &&
|
345 |
block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) { |
346 |
block->new_rematrixing_strategy = 1;
|
347 |
} |
348 |
} |
349 |
block0 = block; |
350 |
} |
351 |
} |
352 |
|
353 |
|
354 |
/**
|
355 |
* Apply stereo rematrixing to coefficients based on rematrixing flags.
|
356 |
*/
|
357 |
static void apply_rematrixing(AC3EncodeContext *s) |
358 |
{ |
359 |
int nb_coefs;
|
360 |
int blk, bnd, i;
|
361 |
int start, end;
|
362 |
uint8_t *flags; |
363 |
|
364 |
if (s->rematrixing == AC3_REMATRIXING_NONE)
|
365 |
return;
|
366 |
|
367 |
nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]); |
368 |
|
369 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
370 |
AC3Block *block = &s->blocks[blk]; |
371 |
if (block->new_rematrixing_strategy)
|
372 |
flags = block->rematrixing_flags; |
373 |
for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) { |
374 |
if (flags[bnd]) {
|
375 |
start = ff_ac3_rematrix_band_tab[bnd]; |
376 |
end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
|
377 |
for (i = start; i < end; i++) {
|
378 |
int32_t lt = block->fixed_coef[0][i];
|
379 |
int32_t rt = block->fixed_coef[1][i];
|
380 |
block->fixed_coef[0][i] = (lt + rt) >> 1; |
381 |
block->fixed_coef[1][i] = (lt - rt) >> 1; |
382 |
} |
383 |
} |
384 |
} |
385 |
} |
386 |
} |
387 |
|
388 |
|
389 |
/**
|
390 |
* Initialize exponent tables.
|
391 |
*/
|
392 |
static av_cold void exponent_init(AC3EncodeContext *s) |
393 |
{ |
394 |
int i;
|
395 |
for (i = 73; i < 256; i++) { |
396 |
exponent_group_tab[0][i] = (i - 1) / 3; |
397 |
exponent_group_tab[1][i] = (i + 2) / 6; |
398 |
exponent_group_tab[2][i] = (i + 8) / 12; |
399 |
} |
400 |
/* LFE */
|
401 |
exponent_group_tab[0][7] = 2; |
402 |
} |
403 |
|
404 |
|
405 |
/**
|
406 |
* Extract exponents from the MDCT coefficients.
|
407 |
* This takes into account the normalization that was done to the input samples
|
408 |
* by adjusting the exponents by the exponent shift values.
|
409 |
*/
|
410 |
static void extract_exponents(AC3EncodeContext *s) |
411 |
{ |
412 |
int blk, ch, i;
|
413 |
|
414 |
for (ch = 0; ch < s->channels; ch++) { |
415 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
416 |
AC3Block *block = &s->blocks[blk]; |
417 |
uint8_t *exp = block->exp[ch]; |
418 |
int32_t *coef = block->fixed_coef[ch]; |
419 |
for (i = 0; i < AC3_MAX_COEFS; i++) { |
420 |
int e;
|
421 |
int v = abs(coef[i]);
|
422 |
if (v == 0) |
423 |
e = 24;
|
424 |
else {
|
425 |
e = 23 - av_log2(v);
|
426 |
if (e >= 24) { |
427 |
e = 24;
|
428 |
coef[i] = 0;
|
429 |
} |
430 |
av_assert2(e >= 0);
|
431 |
} |
432 |
exp[i] = e; |
433 |
} |
434 |
} |
435 |
} |
436 |
} |
437 |
|
438 |
|
439 |
/**
|
440 |
* Exponent Difference Threshold.
|
441 |
* New exponents are sent if their SAD exceed this number.
|
442 |
*/
|
443 |
#define EXP_DIFF_THRESHOLD 500 |
444 |
|
445 |
|
446 |
/**
|
447 |
* Calculate exponent strategies for all blocks in a single channel.
|
448 |
*/
|
449 |
static void compute_exp_strategy_ch(AC3EncodeContext *s, uint8_t *exp_strategy, |
450 |
uint8_t *exp) |
451 |
{ |
452 |
int blk, blk1;
|
453 |
int exp_diff;
|
454 |
|
455 |
/* estimate if the exponent variation & decide if they should be
|
456 |
reused in the next frame */
|
457 |
exp_strategy[0] = EXP_NEW;
|
458 |
exp += AC3_MAX_COEFS; |
459 |
for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) { |
460 |
exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16); |
461 |
if (exp_diff > EXP_DIFF_THRESHOLD)
|
462 |
exp_strategy[blk] = EXP_NEW; |
463 |
else
|
464 |
exp_strategy[blk] = EXP_REUSE; |
465 |
exp += AC3_MAX_COEFS; |
466 |
} |
467 |
|
468 |
/* now select the encoding strategy type : if exponents are often
|
469 |
recoded, we use a coarse encoding */
|
470 |
blk = 0;
|
471 |
while (blk < AC3_MAX_BLOCKS) {
|
472 |
blk1 = blk + 1;
|
473 |
while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)
|
474 |
blk1++; |
475 |
switch (blk1 - blk) {
|
476 |
case 1: exp_strategy[blk] = EXP_D45; break; |
477 |
case 2: |
478 |
case 3: exp_strategy[blk] = EXP_D25; break; |
479 |
default: exp_strategy[blk] = EXP_D15; break; |
480 |
} |
481 |
blk = blk1; |
482 |
} |
483 |
} |
484 |
|
485 |
|
486 |
/**
|
487 |
* Calculate exponent strategies for all channels.
|
488 |
* Array arrangement is reversed to simplify the per-channel calculation.
|
489 |
*/
|
490 |
static void compute_exp_strategy(AC3EncodeContext *s) |
491 |
{ |
492 |
int ch, blk;
|
493 |
|
494 |
for (ch = 0; ch < s->fbw_channels; ch++) { |
495 |
compute_exp_strategy_ch(s, s->exp_strategy[ch], s->blocks[0].exp[ch]);
|
496 |
} |
497 |
if (s->lfe_on) {
|
498 |
ch = s->lfe_channel; |
499 |
s->exp_strategy[ch][0] = EXP_D15;
|
500 |
for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) |
501 |
s->exp_strategy[ch][blk] = EXP_REUSE; |
502 |
} |
503 |
} |
504 |
|
505 |
|
506 |
/**
|
507 |
* Update the exponents so that they are the ones the decoder will decode.
|
508 |
*/
|
509 |
static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy) |
510 |
{ |
511 |
int nb_groups, i, k;
|
512 |
|
513 |
nb_groups = exponent_group_tab[exp_strategy-1][nb_exps] * 3; |
514 |
|
515 |
/* for each group, compute the minimum exponent */
|
516 |
switch(exp_strategy) {
|
517 |
case EXP_D25:
|
518 |
for (i = 1, k = 1; i <= nb_groups; i++) { |
519 |
uint8_t exp_min = exp[k]; |
520 |
if (exp[k+1] < exp_min) |
521 |
exp_min = exp[k+1];
|
522 |
exp[i] = exp_min; |
523 |
k += 2;
|
524 |
} |
525 |
break;
|
526 |
case EXP_D45:
|
527 |
for (i = 1, k = 1; i <= nb_groups; i++) { |
528 |
uint8_t exp_min = exp[k]; |
529 |
if (exp[k+1] < exp_min) |
530 |
exp_min = exp[k+1];
|
531 |
if (exp[k+2] < exp_min) |
532 |
exp_min = exp[k+2];
|
533 |
if (exp[k+3] < exp_min) |
534 |
exp_min = exp[k+3];
|
535 |
exp[i] = exp_min; |
536 |
k += 4;
|
537 |
} |
538 |
break;
|
539 |
} |
540 |
|
541 |
/* constraint for DC exponent */
|
542 |
if (exp[0] > 15) |
543 |
exp[0] = 15; |
544 |
|
545 |
/* decrease the delta between each groups to within 2 so that they can be
|
546 |
differentially encoded */
|
547 |
for (i = 1; i <= nb_groups; i++) |
548 |
exp[i] = FFMIN(exp[i], exp[i-1] + 2); |
549 |
i--; |
550 |
while (--i >= 0) |
551 |
exp[i] = FFMIN(exp[i], exp[i+1] + 2); |
552 |
|
553 |
/* now we have the exponent values the decoder will see */
|
554 |
switch (exp_strategy) {
|
555 |
case EXP_D25:
|
556 |
for (i = nb_groups, k = nb_groups * 2; i > 0; i--) { |
557 |
uint8_t exp1 = exp[i]; |
558 |
exp[k--] = exp1; |
559 |
exp[k--] = exp1; |
560 |
} |
561 |
break;
|
562 |
case EXP_D45:
|
563 |
for (i = nb_groups, k = nb_groups * 4; i > 0; i--) { |
564 |
exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i]; |
565 |
k -= 4;
|
566 |
} |
567 |
break;
|
568 |
} |
569 |
} |
570 |
|
571 |
|
572 |
/**
|
573 |
* Encode exponents from original extracted form to what the decoder will see.
|
574 |
* This copies and groups exponents based on exponent strategy and reduces
|
575 |
* deltas between adjacent exponent groups so that they can be differentially
|
576 |
* encoded.
|
577 |
*/
|
578 |
static void encode_exponents(AC3EncodeContext *s) |
579 |
{ |
580 |
int blk, blk1, ch;
|
581 |
uint8_t *exp, *exp1, *exp_strategy; |
582 |
int nb_coefs, num_reuse_blocks;
|
583 |
|
584 |
for (ch = 0; ch < s->channels; ch++) { |
585 |
exp = s->blocks[0].exp[ch];
|
586 |
exp_strategy = s->exp_strategy[ch]; |
587 |
nb_coefs = s->nb_coefs[ch]; |
588 |
|
589 |
blk = 0;
|
590 |
while (blk < AC3_MAX_BLOCKS) {
|
591 |
blk1 = blk + 1;
|
592 |
|
593 |
/* count the number of EXP_REUSE blocks after the current block */
|
594 |
while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)
|
595 |
blk1++; |
596 |
num_reuse_blocks = blk1 - blk - 1;
|
597 |
|
598 |
/* for the EXP_REUSE case we select the min of the exponents */
|
599 |
s->ac3dsp.ac3_exponent_min(exp, num_reuse_blocks, nb_coefs); |
600 |
|
601 |
encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk]); |
602 |
|
603 |
/* copy encoded exponents for reuse case */
|
604 |
exp1 = exp + AC3_MAX_COEFS; |
605 |
while (blk < blk1-1) { |
606 |
memcpy(exp1, exp, nb_coefs * sizeof(*exp));
|
607 |
exp1 += AC3_MAX_COEFS; |
608 |
blk++; |
609 |
} |
610 |
blk = blk1; |
611 |
exp = exp1; |
612 |
} |
613 |
} |
614 |
} |
615 |
|
616 |
|
617 |
/**
|
618 |
* Group exponents.
|
619 |
* 3 delta-encoded exponents are in each 7-bit group. The number of groups
|
620 |
* varies depending on exponent strategy and bandwidth.
|
621 |
*/
|
622 |
static void group_exponents(AC3EncodeContext *s) |
623 |
{ |
624 |
int blk, ch, i;
|
625 |
int group_size, nb_groups, bit_count;
|
626 |
uint8_t *p; |
627 |
int delta0, delta1, delta2;
|
628 |
int exp0, exp1;
|
629 |
|
630 |
bit_count = 0;
|
631 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
632 |
AC3Block *block = &s->blocks[blk]; |
633 |
for (ch = 0; ch < s->channels; ch++) { |
634 |
int exp_strategy = s->exp_strategy[ch][blk];
|
635 |
if (exp_strategy == EXP_REUSE)
|
636 |
continue;
|
637 |
group_size = exp_strategy + (exp_strategy == EXP_D45); |
638 |
nb_groups = exponent_group_tab[exp_strategy-1][s->nb_coefs[ch]];
|
639 |
bit_count += 4 + (nb_groups * 7); |
640 |
p = block->exp[ch]; |
641 |
|
642 |
/* DC exponent */
|
643 |
exp1 = *p++; |
644 |
block->grouped_exp[ch][0] = exp1;
|
645 |
|
646 |
/* remaining exponents are delta encoded */
|
647 |
for (i = 1; i <= nb_groups; i++) { |
648 |
/* merge three delta in one code */
|
649 |
exp0 = exp1; |
650 |
exp1 = p[0];
|
651 |
p += group_size; |
652 |
delta0 = exp1 - exp0 + 2;
|
653 |
av_assert2(delta0 >= 0 && delta0 <= 4); |
654 |
|
655 |
exp0 = exp1; |
656 |
exp1 = p[0];
|
657 |
p += group_size; |
658 |
delta1 = exp1 - exp0 + 2;
|
659 |
av_assert2(delta1 >= 0 && delta1 <= 4); |
660 |
|
661 |
exp0 = exp1; |
662 |
exp1 = p[0];
|
663 |
p += group_size; |
664 |
delta2 = exp1 - exp0 + 2;
|
665 |
av_assert2(delta2 >= 0 && delta2 <= 4); |
666 |
|
667 |
block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2; |
668 |
} |
669 |
} |
670 |
} |
671 |
|
672 |
s->exponent_bits = bit_count; |
673 |
} |
674 |
|
675 |
|
676 |
/**
|
677 |
* Calculate final exponents from the supplied MDCT coefficients and exponent shift.
|
678 |
* Extract exponents from MDCT coefficients, calculate exponent strategies,
|
679 |
* and encode final exponents.
|
680 |
*/
|
681 |
static void process_exponents(AC3EncodeContext *s) |
682 |
{ |
683 |
extract_exponents(s); |
684 |
|
685 |
compute_exp_strategy(s); |
686 |
|
687 |
encode_exponents(s); |
688 |
|
689 |
group_exponents(s); |
690 |
|
691 |
emms_c(); |
692 |
} |
693 |
|
694 |
|
695 |
/**
|
696 |
* Count frame bits that are based solely on fixed parameters.
|
697 |
* This only has to be run once when the encoder is initialized.
|
698 |
*/
|
699 |
static void count_frame_bits_fixed(AC3EncodeContext *s) |
700 |
{ |
701 |
static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 }; |
702 |
int blk;
|
703 |
int frame_bits;
|
704 |
|
705 |
/* assumptions:
|
706 |
* no dynamic range codes
|
707 |
* no channel coupling
|
708 |
* bit allocation parameters do not change between blocks
|
709 |
* SNR offsets do not change between blocks
|
710 |
* no delta bit allocation
|
711 |
* no skipped data
|
712 |
* no auxilliary data
|
713 |
*/
|
714 |
|
715 |
/* header size */
|
716 |
frame_bits = 65;
|
717 |
frame_bits += frame_bits_inc[s->channel_mode]; |
718 |
|
719 |
/* audio blocks */
|
720 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
721 |
frame_bits += s->fbw_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */ |
722 |
if (s->channel_mode == AC3_CHMODE_STEREO) {
|
723 |
frame_bits++; /* rematstr */
|
724 |
} |
725 |
frame_bits += 2 * s->fbw_channels; /* chexpstr[2] * c */ |
726 |
if (s->lfe_on)
|
727 |
frame_bits++; /* lfeexpstr */
|
728 |
frame_bits++; /* baie */
|
729 |
frame_bits++; /* snr */
|
730 |
frame_bits += 2; /* delta / skip */ |
731 |
} |
732 |
frame_bits++; /* cplinu for block 0 */
|
733 |
/* bit alloc info */
|
734 |
/* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */
|
735 |
/* csnroffset[6] */
|
736 |
/* (fsnoffset[4] + fgaincod[4]) * c */
|
737 |
frame_bits += 2*4 + 3 + 6 + s->channels * (4 + 3); |
738 |
|
739 |
/* auxdatae, crcrsv */
|
740 |
frame_bits += 2;
|
741 |
|
742 |
/* CRC */
|
743 |
frame_bits += 16;
|
744 |
|
745 |
s->frame_bits_fixed = frame_bits; |
746 |
} |
747 |
|
748 |
|
749 |
/**
|
750 |
* Initialize bit allocation.
|
751 |
* Set default parameter codes and calculate parameter values.
|
752 |
*/
|
753 |
static void bit_alloc_init(AC3EncodeContext *s) |
754 |
{ |
755 |
int ch;
|
756 |
|
757 |
/* init default parameters */
|
758 |
s->slow_decay_code = 2;
|
759 |
s->fast_decay_code = 1;
|
760 |
s->slow_gain_code = 1;
|
761 |
s->db_per_bit_code = 3;
|
762 |
s->floor_code = 7;
|
763 |
for (ch = 0; ch < s->channels; ch++) |
764 |
s->fast_gain_code[ch] = 4;
|
765 |
|
766 |
/* initial snr offset */
|
767 |
s->coarse_snr_offset = 40;
|
768 |
|
769 |
/* compute real values */
|
770 |
/* currently none of these values change during encoding, so we can just
|
771 |
set them once at initialization */
|
772 |
s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->bit_alloc.sr_shift; |
773 |
s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->bit_alloc.sr_shift; |
774 |
s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code]; |
775 |
s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code]; |
776 |
s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code]; |
777 |
|
778 |
count_frame_bits_fixed(s); |
779 |
} |
780 |
|
781 |
|
782 |
/**
|
783 |
* Count the bits used to encode the frame, minus exponents and mantissas.
|
784 |
* Bits based on fixed parameters have already been counted, so now we just
|
785 |
* have to add the bits based on parameters that change during encoding.
|
786 |
*/
|
787 |
static void count_frame_bits(AC3EncodeContext *s) |
788 |
{ |
789 |
int blk, ch;
|
790 |
int frame_bits = 0; |
791 |
|
792 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
793 |
/* stereo rematrixing */
|
794 |
if (s->channel_mode == AC3_CHMODE_STEREO &&
|
795 |
s->blocks[blk].new_rematrixing_strategy) { |
796 |
frame_bits += s->num_rematrixing_bands; |
797 |
} |
798 |
|
799 |
for (ch = 0; ch < s->fbw_channels; ch++) { |
800 |
if (s->exp_strategy[ch][blk] != EXP_REUSE)
|
801 |
frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */ |
802 |
} |
803 |
} |
804 |
s->frame_bits = s->frame_bits_fixed + frame_bits; |
805 |
} |
806 |
|
807 |
|
808 |
/**
|
809 |
* Calculate the number of bits needed to encode a set of mantissas.
|
810 |
*/
|
811 |
static int compute_mantissa_size(int mant_cnt[5], uint8_t *bap, int nb_coefs) |
812 |
{ |
813 |
int bits, b, i;
|
814 |
|
815 |
bits = 0;
|
816 |
for (i = 0; i < nb_coefs; i++) { |
817 |
b = bap[i]; |
818 |
if (b <= 4) { |
819 |
// bap=1 to bap=4 will be counted in compute_mantissa_size_final
|
820 |
mant_cnt[b]++; |
821 |
} else if (b <= 13) { |
822 |
// bap=5 to bap=13 use (bap-1) bits
|
823 |
bits += b - 1;
|
824 |
} else {
|
825 |
// bap=14 uses 14 bits and bap=15 uses 16 bits
|
826 |
bits += (b == 14) ? 14 : 16; |
827 |
} |
828 |
} |
829 |
return bits;
|
830 |
} |
831 |
|
832 |
|
833 |
/**
|
834 |
* Finalize the mantissa bit count by adding in the grouped mantissas.
|
835 |
*/
|
836 |
static int compute_mantissa_size_final(int mant_cnt[5]) |
837 |
{ |
838 |
// bap=1 : 3 mantissas in 5 bits
|
839 |
int bits = (mant_cnt[1] / 3) * 5; |
840 |
// bap=2 : 3 mantissas in 7 bits
|
841 |
// bap=4 : 2 mantissas in 7 bits
|
842 |
bits += ((mant_cnt[2] / 3) + (mant_cnt[4] >> 1)) * 7; |
843 |
// bap=3 : each mantissa is 3 bits
|
844 |
bits += mant_cnt[3] * 3; |
845 |
return bits;
|
846 |
} |
847 |
|
848 |
|
849 |
/**
|
850 |
* Calculate masking curve based on the final exponents.
|
851 |
* Also calculate the power spectral densities to use in future calculations.
|
852 |
*/
|
853 |
static void bit_alloc_masking(AC3EncodeContext *s) |
854 |
{ |
855 |
int blk, ch;
|
856 |
|
857 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
858 |
AC3Block *block = &s->blocks[blk]; |
859 |
for (ch = 0; ch < s->channels; ch++) { |
860 |
/* We only need psd and mask for calculating bap.
|
861 |
Since we currently do not calculate bap when exponent
|
862 |
strategy is EXP_REUSE we do not need to calculate psd or mask. */
|
863 |
if (s->exp_strategy[ch][blk] != EXP_REUSE) {
|
864 |
ff_ac3_bit_alloc_calc_psd(block->exp[ch], 0,
|
865 |
s->nb_coefs[ch], |
866 |
block->psd[ch], block->band_psd[ch]); |
867 |
ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch], |
868 |
0, s->nb_coefs[ch],
|
869 |
ff_ac3_fast_gain_tab[s->fast_gain_code[ch]], |
870 |
ch == s->lfe_channel, |
871 |
DBA_NONE, 0, NULL, NULL, NULL, |
872 |
block->mask[ch]); |
873 |
} |
874 |
} |
875 |
} |
876 |
} |
877 |
|
878 |
|
879 |
/**
|
880 |
* Ensure that bap for each block and channel point to the current bap_buffer.
|
881 |
* They may have been switched during the bit allocation search.
|
882 |
*/
|
883 |
static void reset_block_bap(AC3EncodeContext *s) |
884 |
{ |
885 |
int blk, ch;
|
886 |
if (s->blocks[0].bap[0] == s->bap_buffer) |
887 |
return;
|
888 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
889 |
for (ch = 0; ch < s->channels; ch++) { |
890 |
s->blocks[blk].bap[ch] = &s->bap_buffer[AC3_MAX_COEFS * (blk * s->channels + ch)]; |
891 |
} |
892 |
} |
893 |
} |
894 |
|
895 |
|
896 |
/**
|
897 |
* Run the bit allocation with a given SNR offset.
|
898 |
* This calculates the bit allocation pointers that will be used to determine
|
899 |
* the quantization of each mantissa.
|
900 |
* @return the number of bits needed for mantissas if the given SNR offset is
|
901 |
* is used.
|
902 |
*/
|
903 |
static int bit_alloc(AC3EncodeContext *s, int snr_offset) |
904 |
{ |
905 |
int blk, ch;
|
906 |
int mantissa_bits;
|
907 |
int mant_cnt[5]; |
908 |
|
909 |
snr_offset = (snr_offset - 240) << 2; |
910 |
|
911 |
reset_block_bap(s); |
912 |
mantissa_bits = 0;
|
913 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
914 |
AC3Block *block = &s->blocks[blk]; |
915 |
// initialize grouped mantissa counts. these are set so that they are
|
916 |
// padded to the next whole group size when bits are counted in
|
917 |
// compute_mantissa_size_final
|
918 |
mant_cnt[0] = mant_cnt[3] = 0; |
919 |
mant_cnt[1] = mant_cnt[2] = 2; |
920 |
mant_cnt[4] = 1; |
921 |
for (ch = 0; ch < s->channels; ch++) { |
922 |
/* Currently the only bit allocation parameters which vary across
|
923 |
blocks within a frame are the exponent values. We can take
|
924 |
advantage of that by reusing the bit allocation pointers
|
925 |
whenever we reuse exponents. */
|
926 |
if (s->exp_strategy[ch][blk] == EXP_REUSE) {
|
927 |
memcpy(block->bap[ch], s->blocks[blk-1].bap[ch], AC3_MAX_COEFS);
|
928 |
} else {
|
929 |
ff_ac3_bit_alloc_calc_bap(block->mask[ch], block->psd[ch], 0,
|
930 |
s->nb_coefs[ch], snr_offset, |
931 |
s->bit_alloc.floor, ff_ac3_bap_tab, |
932 |
block->bap[ch]); |
933 |
} |
934 |
mantissa_bits += compute_mantissa_size(mant_cnt, block->bap[ch], s->nb_coefs[ch]); |
935 |
} |
936 |
mantissa_bits += compute_mantissa_size_final(mant_cnt); |
937 |
} |
938 |
return mantissa_bits;
|
939 |
} |
940 |
|
941 |
|
942 |
/**
|
943 |
* Constant bitrate bit allocation search.
|
944 |
* Find the largest SNR offset that will allow data to fit in the frame.
|
945 |
*/
|
946 |
static int cbr_bit_allocation(AC3EncodeContext *s) |
947 |
{ |
948 |
int ch;
|
949 |
int bits_left;
|
950 |
int snr_offset, snr_incr;
|
951 |
|
952 |
bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
|
953 |
av_assert2(bits_left >= 0);
|
954 |
|
955 |
snr_offset = s->coarse_snr_offset << 4;
|
956 |
|
957 |
/* if previous frame SNR offset was 1023, check if current frame can also
|
958 |
use SNR offset of 1023. if so, skip the search. */
|
959 |
if ((snr_offset | s->fine_snr_offset[0]) == 1023) { |
960 |
if (bit_alloc(s, 1023) <= bits_left) |
961 |
return 0; |
962 |
} |
963 |
|
964 |
while (snr_offset >= 0 && |
965 |
bit_alloc(s, snr_offset) > bits_left) { |
966 |
snr_offset -= 64;
|
967 |
} |
968 |
if (snr_offset < 0) |
969 |
return AVERROR(EINVAL);
|
970 |
|
971 |
FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); |
972 |
for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) { |
973 |
while (snr_offset + snr_incr <= 1023 && |
974 |
bit_alloc(s, snr_offset + snr_incr) <= bits_left) { |
975 |
snr_offset += snr_incr; |
976 |
FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); |
977 |
} |
978 |
} |
979 |
FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); |
980 |
reset_block_bap(s); |
981 |
|
982 |
s->coarse_snr_offset = snr_offset >> 4;
|
983 |
for (ch = 0; ch < s->channels; ch++) |
984 |
s->fine_snr_offset[ch] = snr_offset & 0xF;
|
985 |
|
986 |
return 0; |
987 |
} |
988 |
|
989 |
|
990 |
/**
|
991 |
* Downgrade exponent strategies to reduce the bits used by the exponents.
|
992 |
* This is a fallback for when bit allocation fails with the normal exponent
|
993 |
* strategies. Each time this function is run it only downgrades the
|
994 |
* strategy in 1 channel of 1 block.
|
995 |
* @return non-zero if downgrade was unsuccessful
|
996 |
*/
|
997 |
static int downgrade_exponents(AC3EncodeContext *s) |
998 |
{ |
999 |
int ch, blk;
|
1000 |
|
1001 |
for (ch = 0; ch < s->fbw_channels; ch++) { |
1002 |
for (blk = AC3_MAX_BLOCKS-1; blk >= 0; blk--) { |
1003 |
if (s->exp_strategy[ch][blk] == EXP_D15) {
|
1004 |
s->exp_strategy[ch][blk] = EXP_D25; |
1005 |
return 0; |
1006 |
} |
1007 |
} |
1008 |
} |
1009 |
for (ch = 0; ch < s->fbw_channels; ch++) { |
1010 |
for (blk = AC3_MAX_BLOCKS-1; blk >= 0; blk--) { |
1011 |
if (s->exp_strategy[ch][blk] == EXP_D25) {
|
1012 |
s->exp_strategy[ch][blk] = EXP_D45; |
1013 |
return 0; |
1014 |
} |
1015 |
} |
1016 |
} |
1017 |
for (ch = 0; ch < s->fbw_channels; ch++) { |
1018 |
/* block 0 cannot reuse exponents, so only downgrade D45 to REUSE if
|
1019 |
the block number > 0 */
|
1020 |
for (blk = AC3_MAX_BLOCKS-1; blk > 0; blk--) { |
1021 |
if (s->exp_strategy[ch][blk] > EXP_REUSE) {
|
1022 |
s->exp_strategy[ch][blk] = EXP_REUSE; |
1023 |
return 0; |
1024 |
} |
1025 |
} |
1026 |
} |
1027 |
return -1; |
1028 |
} |
1029 |
|
1030 |
|
1031 |
/**
|
1032 |
* Reduce the bandwidth to reduce the number of bits used for a given SNR offset.
|
1033 |
* This is a second fallback for when bit allocation still fails after exponents
|
1034 |
* have been downgraded.
|
1035 |
* @return non-zero if bandwidth reduction was unsuccessful
|
1036 |
*/
|
1037 |
static int reduce_bandwidth(AC3EncodeContext *s, int min_bw_code) |
1038 |
{ |
1039 |
int ch;
|
1040 |
|
1041 |
if (s->bandwidth_code[0] > min_bw_code) { |
1042 |
for (ch = 0; ch < s->fbw_channels; ch++) { |
1043 |
s->bandwidth_code[ch]--; |
1044 |
s->nb_coefs[ch] = s->bandwidth_code[ch] * 3 + 73; |
1045 |
} |
1046 |
return 0; |
1047 |
} |
1048 |
return -1; |
1049 |
} |
1050 |
|
1051 |
|
1052 |
/**
|
1053 |
* Perform bit allocation search.
|
1054 |
* Finds the SNR offset value that maximizes quality and fits in the specified
|
1055 |
* frame size. Output is the SNR offset and a set of bit allocation pointers
|
1056 |
* used to quantize the mantissas.
|
1057 |
*/
|
1058 |
static int compute_bit_allocation(AC3EncodeContext *s) |
1059 |
{ |
1060 |
int ret;
|
1061 |
|
1062 |
count_frame_bits(s); |
1063 |
|
1064 |
bit_alloc_masking(s); |
1065 |
|
1066 |
ret = cbr_bit_allocation(s); |
1067 |
while (ret) {
|
1068 |
/* fallback 1: downgrade exponents */
|
1069 |
if (!downgrade_exponents(s)) {
|
1070 |
extract_exponents(s); |
1071 |
encode_exponents(s); |
1072 |
group_exponents(s); |
1073 |
ret = compute_bit_allocation(s); |
1074 |
continue;
|
1075 |
} |
1076 |
|
1077 |
/* fallback 2: reduce bandwidth */
|
1078 |
/* only do this if the user has not specified a specific cutoff
|
1079 |
frequency */
|
1080 |
if (!s->cutoff && !reduce_bandwidth(s, 0)) { |
1081 |
process_exponents(s); |
1082 |
ret = compute_bit_allocation(s); |
1083 |
continue;
|
1084 |
} |
1085 |
|
1086 |
/* fallbacks were not enough... */
|
1087 |
break;
|
1088 |
} |
1089 |
|
1090 |
return ret;
|
1091 |
} |
1092 |
|
1093 |
|
1094 |
/**
|
1095 |
* Symmetric quantization on 'levels' levels.
|
1096 |
*/
|
1097 |
static inline int sym_quant(int c, int e, int levels) |
1098 |
{ |
1099 |
int v = ((((levels * c) >> (24 - e)) + 1) >> 1) + (levels >> 1); |
1100 |
av_assert2(v >= 0 && v < levels);
|
1101 |
return v;
|
1102 |
} |
1103 |
|
1104 |
|
1105 |
/**
|
1106 |
* Asymmetric quantization on 2^qbits levels.
|
1107 |
*/
|
1108 |
static inline int asym_quant(int c, int e, int qbits) |
1109 |
{ |
1110 |
int lshift, m, v;
|
1111 |
|
1112 |
lshift = e + qbits - 24;
|
1113 |
if (lshift >= 0) |
1114 |
v = c << lshift; |
1115 |
else
|
1116 |
v = c >> (-lshift); |
1117 |
/* rounding */
|
1118 |
v = (v + 1) >> 1; |
1119 |
m = (1 << (qbits-1)); |
1120 |
if (v >= m)
|
1121 |
v = m - 1;
|
1122 |
av_assert2(v >= -m); |
1123 |
return v & ((1 << qbits)-1); |
1124 |
} |
1125 |
|
1126 |
|
1127 |
/**
|
1128 |
* Quantize a set of mantissas for a single channel in a single block.
|
1129 |
*/
|
1130 |
static void quantize_mantissas_blk_ch(AC3EncodeContext *s, int32_t *fixed_coef, |
1131 |
uint8_t *exp, |
1132 |
uint8_t *bap, uint16_t *qmant, int n)
|
1133 |
{ |
1134 |
int i;
|
1135 |
|
1136 |
for (i = 0; i < n; i++) { |
1137 |
int v;
|
1138 |
int c = fixed_coef[i];
|
1139 |
int e = exp[i];
|
1140 |
int b = bap[i];
|
1141 |
switch (b) {
|
1142 |
case 0: |
1143 |
v = 0;
|
1144 |
break;
|
1145 |
case 1: |
1146 |
v = sym_quant(c, e, 3);
|
1147 |
switch (s->mant1_cnt) {
|
1148 |
case 0: |
1149 |
s->qmant1_ptr = &qmant[i]; |
1150 |
v = 9 * v;
|
1151 |
s->mant1_cnt = 1;
|
1152 |
break;
|
1153 |
case 1: |
1154 |
*s->qmant1_ptr += 3 * v;
|
1155 |
s->mant1_cnt = 2;
|
1156 |
v = 128;
|
1157 |
break;
|
1158 |
default:
|
1159 |
*s->qmant1_ptr += v; |
1160 |
s->mant1_cnt = 0;
|
1161 |
v = 128;
|
1162 |
break;
|
1163 |
} |
1164 |
break;
|
1165 |
case 2: |
1166 |
v = sym_quant(c, e, 5);
|
1167 |
switch (s->mant2_cnt) {
|
1168 |
case 0: |
1169 |
s->qmant2_ptr = &qmant[i]; |
1170 |
v = 25 * v;
|
1171 |
s->mant2_cnt = 1;
|
1172 |
break;
|
1173 |
case 1: |
1174 |
*s->qmant2_ptr += 5 * v;
|
1175 |
s->mant2_cnt = 2;
|
1176 |
v = 128;
|
1177 |
break;
|
1178 |
default:
|
1179 |
*s->qmant2_ptr += v; |
1180 |
s->mant2_cnt = 0;
|
1181 |
v = 128;
|
1182 |
break;
|
1183 |
} |
1184 |
break;
|
1185 |
case 3: |
1186 |
v = sym_quant(c, e, 7);
|
1187 |
break;
|
1188 |
case 4: |
1189 |
v = sym_quant(c, e, 11);
|
1190 |
switch (s->mant4_cnt) {
|
1191 |
case 0: |
1192 |
s->qmant4_ptr = &qmant[i]; |
1193 |
v = 11 * v;
|
1194 |
s->mant4_cnt = 1;
|
1195 |
break;
|
1196 |
default:
|
1197 |
*s->qmant4_ptr += v; |
1198 |
s->mant4_cnt = 0;
|
1199 |
v = 128;
|
1200 |
break;
|
1201 |
} |
1202 |
break;
|
1203 |
case 5: |
1204 |
v = sym_quant(c, e, 15);
|
1205 |
break;
|
1206 |
case 14: |
1207 |
v = asym_quant(c, e, 14);
|
1208 |
break;
|
1209 |
case 15: |
1210 |
v = asym_quant(c, e, 16);
|
1211 |
break;
|
1212 |
default:
|
1213 |
v = asym_quant(c, e, b - 1);
|
1214 |
break;
|
1215 |
} |
1216 |
qmant[i] = v; |
1217 |
} |
1218 |
} |
1219 |
|
1220 |
|
1221 |
/**
|
1222 |
* Quantize mantissas using coefficients, exponents, and bit allocation pointers.
|
1223 |
*/
|
1224 |
static void quantize_mantissas(AC3EncodeContext *s) |
1225 |
{ |
1226 |
int blk, ch;
|
1227 |
|
1228 |
|
1229 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
1230 |
AC3Block *block = &s->blocks[blk]; |
1231 |
s->mant1_cnt = s->mant2_cnt = s->mant4_cnt = 0;
|
1232 |
s->qmant1_ptr = s->qmant2_ptr = s->qmant4_ptr = NULL;
|
1233 |
|
1234 |
for (ch = 0; ch < s->channels; ch++) { |
1235 |
quantize_mantissas_blk_ch(s, block->fixed_coef[ch], |
1236 |
block->exp[ch], block->bap[ch], |
1237 |
block->qmant[ch], s->nb_coefs[ch]); |
1238 |
} |
1239 |
} |
1240 |
} |
1241 |
|
1242 |
|
1243 |
/**
|
1244 |
* Write the AC-3 frame header to the output bitstream.
|
1245 |
*/
|
1246 |
static void output_frame_header(AC3EncodeContext *s) |
1247 |
{ |
1248 |
put_bits(&s->pb, 16, 0x0b77); /* frame header */ |
1249 |
put_bits(&s->pb, 16, 0); /* crc1: will be filled later */ |
1250 |
put_bits(&s->pb, 2, s->bit_alloc.sr_code);
|
1251 |
put_bits(&s->pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min) / 2); |
1252 |
put_bits(&s->pb, 5, s->bitstream_id);
|
1253 |
put_bits(&s->pb, 3, s->bitstream_mode);
|
1254 |
put_bits(&s->pb, 3, s->channel_mode);
|
1255 |
if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO) |
1256 |
put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */ |
1257 |
if (s->channel_mode & 0x04) |
1258 |
put_bits(&s->pb, 2, 1); /* XXX -6 dB */ |
1259 |
if (s->channel_mode == AC3_CHMODE_STEREO)
|
1260 |
put_bits(&s->pb, 2, 0); /* surround not indicated */ |
1261 |
put_bits(&s->pb, 1, s->lfe_on); /* LFE */ |
1262 |
put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */ |
1263 |
put_bits(&s->pb, 1, 0); /* no compression control word */ |
1264 |
put_bits(&s->pb, 1, 0); /* no lang code */ |
1265 |
put_bits(&s->pb, 1, 0); /* no audio production info */ |
1266 |
put_bits(&s->pb, 1, 0); /* no copyright */ |
1267 |
put_bits(&s->pb, 1, 1); /* original bitstream */ |
1268 |
put_bits(&s->pb, 1, 0); /* no time code 1 */ |
1269 |
put_bits(&s->pb, 1, 0); /* no time code 2 */ |
1270 |
put_bits(&s->pb, 1, 0); /* no additional bit stream info */ |
1271 |
} |
1272 |
|
1273 |
|
1274 |
/**
|
1275 |
* Write one audio block to the output bitstream.
|
1276 |
*/
|
1277 |
static void output_audio_block(AC3EncodeContext *s, int blk) |
1278 |
{ |
1279 |
int ch, i, baie, rbnd;
|
1280 |
AC3Block *block = &s->blocks[blk]; |
1281 |
|
1282 |
/* block switching */
|
1283 |
for (ch = 0; ch < s->fbw_channels; ch++) |
1284 |
put_bits(&s->pb, 1, 0); |
1285 |
|
1286 |
/* dither flags */
|
1287 |
for (ch = 0; ch < s->fbw_channels; ch++) |
1288 |
put_bits(&s->pb, 1, 1); |
1289 |
|
1290 |
/* dynamic range codes */
|
1291 |
put_bits(&s->pb, 1, 0); |
1292 |
|
1293 |
/* channel coupling */
|
1294 |
if (!blk) {
|
1295 |
put_bits(&s->pb, 1, 1); /* coupling strategy present */ |
1296 |
put_bits(&s->pb, 1, 0); /* no coupling strategy */ |
1297 |
} else {
|
1298 |
put_bits(&s->pb, 1, 0); /* no new coupling strategy */ |
1299 |
} |
1300 |
|
1301 |
/* stereo rematrixing */
|
1302 |
if (s->channel_mode == AC3_CHMODE_STEREO) {
|
1303 |
put_bits(&s->pb, 1, block->new_rematrixing_strategy);
|
1304 |
if (block->new_rematrixing_strategy) {
|
1305 |
/* rematrixing flags */
|
1306 |
for (rbnd = 0; rbnd < s->num_rematrixing_bands; rbnd++) |
1307 |
put_bits(&s->pb, 1, block->rematrixing_flags[rbnd]);
|
1308 |
} |
1309 |
} |
1310 |
|
1311 |
/* exponent strategy */
|
1312 |
for (ch = 0; ch < s->fbw_channels; ch++) |
1313 |
put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
|
1314 |
if (s->lfe_on)
|
1315 |
put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
|
1316 |
|
1317 |
/* bandwidth */
|
1318 |
for (ch = 0; ch < s->fbw_channels; ch++) { |
1319 |
if (s->exp_strategy[ch][blk] != EXP_REUSE)
|
1320 |
put_bits(&s->pb, 6, s->bandwidth_code[ch]);
|
1321 |
} |
1322 |
|
1323 |
/* exponents */
|
1324 |
for (ch = 0; ch < s->channels; ch++) { |
1325 |
int nb_groups;
|
1326 |
|
1327 |
if (s->exp_strategy[ch][blk] == EXP_REUSE)
|
1328 |
continue;
|
1329 |
|
1330 |
/* DC exponent */
|
1331 |
put_bits(&s->pb, 4, block->grouped_exp[ch][0]); |
1332 |
|
1333 |
/* exponent groups */
|
1334 |
nb_groups = exponent_group_tab[s->exp_strategy[ch][blk]-1][s->nb_coefs[ch]];
|
1335 |
for (i = 1; i <= nb_groups; i++) |
1336 |
put_bits(&s->pb, 7, block->grouped_exp[ch][i]);
|
1337 |
|
1338 |
/* gain range info */
|
1339 |
if (ch != s->lfe_channel)
|
1340 |
put_bits(&s->pb, 2, 0); |
1341 |
} |
1342 |
|
1343 |
/* bit allocation info */
|
1344 |
baie = (blk == 0);
|
1345 |
put_bits(&s->pb, 1, baie);
|
1346 |
if (baie) {
|
1347 |
put_bits(&s->pb, 2, s->slow_decay_code);
|
1348 |
put_bits(&s->pb, 2, s->fast_decay_code);
|
1349 |
put_bits(&s->pb, 2, s->slow_gain_code);
|
1350 |
put_bits(&s->pb, 2, s->db_per_bit_code);
|
1351 |
put_bits(&s->pb, 3, s->floor_code);
|
1352 |
} |
1353 |
|
1354 |
/* snr offset */
|
1355 |
put_bits(&s->pb, 1, baie);
|
1356 |
if (baie) {
|
1357 |
put_bits(&s->pb, 6, s->coarse_snr_offset);
|
1358 |
for (ch = 0; ch < s->channels; ch++) { |
1359 |
put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
|
1360 |
put_bits(&s->pb, 3, s->fast_gain_code[ch]);
|
1361 |
} |
1362 |
} |
1363 |
|
1364 |
put_bits(&s->pb, 1, 0); /* no delta bit allocation */ |
1365 |
put_bits(&s->pb, 1, 0); /* no data to skip */ |
1366 |
|
1367 |
/* mantissas */
|
1368 |
for (ch = 0; ch < s->channels; ch++) { |
1369 |
int b, q;
|
1370 |
for (i = 0; i < s->nb_coefs[ch]; i++) { |
1371 |
q = block->qmant[ch][i]; |
1372 |
b = block->bap[ch][i]; |
1373 |
switch (b) {
|
1374 |
case 0: break; |
1375 |
case 1: if (q != 128) put_bits(&s->pb, 5, q); break; |
1376 |
case 2: if (q != 128) put_bits(&s->pb, 7, q); break; |
1377 |
case 3: put_bits(&s->pb, 3, q); break; |
1378 |
case 4: if (q != 128) put_bits(&s->pb, 7, q); break; |
1379 |
case 14: put_bits(&s->pb, 14, q); break; |
1380 |
case 15: put_bits(&s->pb, 16, q); break; |
1381 |
default: put_bits(&s->pb, b-1, q); break; |
1382 |
} |
1383 |
} |
1384 |
} |
1385 |
} |
1386 |
|
1387 |
|
1388 |
/** CRC-16 Polynomial */
|
1389 |
#define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16)) |
1390 |
|
1391 |
|
1392 |
static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly) |
1393 |
{ |
1394 |
unsigned int c; |
1395 |
|
1396 |
c = 0;
|
1397 |
while (a) {
|
1398 |
if (a & 1) |
1399 |
c ^= b; |
1400 |
a = a >> 1;
|
1401 |
b = b << 1;
|
1402 |
if (b & (1 << 16)) |
1403 |
b ^= poly; |
1404 |
} |
1405 |
return c;
|
1406 |
} |
1407 |
|
1408 |
|
1409 |
static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly) |
1410 |
{ |
1411 |
unsigned int r; |
1412 |
r = 1;
|
1413 |
while (n) {
|
1414 |
if (n & 1) |
1415 |
r = mul_poly(r, a, poly); |
1416 |
a = mul_poly(a, a, poly); |
1417 |
n >>= 1;
|
1418 |
} |
1419 |
return r;
|
1420 |
} |
1421 |
|
1422 |
|
1423 |
/**
|
1424 |
* Fill the end of the frame with 0's and compute the two CRCs.
|
1425 |
*/
|
1426 |
static void output_frame_end(AC3EncodeContext *s) |
1427 |
{ |
1428 |
const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI);
|
1429 |
int frame_size_58, pad_bytes, crc1, crc2_partial, crc2, crc_inv;
|
1430 |
uint8_t *frame; |
1431 |
|
1432 |
frame_size_58 = ((s->frame_size >> 2) + (s->frame_size >> 4)) << 1; |
1433 |
|
1434 |
/* pad the remainder of the frame with zeros */
|
1435 |
av_assert2(s->frame_size * 8 - put_bits_count(&s->pb) >= 18); |
1436 |
flush_put_bits(&s->pb); |
1437 |
frame = s->pb.buf; |
1438 |
pad_bytes = s->frame_size - (put_bits_ptr(&s->pb) - frame) - 2;
|
1439 |
av_assert2(pad_bytes >= 0);
|
1440 |
if (pad_bytes > 0) |
1441 |
memset(put_bits_ptr(&s->pb), 0, pad_bytes);
|
1442 |
|
1443 |
/* compute crc1 */
|
1444 |
/* this is not so easy because it is at the beginning of the data... */
|
1445 |
crc1 = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58 - 4)); |
1446 |
crc_inv = s->crc_inv[s->frame_size > s->frame_size_min]; |
1447 |
crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); |
1448 |
AV_WB16(frame + 2, crc1);
|
1449 |
|
1450 |
/* compute crc2 */
|
1451 |
crc2_partial = av_crc(crc_ctx, 0, frame + frame_size_58,
|
1452 |
s->frame_size - frame_size_58 - 3);
|
1453 |
crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1); |
1454 |
/* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
|
1455 |
if (crc2 == 0x770B) { |
1456 |
frame[s->frame_size - 3] ^= 0x1; |
1457 |
crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1); |
1458 |
} |
1459 |
crc2 = av_bswap16(crc2); |
1460 |
AV_WB16(frame + s->frame_size - 2, crc2);
|
1461 |
} |
1462 |
|
1463 |
|
1464 |
/**
|
1465 |
* Write the frame to the output bitstream.
|
1466 |
*/
|
1467 |
static void output_frame(AC3EncodeContext *s, unsigned char *frame) |
1468 |
{ |
1469 |
int blk;
|
1470 |
|
1471 |
init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE); |
1472 |
|
1473 |
output_frame_header(s); |
1474 |
|
1475 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) |
1476 |
output_audio_block(s, blk); |
1477 |
|
1478 |
output_frame_end(s); |
1479 |
} |
1480 |
|
1481 |
|
1482 |
/**
|
1483 |
* Encode a single AC-3 frame.
|
1484 |
*/
|
1485 |
static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, |
1486 |
int buf_size, void *data) |
1487 |
{ |
1488 |
AC3EncodeContext *s = avctx->priv_data; |
1489 |
const SampleType *samples = data;
|
1490 |
int ret;
|
1491 |
|
1492 |
if (s->bit_alloc.sr_code == 1) |
1493 |
adjust_frame_size(s); |
1494 |
|
1495 |
deinterleave_input_samples(s, samples); |
1496 |
|
1497 |
apply_mdct(s); |
1498 |
|
1499 |
scale_coefficients(s); |
1500 |
|
1501 |
compute_rematrixing_strategy(s); |
1502 |
|
1503 |
apply_rematrixing(s); |
1504 |
|
1505 |
process_exponents(s); |
1506 |
|
1507 |
ret = compute_bit_allocation(s); |
1508 |
if (ret) {
|
1509 |
av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
|
1510 |
return ret;
|
1511 |
} |
1512 |
|
1513 |
quantize_mantissas(s); |
1514 |
|
1515 |
output_frame(s, frame); |
1516 |
|
1517 |
return s->frame_size;
|
1518 |
} |
1519 |
|
1520 |
|
1521 |
/**
|
1522 |
* Finalize encoding and free any memory allocated by the encoder.
|
1523 |
*/
|
1524 |
static av_cold int ac3_encode_close(AVCodecContext *avctx) |
1525 |
{ |
1526 |
int blk, ch;
|
1527 |
AC3EncodeContext *s = avctx->priv_data; |
1528 |
|
1529 |
for (ch = 0; ch < s->channels; ch++) |
1530 |
av_freep(&s->planar_samples[ch]); |
1531 |
av_freep(&s->planar_samples); |
1532 |
av_freep(&s->bap_buffer); |
1533 |
av_freep(&s->bap1_buffer); |
1534 |
av_freep(&s->mdct_coef_buffer); |
1535 |
av_freep(&s->fixed_coef_buffer); |
1536 |
av_freep(&s->exp_buffer); |
1537 |
av_freep(&s->grouped_exp_buffer); |
1538 |
av_freep(&s->psd_buffer); |
1539 |
av_freep(&s->band_psd_buffer); |
1540 |
av_freep(&s->mask_buffer); |
1541 |
av_freep(&s->qmant_buffer); |
1542 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
1543 |
AC3Block *block = &s->blocks[blk]; |
1544 |
av_freep(&block->bap); |
1545 |
av_freep(&block->mdct_coef); |
1546 |
av_freep(&block->fixed_coef); |
1547 |
av_freep(&block->exp); |
1548 |
av_freep(&block->grouped_exp); |
1549 |
av_freep(&block->psd); |
1550 |
av_freep(&block->band_psd); |
1551 |
av_freep(&block->mask); |
1552 |
av_freep(&block->qmant); |
1553 |
} |
1554 |
|
1555 |
mdct_end(&s->mdct); |
1556 |
|
1557 |
av_freep(&avctx->coded_frame); |
1558 |
return 0; |
1559 |
} |
1560 |
|
1561 |
|
1562 |
/**
|
1563 |
* Set channel information during initialization.
|
1564 |
*/
|
1565 |
static av_cold int set_channel_info(AC3EncodeContext *s, int channels, |
1566 |
int64_t *channel_layout) |
1567 |
{ |
1568 |
int ch_layout;
|
1569 |
|
1570 |
if (channels < 1 || channels > AC3_MAX_CHANNELS) |
1571 |
return AVERROR(EINVAL);
|
1572 |
if ((uint64_t)*channel_layout > 0x7FF) |
1573 |
return AVERROR(EINVAL);
|
1574 |
ch_layout = *channel_layout; |
1575 |
if (!ch_layout)
|
1576 |
ch_layout = avcodec_guess_channel_layout(channels, CODEC_ID_AC3, NULL);
|
1577 |
if (av_get_channel_layout_nb_channels(ch_layout) != channels)
|
1578 |
return AVERROR(EINVAL);
|
1579 |
|
1580 |
s->lfe_on = !!(ch_layout & AV_CH_LOW_FREQUENCY); |
1581 |
s->channels = channels; |
1582 |
s->fbw_channels = channels - s->lfe_on; |
1583 |
s->lfe_channel = s->lfe_on ? s->fbw_channels : -1;
|
1584 |
if (s->lfe_on)
|
1585 |
ch_layout -= AV_CH_LOW_FREQUENCY; |
1586 |
|
1587 |
switch (ch_layout) {
|
1588 |
case AV_CH_LAYOUT_MONO: s->channel_mode = AC3_CHMODE_MONO; break; |
1589 |
case AV_CH_LAYOUT_STEREO: s->channel_mode = AC3_CHMODE_STEREO; break; |
1590 |
case AV_CH_LAYOUT_SURROUND: s->channel_mode = AC3_CHMODE_3F; break; |
1591 |
case AV_CH_LAYOUT_2_1: s->channel_mode = AC3_CHMODE_2F1R; break; |
1592 |
case AV_CH_LAYOUT_4POINT0: s->channel_mode = AC3_CHMODE_3F1R; break; |
1593 |
case AV_CH_LAYOUT_QUAD:
|
1594 |
case AV_CH_LAYOUT_2_2: s->channel_mode = AC3_CHMODE_2F2R; break; |
1595 |
case AV_CH_LAYOUT_5POINT0:
|
1596 |
case AV_CH_LAYOUT_5POINT0_BACK: s->channel_mode = AC3_CHMODE_3F2R; break; |
1597 |
default:
|
1598 |
return AVERROR(EINVAL);
|
1599 |
} |
1600 |
|
1601 |
s->channel_map = ff_ac3_enc_channel_map[s->channel_mode][s->lfe_on]; |
1602 |
*channel_layout = ch_layout; |
1603 |
if (s->lfe_on)
|
1604 |
*channel_layout |= AV_CH_LOW_FREQUENCY; |
1605 |
|
1606 |
return 0; |
1607 |
} |
1608 |
|
1609 |
|
1610 |
static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s) |
1611 |
{ |
1612 |
int i, ret;
|
1613 |
|
1614 |
/* validate channel layout */
|
1615 |
if (!avctx->channel_layout) {
|
1616 |
av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
|
1617 |
"encoder will guess the layout, but it "
|
1618 |
"might be incorrect.\n");
|
1619 |
} |
1620 |
ret = set_channel_info(s, avctx->channels, &avctx->channel_layout); |
1621 |
if (ret) {
|
1622 |
av_log(avctx, AV_LOG_ERROR, "invalid channel layout\n");
|
1623 |
return ret;
|
1624 |
} |
1625 |
|
1626 |
/* validate sample rate */
|
1627 |
for (i = 0; i < 9; i++) { |
1628 |
if ((ff_ac3_sample_rate_tab[i / 3] >> (i % 3)) == avctx->sample_rate) |
1629 |
break;
|
1630 |
} |
1631 |
if (i == 9) { |
1632 |
av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
|
1633 |
return AVERROR(EINVAL);
|
1634 |
} |
1635 |
s->sample_rate = avctx->sample_rate; |
1636 |
s->bit_alloc.sr_shift = i % 3;
|
1637 |
s->bit_alloc.sr_code = i / 3;
|
1638 |
|
1639 |
/* validate bit rate */
|
1640 |
for (i = 0; i < 19; i++) { |
1641 |
if ((ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift)*1000 == avctx->bit_rate) |
1642 |
break;
|
1643 |
} |
1644 |
if (i == 19) { |
1645 |
av_log(avctx, AV_LOG_ERROR, "invalid bit rate\n");
|
1646 |
return AVERROR(EINVAL);
|
1647 |
} |
1648 |
s->bit_rate = avctx->bit_rate; |
1649 |
s->frame_size_code = i << 1;
|
1650 |
|
1651 |
/* validate cutoff */
|
1652 |
if (avctx->cutoff < 0) { |
1653 |
av_log(avctx, AV_LOG_ERROR, "invalid cutoff frequency\n");
|
1654 |
return AVERROR(EINVAL);
|
1655 |
} |
1656 |
s->cutoff = avctx->cutoff; |
1657 |
if (s->cutoff > (s->sample_rate >> 1)) |
1658 |
s->cutoff = s->sample_rate >> 1;
|
1659 |
|
1660 |
return 0; |
1661 |
} |
1662 |
|
1663 |
|
1664 |
/**
|
1665 |
* Set bandwidth for all channels.
|
1666 |
* The user can optionally supply a cutoff frequency. Otherwise an appropriate
|
1667 |
* default value will be used.
|
1668 |
*/
|
1669 |
static av_cold void set_bandwidth(AC3EncodeContext *s) |
1670 |
{ |
1671 |
int ch, bw_code;
|
1672 |
|
1673 |
if (s->cutoff) {
|
1674 |
/* calculate bandwidth based on user-specified cutoff frequency */
|
1675 |
int fbw_coeffs;
|
1676 |
fbw_coeffs = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
|
1677 |
bw_code = av_clip((fbw_coeffs - 73) / 3, 0, 60); |
1678 |
} else {
|
1679 |
/* use default bandwidth setting */
|
1680 |
/* XXX: should compute the bandwidth according to the frame
|
1681 |
size, so that we avoid annoying high frequency artifacts */
|
1682 |
bw_code = 50;
|
1683 |
} |
1684 |
|
1685 |
/* set number of coefficients for each channel */
|
1686 |
for (ch = 0; ch < s->fbw_channels; ch++) { |
1687 |
s->bandwidth_code[ch] = bw_code; |
1688 |
s->nb_coefs[ch] = bw_code * 3 + 73; |
1689 |
} |
1690 |
if (s->lfe_on)
|
1691 |
s->nb_coefs[s->lfe_channel] = 7; /* LFE channel always has 7 coefs */ |
1692 |
} |
1693 |
|
1694 |
|
1695 |
static av_cold int allocate_buffers(AVCodecContext *avctx) |
1696 |
{ |
1697 |
int blk, ch;
|
1698 |
AC3EncodeContext *s = avctx->priv_data; |
1699 |
|
1700 |
FF_ALLOC_OR_GOTO(avctx, s->planar_samples, s->channels * sizeof(*s->planar_samples),
|
1701 |
alloc_fail); |
1702 |
for (ch = 0; ch < s->channels; ch++) { |
1703 |
FF_ALLOCZ_OR_GOTO(avctx, s->planar_samples[ch], |
1704 |
(AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples),
|
1705 |
alloc_fail); |
1706 |
} |
1707 |
FF_ALLOC_OR_GOTO(avctx, s->bap_buffer, AC3_MAX_BLOCKS * s->channels * |
1708 |
AC3_MAX_COEFS * sizeof(*s->bap_buffer), alloc_fail);
|
1709 |
FF_ALLOC_OR_GOTO(avctx, s->bap1_buffer, AC3_MAX_BLOCKS * s->channels * |
1710 |
AC3_MAX_COEFS * sizeof(*s->bap1_buffer), alloc_fail);
|
1711 |
FF_ALLOC_OR_GOTO(avctx, s->mdct_coef_buffer, AC3_MAX_BLOCKS * s->channels * |
1712 |
AC3_MAX_COEFS * sizeof(*s->mdct_coef_buffer), alloc_fail);
|
1713 |
FF_ALLOC_OR_GOTO(avctx, s->exp_buffer, AC3_MAX_BLOCKS * s->channels * |
1714 |
AC3_MAX_COEFS * sizeof(*s->exp_buffer), alloc_fail);
|
1715 |
FF_ALLOC_OR_GOTO(avctx, s->grouped_exp_buffer, AC3_MAX_BLOCKS * s->channels * |
1716 |
128 * sizeof(*s->grouped_exp_buffer), alloc_fail); |
1717 |
FF_ALLOC_OR_GOTO(avctx, s->psd_buffer, AC3_MAX_BLOCKS * s->channels * |
1718 |
AC3_MAX_COEFS * sizeof(*s->psd_buffer), alloc_fail);
|
1719 |
FF_ALLOC_OR_GOTO(avctx, s->band_psd_buffer, AC3_MAX_BLOCKS * s->channels * |
1720 |
64 * sizeof(*s->band_psd_buffer), alloc_fail); |
1721 |
FF_ALLOC_OR_GOTO(avctx, s->mask_buffer, AC3_MAX_BLOCKS * s->channels * |
1722 |
64 * sizeof(*s->mask_buffer), alloc_fail); |
1723 |
FF_ALLOC_OR_GOTO(avctx, s->qmant_buffer, AC3_MAX_BLOCKS * s->channels * |
1724 |
AC3_MAX_COEFS * sizeof(*s->qmant_buffer), alloc_fail);
|
1725 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
1726 |
AC3Block *block = &s->blocks[blk]; |
1727 |
FF_ALLOC_OR_GOTO(avctx, block->bap, s->channels * sizeof(*block->bap),
|
1728 |
alloc_fail); |
1729 |
FF_ALLOCZ_OR_GOTO(avctx, block->mdct_coef, s->channels * sizeof(*block->mdct_coef),
|
1730 |
alloc_fail); |
1731 |
FF_ALLOCZ_OR_GOTO(avctx, block->exp, s->channels * sizeof(*block->exp),
|
1732 |
alloc_fail); |
1733 |
FF_ALLOCZ_OR_GOTO(avctx, block->grouped_exp, s->channels * sizeof(*block->grouped_exp),
|
1734 |
alloc_fail); |
1735 |
FF_ALLOCZ_OR_GOTO(avctx, block->psd, s->channels * sizeof(*block->psd),
|
1736 |
alloc_fail); |
1737 |
FF_ALLOCZ_OR_GOTO(avctx, block->band_psd, s->channels * sizeof(*block->band_psd),
|
1738 |
alloc_fail); |
1739 |
FF_ALLOCZ_OR_GOTO(avctx, block->mask, s->channels * sizeof(*block->mask),
|
1740 |
alloc_fail); |
1741 |
FF_ALLOCZ_OR_GOTO(avctx, block->qmant, s->channels * sizeof(*block->qmant),
|
1742 |
alloc_fail); |
1743 |
|
1744 |
for (ch = 0; ch < s->channels; ch++) { |
1745 |
/* arrangement: block, channel, coeff */
|
1746 |
block->bap[ch] = &s->bap_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)]; |
1747 |
block->mdct_coef[ch] = &s->mdct_coef_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)]; |
1748 |
block->grouped_exp[ch] = &s->grouped_exp_buffer[128 * (blk * s->channels + ch)];
|
1749 |
block->psd[ch] = &s->psd_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)]; |
1750 |
block->band_psd[ch] = &s->band_psd_buffer [64 * (blk * s->channels + ch)];
|
1751 |
block->mask[ch] = &s->mask_buffer [64 * (blk * s->channels + ch)];
|
1752 |
block->qmant[ch] = &s->qmant_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)]; |
1753 |
|
1754 |
/* arrangement: channel, block, coeff */
|
1755 |
block->exp[ch] = &s->exp_buffer [AC3_MAX_COEFS * (AC3_MAX_BLOCKS * ch + blk)]; |
1756 |
} |
1757 |
} |
1758 |
|
1759 |
if (CONFIG_AC3ENC_FLOAT) {
|
1760 |
FF_ALLOC_OR_GOTO(avctx, s->fixed_coef_buffer, AC3_MAX_BLOCKS * s->channels * |
1761 |
AC3_MAX_COEFS * sizeof(*s->fixed_coef_buffer), alloc_fail);
|
1762 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
1763 |
AC3Block *block = &s->blocks[blk]; |
1764 |
FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, s->channels * |
1765 |
sizeof(*block->fixed_coef), alloc_fail);
|
1766 |
for (ch = 0; ch < s->channels; ch++) |
1767 |
block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (blk * s->channels + ch)]; |
1768 |
} |
1769 |
} else {
|
1770 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { |
1771 |
AC3Block *block = &s->blocks[blk]; |
1772 |
FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, s->channels * |
1773 |
sizeof(*block->fixed_coef), alloc_fail);
|
1774 |
for (ch = 0; ch < s->channels; ch++) |
1775 |
block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch]; |
1776 |
} |
1777 |
} |
1778 |
|
1779 |
return 0; |
1780 |
alloc_fail:
|
1781 |
return AVERROR(ENOMEM);
|
1782 |
} |
1783 |
|
1784 |
|
1785 |
/**
|
1786 |
* Initialize the encoder.
|
1787 |
*/
|
1788 |
static av_cold int ac3_encode_init(AVCodecContext *avctx) |
1789 |
{ |
1790 |
AC3EncodeContext *s = avctx->priv_data; |
1791 |
int ret, frame_size_58;
|
1792 |
|
1793 |
avctx->frame_size = AC3_FRAME_SIZE; |
1794 |
|
1795 |
ff_ac3_common_init(); |
1796 |
|
1797 |
ret = validate_options(avctx, s); |
1798 |
if (ret)
|
1799 |
return ret;
|
1800 |
|
1801 |
s->bitstream_id = 8 + s->bit_alloc.sr_shift;
|
1802 |
s->bitstream_mode = 0; /* complete main audio service */ |
1803 |
|
1804 |
s->frame_size_min = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
|
1805 |
s->bits_written = 0;
|
1806 |
s->samples_written = 0;
|
1807 |
s->frame_size = s->frame_size_min; |
1808 |
|
1809 |
/* calculate crc_inv for both possible frame sizes */
|
1810 |
frame_size_58 = (( s->frame_size >> 2) + ( s->frame_size >> 4)) << 1; |
1811 |
s->crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY); |
1812 |
if (s->bit_alloc.sr_code == 1) { |
1813 |
frame_size_58 = (((s->frame_size+2) >> 2) + ((s->frame_size+2) >> 4)) << 1; |
1814 |
s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY); |
1815 |
} |
1816 |
|
1817 |
set_bandwidth(s); |
1818 |
|
1819 |
rematrixing_init(s); |
1820 |
|
1821 |
exponent_init(s); |
1822 |
|
1823 |
bit_alloc_init(s); |
1824 |
|
1825 |
ret = mdct_init(avctx, &s->mdct, 9);
|
1826 |
if (ret)
|
1827 |
goto init_fail;
|
1828 |
|
1829 |
ret = allocate_buffers(avctx); |
1830 |
if (ret)
|
1831 |
goto init_fail;
|
1832 |
|
1833 |
avctx->coded_frame= avcodec_alloc_frame(); |
1834 |
|
1835 |
dsputil_init(&s->dsp, avctx); |
1836 |
ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT); |
1837 |
|
1838 |
return 0; |
1839 |
init_fail:
|
1840 |
ac3_encode_close(avctx); |
1841 |
return ret;
|
1842 |
} |