ffmpeg / libavcodec / ac3enc.c @ 9be52d48
History  View  Annotate  Download (53.1 KB)
1 
/*


2 
* The simplest AC3 encoder

3 
* Copyright (c) 2000 Fabrice Bellard

4 
* Copyright (c) 20062010 Justin Ruggles <justin.ruggles@gmail.com>

5 
* Copyright (c) 20062010 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 021101301 USA

22 
*/

23  
24 
/**

25 
* @file

26 
* The simplest AC3 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 
* AC3 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]; ///< perblock 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 bitspersecond 
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 fullbandwidth 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; ///< userspecified 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 (signaltomask ratio) (fgaincod) 
118 
int fine_snr_offset[AC3_MAX_CHANNELS]; ///< fine SNR offsets (fsnroffst) 
119 
int frame_bits_fixed; ///< number of noncoefficient 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 strategy1][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 AC3 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 fixedpoint 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[blk1], 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 perchannel 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_strategy1][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[i1] + 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[k1] = exp[k2] = exp[k3] = 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 deltaencoded exponents are in each 7bit 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 (bap1) 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[blk1].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 nonzero 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_BLOCKS1; 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_BLOCKS1; 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_BLOCKS1; 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 nonzero 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 << (qbits1)); 
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 AC3 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, b1, q); break; 
1277 
} 
1278 
} 
1279 
} 
1280 
} 
1281  
1282  
1283 
/** CRC16 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 AC3 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 userspecified 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 
} 