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