ffmpeg / libavcodec / ac3enc.c @ 7e0a284b
History  View  Annotate  Download (58.3 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 
//#define ASSERT_LEVEL 2

31  
32 
#include "libavutil/audioconvert.h" 
33 
#include "libavutil/avassert.h" 
34 
#include "libavutil/crc.h" 
35 
#include "avcodec.h" 
36 
#include "put_bits.h" 
37 
#include "dsputil.h" 
38 
#include "ac3dsp.h" 
39 
#include "ac3.h" 
40 
#include "audioconvert.h" 
41  
42  
43 
#ifndef CONFIG_AC3ENC_FLOAT

44 
#define CONFIG_AC3ENC_FLOAT 0 
45 
#endif

46  
47  
48 
/** Maximum number of exponent groups. +1 for separate DC exponent. */

49 
#define AC3_MAX_EXP_GROUPS 85 
50  
51 
/* stereo rematrixing algorithms */

52 
#define AC3_REMATRIXING_IS_STATIC 0x1 
53 
#define AC3_REMATRIXING_SUMS 0 
54 
#define AC3_REMATRIXING_NONE 1 
55 
#define AC3_REMATRIXING_ALWAYS 3 
56  
57 
/** Scale a float value by 2^bits and convert to an integer. */

58 
#define SCALE_FLOAT(a, bits) lrintf((a) * (float)(1 << (bits))) 
59  
60  
61 
#if CONFIG_AC3ENC_FLOAT

62 
#include "ac3enc_float.h" 
63 
#else

64 
#include "ac3enc_fixed.h" 
65 
#endif

66  
67  
68 
/**

69 
* Data for a single audio block.

70 
*/

71 
typedef struct AC3Block { 
72 
uint8_t **bap; ///< bit allocation pointers (bap)

73 
CoefType **mdct_coef; ///< MDCT coefficients

74 
int32_t **fixed_coef; ///< fixedpoint MDCT coefficients

75 
uint8_t **exp; ///< original exponents

76 
uint8_t **grouped_exp; ///< grouped exponents

77 
int16_t **psd; ///< psd per frequency bin

78 
int16_t **band_psd; ///< psd per critical band

79 
int16_t **mask; ///< masking curve

80 
uint16_t **qmant; ///< quantized mantissas

81 
int8_t coeff_shift[AC3_MAX_CHANNELS]; ///< fixedpoint coefficient shift values

82 
uint8_t new_rematrixing_strategy; ///< send new rematrixing flags in this block

83 
uint8_t rematrixing_flags[4]; ///< rematrixing flags 
84 
} AC3Block; 
85  
86 
/**

87 
* AC3 encoder private context.

88 
*/

89 
typedef struct AC3EncodeContext { 
90 
PutBitContext pb; ///< bitstream writer context

91 
DSPContext dsp; 
92 
AC3DSPContext ac3dsp; ///< AC3 optimized functions

93 
AC3MDCTContext mdct; ///< MDCT context

94  
95 
AC3Block blocks[AC3_MAX_BLOCKS]; ///< perblock info

96  
97 
int bitstream_id; ///< bitstream id (bsid) 
98 
int bitstream_mode; ///< bitstream mode (bsmod) 
99  
100 
int bit_rate; ///< target bit rate, in bitspersecond 
101 
int sample_rate; ///< sampling frequency, in Hz 
102  
103 
int frame_size_min; ///< minimum frame size in case rounding is necessary 
104 
int frame_size; ///< current frame size in bytes 
105 
int frame_size_code; ///< frame size code (frmsizecod) 
106 
uint16_t crc_inv[2];

107 
int bits_written; ///< bit count (used to avg. bitrate) 
108 
int samples_written; ///< sample count (used to avg. bitrate) 
109  
110 
int fbw_channels; ///< number of fullbandwidth channels (nfchans) 
111 
int channels; ///< total number of channels (nchans) 
112 
int lfe_on; ///< indicates if there is an LFE channel (lfeon) 
113 
int lfe_channel; ///< channel index of the LFE channel 
114 
int channel_mode; ///< channel mode (acmod) 
115 
const uint8_t *channel_map; ///< channel map used to reorder channels 
116  
117 
int cutoff; ///< userspecified cutoff frequency, in Hz 
118 
int bandwidth_code[AC3_MAX_CHANNELS]; ///< bandwidth code (0 to 60) (chbwcod) 
119 
int nb_coefs[AC3_MAX_CHANNELS];

120  
121 
int rematrixing; ///< determines how rematrixing strategy is calculated 
122 
int num_rematrixing_bands; ///< number of rematrixing bands 
123  
124 
/* bitrate allocation control */

125 
int slow_gain_code; ///< slow gain code (sgaincod) 
126 
int slow_decay_code; ///< slow decay code (sdcycod) 
127 
int fast_decay_code; ///< fast decay code (fdcycod) 
128 
int db_per_bit_code; ///< dB/bit code (dbpbcod) 
129 
int floor_code; ///< floor code (floorcod) 
130 
AC3BitAllocParameters bit_alloc; ///< bit allocation parameters

131 
int coarse_snr_offset; ///< coarse SNR offsets (csnroffst) 
132 
int fast_gain_code[AC3_MAX_CHANNELS]; ///< fast gain codes (signaltomask ratio) (fgaincod) 
133 
int fine_snr_offset[AC3_MAX_CHANNELS]; ///< fine SNR offsets (fsnroffst) 
134 
int frame_bits_fixed; ///< number of noncoefficient bits for fixed parameters 
135 
int frame_bits; ///< all frame bits except exponents and mantissas 
136 
int exponent_bits; ///< number of bits used for exponents 
137  
138 
/* mantissa encoding */

139 
int mant1_cnt, mant2_cnt, mant4_cnt; ///< mantissa counts for bap=1,2,4 
140 
uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4

141  
142 
SampleType **planar_samples; 
143 
uint8_t *bap_buffer; 
144 
uint8_t *bap1_buffer; 
145 
CoefType *mdct_coef_buffer; 
146 
int32_t *fixed_coef_buffer; 
147 
uint8_t *exp_buffer; 
148 
uint8_t *grouped_exp_buffer; 
149 
int16_t *psd_buffer; 
150 
int16_t *band_psd_buffer; 
151 
int16_t *mask_buffer; 
152 
uint16_t *qmant_buffer; 
153  
154 
uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< exponent strategies

155  
156 
DECLARE_ALIGNED(16, SampleType, windowed_samples)[AC3_WINDOW_SIZE];

157 
} AC3EncodeContext; 
158  
159  
160 
/* prototypes for functions in ac3enc_fixed.c and ac3enc_float.c */

161  
162 
static av_cold void mdct_end(AC3MDCTContext *mdct); 
163  
164 
static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, 
165 
int nbits);

166  
167 
static void mdct512(AC3MDCTContext *mdct, CoefType *out, SampleType *in); 
168  
169 
static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input, 
170 
const SampleType *window, int n); 
171  
172 
static int normalize_samples(AC3EncodeContext *s); 
173  
174 
static void scale_coefficients(AC3EncodeContext *s); 
175  
176  
177 
/**

178 
* LUT for number of exponent groups.

179 
* exponent_group_tab[exponent strategy1][number of coefficients]

180 
*/

181 
static uint8_t exponent_group_tab[3][256]; 
182  
183  
184 
/**

185 
* List of supported channel layouts.

186 
*/

187 
static const int64_t ac3_channel_layouts[] = { 
188 
AV_CH_LAYOUT_MONO, 
189 
AV_CH_LAYOUT_STEREO, 
190 
AV_CH_LAYOUT_2_1, 
191 
AV_CH_LAYOUT_SURROUND, 
192 
AV_CH_LAYOUT_2_2, 
193 
AV_CH_LAYOUT_QUAD, 
194 
AV_CH_LAYOUT_4POINT0, 
195 
AV_CH_LAYOUT_5POINT0, 
196 
AV_CH_LAYOUT_5POINT0_BACK, 
197 
(AV_CH_LAYOUT_MONO  AV_CH_LOW_FREQUENCY), 
198 
(AV_CH_LAYOUT_STEREO  AV_CH_LOW_FREQUENCY), 
199 
(AV_CH_LAYOUT_2_1  AV_CH_LOW_FREQUENCY), 
200 
(AV_CH_LAYOUT_SURROUND  AV_CH_LOW_FREQUENCY), 
201 
(AV_CH_LAYOUT_2_2  AV_CH_LOW_FREQUENCY), 
202 
(AV_CH_LAYOUT_QUAD  AV_CH_LOW_FREQUENCY), 
203 
(AV_CH_LAYOUT_4POINT0  AV_CH_LOW_FREQUENCY), 
204 
AV_CH_LAYOUT_5POINT1, 
205 
AV_CH_LAYOUT_5POINT1_BACK, 
206 
0

207 
}; 
208  
209  
210 
/**

211 
* Adjust the frame size to make the average bit rate match the target bit rate.

212 
* This is only needed for 11025, 22050, and 44100 sample rates.

213 
*/

214 
static void adjust_frame_size(AC3EncodeContext *s) 
215 
{ 
216 
while (s>bits_written >= s>bit_rate && s>samples_written >= s>sample_rate) {

217 
s>bits_written = s>bit_rate; 
218 
s>samples_written = s>sample_rate; 
219 
} 
220 
s>frame_size = s>frame_size_min + 
221 
2 * (s>bits_written * s>sample_rate < s>samples_written * s>bit_rate);

222 
s>bits_written += s>frame_size * 8;

223 
s>samples_written += AC3_FRAME_SIZE; 
224 
} 
225  
226  
227 
/**

228 
* Deinterleave input samples.

229 
* Channels are reordered from FFmpeg's default order to AC3 order.

230 
*/

231 
static void deinterleave_input_samples(AC3EncodeContext *s, 
232 
const SampleType *samples)

233 
{ 
234 
int ch, i;

235  
236 
/* deinterleave and remap input samples */

237 
for (ch = 0; ch < s>channels; ch++) { 
238 
const SampleType *sptr;

239 
int sinc;

240  
241 
/* copy last 256 samples of previous frame to the start of the current frame */

242 
memcpy(&s>planar_samples[ch][0], &s>planar_samples[ch][AC3_FRAME_SIZE],

243 
AC3_BLOCK_SIZE * sizeof(s>planar_samples[0][0])); 
244  
245 
/* deinterleave */

246 
sinc = s>channels; 
247 
sptr = samples + s>channel_map[ch]; 
248 
for (i = AC3_BLOCK_SIZE; i < AC3_FRAME_SIZE+AC3_BLOCK_SIZE; i++) {

249 
s>planar_samples[ch][i] = *sptr; 
250 
sptr += sinc; 
251 
} 
252 
} 
253 
} 
254  
255  
256 
/**

257 
* Apply the MDCT to input samples to generate frequency coefficients.

258 
* This applies the KBD window and normalizes the input to reduce precision

259 
* loss due to fixedpoint calculations.

260 
*/

261 
static void apply_mdct(AC3EncodeContext *s) 
262 
{ 
263 
int blk, ch;

264  
265 
for (ch = 0; ch < s>channels; ch++) { 
266 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
267 
AC3Block *block = &s>blocks[blk]; 
268 
const SampleType *input_samples = &s>planar_samples[ch][blk * AC3_BLOCK_SIZE];

269  
270 
apply_window(&s>dsp, s>windowed_samples, input_samples, s>mdct.window, AC3_WINDOW_SIZE); 
271  
272 
block>coeff_shift[ch] = normalize_samples(s); 
273  
274 
mdct512(&s>mdct, block>mdct_coef[ch], s>windowed_samples); 
275 
} 
276 
} 
277 
} 
278  
279  
280 
/**

281 
* Initialize stereo rematrixing.

282 
* If the strategy does not change for each frame, set the rematrixing flags.

283 
*/

284 
static void rematrixing_init(AC3EncodeContext *s) 
285 
{ 
286 
if (s>channel_mode == AC3_CHMODE_STEREO)

287 
s>rematrixing = AC3_REMATRIXING_SUMS; 
288 
else

289 
s>rematrixing = AC3_REMATRIXING_NONE; 
290 
/* NOTE: AC3_REMATRIXING_ALWAYS might be used in

291 
the future in conjunction with channel coupling. */

292  
293 
if (s>rematrixing & AC3_REMATRIXING_IS_STATIC) {

294 
int flag = (s>rematrixing == AC3_REMATRIXING_ALWAYS);

295 
s>blocks[0].new_rematrixing_strategy = 1; 
296 
memset(s>blocks[0].rematrixing_flags, flag,

297 
sizeof(s>blocks[0].rematrixing_flags)); 
298 
} 
299 
} 
300  
301  
302 
/**

303 
* Determine rematrixing flags for each block and band.

304 
*/

305 
static void compute_rematrixing_strategy(AC3EncodeContext *s) 
306 
{ 
307 
int nb_coefs;

308 
int blk, bnd, i;

309 
AC3Block *block, *block0; 
310  
311 
s>num_rematrixing_bands = 4;

312  
313 
if (s>rematrixing & AC3_REMATRIXING_IS_STATIC)

314 
return;

315  
316 
nb_coefs = FFMIN(s>nb_coefs[0], s>nb_coefs[1]); 
317  
318 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
319 
block = &s>blocks[blk]; 
320 
block>new_rematrixing_strategy = !blk; 
321 
for (bnd = 0; bnd < s>num_rematrixing_bands; bnd++) { 
322 
/* calculate calculate sum of squared coeffs for one band in one block */

323 
int start = ff_ac3_rematrix_band_tab[bnd];

324 
int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]); 
325 
CoefSumType sum[4] = {0,}; 
326 
for (i = start; i < end; i++) {

327 
CoefType lt = block>mdct_coef[0][i];

328 
CoefType rt = block>mdct_coef[1][i];

329 
CoefType md = lt + rt; 
330 
CoefType sd = lt  rt; 
331 
sum[0] += MUL_COEF(lt, lt);

332 
sum[1] += MUL_COEF(rt, rt);

333 
sum[2] += MUL_COEF(md, md);

334 
sum[3] += MUL_COEF(sd, sd);

335 
} 
336  
337 
/* compare sums to determine if rematrixing will be used for this band */

338 
if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1])) 
339 
block>rematrixing_flags[bnd] = 1;

340 
else

341 
block>rematrixing_flags[bnd] = 0;

342  
343 
/* determine if new rematrixing flags will be sent */

344 
if (blk &&

345 
block>rematrixing_flags[bnd] != block0>rematrixing_flags[bnd]) { 
346 
block>new_rematrixing_strategy = 1;

347 
} 
348 
} 
349 
block0 = block; 
350 
} 
351 
} 
352  
353  
354 
/**

355 
* Apply stereo rematrixing to coefficients based on rematrixing flags.

356 
*/

357 
static void apply_rematrixing(AC3EncodeContext *s) 
358 
{ 
359 
int nb_coefs;

360 
int blk, bnd, i;

361 
int start, end;

362 
uint8_t *flags; 
363  
364 
if (s>rematrixing == AC3_REMATRIXING_NONE)

365 
return;

366  
367 
nb_coefs = FFMIN(s>nb_coefs[0], s>nb_coefs[1]); 
368  
369 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
370 
AC3Block *block = &s>blocks[blk]; 
371 
if (block>new_rematrixing_strategy)

372 
flags = block>rematrixing_flags; 
373 
for (bnd = 0; bnd < s>num_rematrixing_bands; bnd++) { 
374 
if (flags[bnd]) {

375 
start = ff_ac3_rematrix_band_tab[bnd]; 
376 
end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);

377 
for (i = start; i < end; i++) {

378 
int32_t lt = block>fixed_coef[0][i];

379 
int32_t rt = block>fixed_coef[1][i];

380 
block>fixed_coef[0][i] = (lt + rt) >> 1; 
381 
block>fixed_coef[1][i] = (lt  rt) >> 1; 
382 
} 
383 
} 
384 
} 
385 
} 
386 
} 
387  
388  
389 
/**

390 
* Initialize exponent tables.

391 
*/

392 
static av_cold void exponent_init(AC3EncodeContext *s) 
393 
{ 
394 
int i;

395 
for (i = 73; i < 256; i++) { 
396 
exponent_group_tab[0][i] = (i  1) / 3; 
397 
exponent_group_tab[1][i] = (i + 2) / 6; 
398 
exponent_group_tab[2][i] = (i + 8) / 12; 
399 
} 
400 
/* LFE */

401 
exponent_group_tab[0][7] = 2; 
402 
} 
403  
404  
405 
/**

406 
* Extract exponents from the MDCT coefficients.

407 
* This takes into account the normalization that was done to the input samples

408 
* by adjusting the exponents by the exponent shift values.

409 
*/

410 
static void extract_exponents(AC3EncodeContext *s) 
411 
{ 
412 
int blk, ch, i;

413  
414 
for (ch = 0; ch < s>channels; ch++) { 
415 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
416 
AC3Block *block = &s>blocks[blk]; 
417 
uint8_t *exp = block>exp[ch]; 
418 
int32_t *coef = block>fixed_coef[ch]; 
419 
for (i = 0; i < AC3_MAX_COEFS; i++) { 
420 
int e;

421 
int v = abs(coef[i]);

422 
if (v == 0) 
423 
e = 24;

424 
else {

425 
e = 23  av_log2(v);

426 
if (e >= 24) { 
427 
e = 24;

428 
coef[i] = 0;

429 
} 
430 
av_assert2(e >= 0);

431 
} 
432 
exp[i] = e; 
433 
} 
434 
} 
435 
} 
436 
} 
437  
438  
439 
/**

440 
* Exponent Difference Threshold.

441 
* New exponents are sent if their SAD exceed this number.

442 
*/

443 
#define EXP_DIFF_THRESHOLD 500 
444  
445  
446 
/**

447 
* Calculate exponent strategies for all blocks in a single channel.

448 
*/

449 
static void compute_exp_strategy_ch(AC3EncodeContext *s, uint8_t *exp_strategy, 
450 
uint8_t *exp) 
451 
{ 
452 
int blk, blk1;

453 
int exp_diff;

454  
455 
/* estimate if the exponent variation & decide if they should be

456 
reused in the next frame */

457 
exp_strategy[0] = EXP_NEW;

458 
exp += AC3_MAX_COEFS; 
459 
for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) { 
460 
exp_diff = s>dsp.sad[0](NULL, exp, exp  AC3_MAX_COEFS, 16, 16); 
461 
if (exp_diff > EXP_DIFF_THRESHOLD)

462 
exp_strategy[blk] = EXP_NEW; 
463 
else

464 
exp_strategy[blk] = EXP_REUSE; 
465 
exp += AC3_MAX_COEFS; 
466 
} 
467  
468 
/* now select the encoding strategy type : if exponents are often

469 
recoded, we use a coarse encoding */

470 
blk = 0;

471 
while (blk < AC3_MAX_BLOCKS) {

472 
blk1 = blk + 1;

473 
while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)

474 
blk1++; 
475 
switch (blk1  blk) {

476 
case 1: exp_strategy[blk] = EXP_D45; break; 
477 
case 2: 
478 
case 3: exp_strategy[blk] = EXP_D25; break; 
479 
default: exp_strategy[blk] = EXP_D15; break; 
480 
} 
481 
blk = blk1; 
482 
} 
483 
} 
484  
485  
486 
/**

487 
* Calculate exponent strategies for all channels.

488 
* Array arrangement is reversed to simplify the perchannel calculation.

489 
*/

490 
static void compute_exp_strategy(AC3EncodeContext *s) 
491 
{ 
492 
int ch, blk;

493  
494 
for (ch = 0; ch < s>fbw_channels; ch++) { 
495 
compute_exp_strategy_ch(s, s>exp_strategy[ch], s>blocks[0].exp[ch]);

496 
} 
497 
if (s>lfe_on) {

498 
ch = s>lfe_channel; 
499 
s>exp_strategy[ch][0] = EXP_D15;

500 
for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) 
501 
s>exp_strategy[ch][blk] = EXP_REUSE; 
502 
} 
503 
} 
504  
505  
506 
/**

507 
* Update the exponents so that they are the ones the decoder will decode.

508 
*/

509 
static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy) 
510 
{ 
511 
int nb_groups, i, k;

512  
513 
nb_groups = exponent_group_tab[exp_strategy1][nb_exps] * 3; 
514  
515 
/* for each group, compute the minimum exponent */

516 
switch(exp_strategy) {

517 
case EXP_D25:

518 
for (i = 1, k = 1; i <= nb_groups; i++) { 
519 
uint8_t exp_min = exp[k]; 
520 
if (exp[k+1] < exp_min) 
521 
exp_min = exp[k+1];

522 
exp[i] = exp_min; 
523 
k += 2;

524 
} 
525 
break;

526 
case EXP_D45:

527 
for (i = 1, k = 1; i <= nb_groups; i++) { 
528 
uint8_t exp_min = exp[k]; 
529 
if (exp[k+1] < exp_min) 
530 
exp_min = exp[k+1];

531 
if (exp[k+2] < exp_min) 
532 
exp_min = exp[k+2];

533 
if (exp[k+3] < exp_min) 
534 
exp_min = exp[k+3];

535 
exp[i] = exp_min; 
536 
k += 4;

537 
} 
538 
break;

539 
} 
540  
541 
/* constraint for DC exponent */

542 
if (exp[0] > 15) 
543 
exp[0] = 15; 
544  
545 
/* decrease the delta between each groups to within 2 so that they can be

546 
differentially encoded */

547 
for (i = 1; i <= nb_groups; i++) 
548 
exp[i] = FFMIN(exp[i], exp[i1] + 2); 
549 
i; 
550 
while (i >= 0) 
551 
exp[i] = FFMIN(exp[i], exp[i+1] + 2); 
552  
553 
/* now we have the exponent values the decoder will see */

554 
switch (exp_strategy) {

555 
case EXP_D25:

556 
for (i = nb_groups, k = nb_groups * 2; i > 0; i) { 
557 
uint8_t exp1 = exp[i]; 
558 
exp[k] = exp1; 
559 
exp[k] = exp1; 
560 
} 
561 
break;

562 
case EXP_D45:

563 
for (i = nb_groups, k = nb_groups * 4; i > 0; i) { 
564 
exp[k] = exp[k1] = exp[k2] = exp[k3] = exp[i]; 
565 
k = 4;

566 
} 
567 
break;

568 
} 
569 
} 
570  
571  
572 
/**

573 
* Encode exponents from original extracted form to what the decoder will see.

574 
* This copies and groups exponents based on exponent strategy and reduces

575 
* deltas between adjacent exponent groups so that they can be differentially

576 
* encoded.

577 
*/

578 
static void encode_exponents(AC3EncodeContext *s) 
579 
{ 
580 
int blk, blk1, ch;

581 
uint8_t *exp, *exp1, *exp_strategy; 
582 
int nb_coefs, num_reuse_blocks;

583  
584 
for (ch = 0; ch < s>channels; ch++) { 
585 
exp = s>blocks[0].exp[ch];

586 
exp_strategy = s>exp_strategy[ch]; 
587 
nb_coefs = s>nb_coefs[ch]; 
588  
589 
blk = 0;

590 
while (blk < AC3_MAX_BLOCKS) {

591 
blk1 = blk + 1;

592  
593 
/* count the number of EXP_REUSE blocks after the current block */

594 
while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)

595 
blk1++; 
596 
num_reuse_blocks = blk1  blk  1;

597  
598 
/* for the EXP_REUSE case we select the min of the exponents */

599 
s>ac3dsp.ac3_exponent_min(exp, num_reuse_blocks, nb_coefs); 
600  
601 
encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk]); 
602  
603 
/* copy encoded exponents for reuse case */

604 
exp1 = exp + AC3_MAX_COEFS; 
605 
while (blk < blk11) { 
606 
memcpy(exp1, exp, nb_coefs * sizeof(*exp));

607 
exp1 += AC3_MAX_COEFS; 
608 
blk++; 
609 
} 
610 
blk = blk1; 
611 
exp = exp1; 
612 
} 
613 
} 
614 
} 
615  
616  
617 
/**

618 
* Group exponents.

619 
* 3 deltaencoded exponents are in each 7bit group. The number of groups

620 
* varies depending on exponent strategy and bandwidth.

621 
*/

622 
static void group_exponents(AC3EncodeContext *s) 
623 
{ 
624 
int blk, ch, i;

625 
int group_size, nb_groups, bit_count;

626 
uint8_t *p; 
627 
int delta0, delta1, delta2;

628 
int exp0, exp1;

629  
630 
bit_count = 0;

631 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
632 
AC3Block *block = &s>blocks[blk]; 
633 
for (ch = 0; ch < s>channels; ch++) { 
634 
int exp_strategy = s>exp_strategy[ch][blk];

635 
if (exp_strategy == EXP_REUSE)

636 
continue;

637 
group_size = exp_strategy + (exp_strategy == EXP_D45); 
638 
nb_groups = exponent_group_tab[exp_strategy1][s>nb_coefs[ch]];

639 
bit_count += 4 + (nb_groups * 7); 
640 
p = block>exp[ch]; 
641  
642 
/* DC exponent */

643 
exp1 = *p++; 
644 
block>grouped_exp[ch][0] = exp1;

645  
646 
/* remaining exponents are delta encoded */

647 
for (i = 1; i <= nb_groups; i++) { 
648 
/* merge three delta in one code */

649 
exp0 = exp1; 
650 
exp1 = p[0];

651 
p += group_size; 
652 
delta0 = exp1  exp0 + 2;

653 
av_assert2(delta0 >= 0 && delta0 <= 4); 
654  
655 
exp0 = exp1; 
656 
exp1 = p[0];

657 
p += group_size; 
658 
delta1 = exp1  exp0 + 2;

659 
av_assert2(delta1 >= 0 && delta1 <= 4); 
660  
661 
exp0 = exp1; 
662 
exp1 = p[0];

663 
p += group_size; 
664 
delta2 = exp1  exp0 + 2;

665 
av_assert2(delta2 >= 0 && delta2 <= 4); 
666  
667 
block>grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2; 
668 
} 
669 
} 
670 
} 
671  
672 
s>exponent_bits = bit_count; 
673 
} 
674  
675  
676 
/**

677 
* Calculate final exponents from the supplied MDCT coefficients and exponent shift.

678 
* Extract exponents from MDCT coefficients, calculate exponent strategies,

679 
* and encode final exponents.

680 
*/

681 
static void process_exponents(AC3EncodeContext *s) 
682 
{ 
683 
extract_exponents(s); 
684  
685 
compute_exp_strategy(s); 
686  
687 
encode_exponents(s); 
688  
689 
group_exponents(s); 
690  
691 
emms_c(); 
692 
} 
693  
694  
695 
/**

696 
* Count frame bits that are based solely on fixed parameters.

697 
* This only has to be run once when the encoder is initialized.

698 
*/

699 
static void count_frame_bits_fixed(AC3EncodeContext *s) 
700 
{ 
701 
static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 }; 
702 
int blk;

703 
int frame_bits;

704  
705 
/* assumptions:

706 
* no dynamic range codes

707 
* no channel coupling

708 
* bit allocation parameters do not change between blocks

709 
* SNR offsets do not change between blocks

710 
* no delta bit allocation

711 
* no skipped data

712 
* no auxilliary data

713 
*/

714  
715 
/* header size */

716 
frame_bits = 65;

717 
frame_bits += frame_bits_inc[s>channel_mode]; 
718  
719 
/* audio blocks */

720 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
721 
frame_bits += s>fbw_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */ 
722 
if (s>channel_mode == AC3_CHMODE_STEREO) {

723 
frame_bits++; /* rematstr */

724 
} 
725 
frame_bits += 2 * s>fbw_channels; /* chexpstr[2] * c */ 
726 
if (s>lfe_on)

727 
frame_bits++; /* lfeexpstr */

728 
frame_bits++; /* baie */

729 
frame_bits++; /* snr */

730 
frame_bits += 2; /* delta / skip */ 
731 
} 
732 
frame_bits++; /* cplinu for block 0 */

733 
/* bit alloc info */

734 
/* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */

735 
/* csnroffset[6] */

736 
/* (fsnoffset[4] + fgaincod[4]) * c */

737 
frame_bits += 2*4 + 3 + 6 + s>channels * (4 + 3); 
738  
739 
/* auxdatae, crcrsv */

740 
frame_bits += 2;

741  
742 
/* CRC */

743 
frame_bits += 16;

744  
745 
s>frame_bits_fixed = frame_bits; 
746 
} 
747  
748  
749 
/**

750 
* Initialize bit allocation.

751 
* Set default parameter codes and calculate parameter values.

752 
*/

753 
static void bit_alloc_init(AC3EncodeContext *s) 
754 
{ 
755 
int ch;

756  
757 
/* init default parameters */

758 
s>slow_decay_code = 2;

759 
s>fast_decay_code = 1;

760 
s>slow_gain_code = 1;

761 
s>db_per_bit_code = 3;

762 
s>floor_code = 7;

763 
for (ch = 0; ch < s>channels; ch++) 
764 
s>fast_gain_code[ch] = 4;

765  
766 
/* initial snr offset */

767 
s>coarse_snr_offset = 40;

768  
769 
/* compute real values */

770 
/* currently none of these values change during encoding, so we can just

771 
set them once at initialization */

772 
s>bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s>slow_decay_code] >> s>bit_alloc.sr_shift; 
773 
s>bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s>fast_decay_code] >> s>bit_alloc.sr_shift; 
774 
s>bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s>slow_gain_code]; 
775 
s>bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s>db_per_bit_code]; 
776 
s>bit_alloc.floor = ff_ac3_floor_tab[s>floor_code]; 
777  
778 
count_frame_bits_fixed(s); 
779 
} 
780  
781  
782 
/**

783 
* Count the bits used to encode the frame, minus exponents and mantissas.

784 
* Bits based on fixed parameters have already been counted, so now we just

785 
* have to add the bits based on parameters that change during encoding.

786 
*/

787 
static void count_frame_bits(AC3EncodeContext *s) 
788 
{ 
789 
int blk, ch;

790 
int frame_bits = 0; 
791  
792 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
793 
/* stereo rematrixing */

794 
if (s>channel_mode == AC3_CHMODE_STEREO &&

795 
s>blocks[blk].new_rematrixing_strategy) { 
796 
frame_bits += s>num_rematrixing_bands; 
797 
} 
798  
799 
for (ch = 0; ch < s>fbw_channels; ch++) { 
800 
if (s>exp_strategy[ch][blk] != EXP_REUSE)

801 
frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */ 
802 
} 
803 
} 
804 
s>frame_bits = s>frame_bits_fixed + frame_bits; 
805 
} 
806  
807  
808 
/**

809 
* Calculate the number of bits needed to encode a set of mantissas.

810 
*/

811 
static int compute_mantissa_size(int mant_cnt[5], uint8_t *bap, int nb_coefs) 
812 
{ 
813 
int bits, b, i;

814  
815 
bits = 0;

816 
for (i = 0; i < nb_coefs; i++) { 
817 
b = bap[i]; 
818 
if (b <= 4) { 
819 
// bap=1 to bap=4 will be counted in compute_mantissa_size_final

820 
mant_cnt[b]++; 
821 
} else if (b <= 13) { 
822 
// bap=5 to bap=13 use (bap1) bits

823 
bits += b  1;

824 
} else {

825 
// bap=14 uses 14 bits and bap=15 uses 16 bits

826 
bits += (b == 14) ? 14 : 16; 
827 
} 
828 
} 
829 
return bits;

830 
} 
831  
832  
833 
/**

834 
* Finalize the mantissa bit count by adding in the grouped mantissas.

835 
*/

836 
static int compute_mantissa_size_final(int mant_cnt[5]) 
837 
{ 
838 
// bap=1 : 3 mantissas in 5 bits

839 
int bits = (mant_cnt[1] / 3) * 5; 
840 
// bap=2 : 3 mantissas in 7 bits

841 
// bap=4 : 2 mantissas in 7 bits

842 
bits += ((mant_cnt[2] / 3) + (mant_cnt[4] >> 1)) * 7; 
843 
// bap=3 : each mantissa is 3 bits

844 
bits += mant_cnt[3] * 3; 
845 
return bits;

846 
} 
847  
848  
849 
/**

850 
* Calculate masking curve based on the final exponents.

851 
* Also calculate the power spectral densities to use in future calculations.

852 
*/

853 
static void bit_alloc_masking(AC3EncodeContext *s) 
854 
{ 
855 
int blk, ch;

856  
857 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
858 
AC3Block *block = &s>blocks[blk]; 
859 
for (ch = 0; ch < s>channels; ch++) { 
860 
/* We only need psd and mask for calculating bap.

861 
Since we currently do not calculate bap when exponent

862 
strategy is EXP_REUSE we do not need to calculate psd or mask. */

863 
if (s>exp_strategy[ch][blk] != EXP_REUSE) {

864 
ff_ac3_bit_alloc_calc_psd(block>exp[ch], 0,

865 
s>nb_coefs[ch], 
866 
block>psd[ch], block>band_psd[ch]); 
867 
ff_ac3_bit_alloc_calc_mask(&s>bit_alloc, block>band_psd[ch], 
868 
0, s>nb_coefs[ch],

869 
ff_ac3_fast_gain_tab[s>fast_gain_code[ch]], 
870 
ch == s>lfe_channel, 
871 
DBA_NONE, 0, NULL, NULL, NULL, 
872 
block>mask[ch]); 
873 
} 
874 
} 
875 
} 
876 
} 
877  
878  
879 
/**

880 
* Ensure that bap for each block and channel point to the current bap_buffer.

881 
* They may have been switched during the bit allocation search.

882 
*/

883 
static void reset_block_bap(AC3EncodeContext *s) 
884 
{ 
885 
int blk, ch;

886 
if (s>blocks[0].bap[0] == s>bap_buffer) 
887 
return;

888 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
889 
for (ch = 0; ch < s>channels; ch++) { 
890 
s>blocks[blk].bap[ch] = &s>bap_buffer[AC3_MAX_COEFS * (blk * s>channels + ch)]; 
891 
} 
892 
} 
893 
} 
894  
895  
896 
/**

897 
* Run the bit allocation with a given SNR offset.

898 
* This calculates the bit allocation pointers that will be used to determine

899 
* the quantization of each mantissa.

900 
* @return the number of bits needed for mantissas if the given SNR offset is

901 
* is used.

902 
*/

903 
static int bit_alloc(AC3EncodeContext *s, int snr_offset) 
904 
{ 
905 
int blk, ch;

906 
int mantissa_bits;

907 
int mant_cnt[5]; 
908  
909 
snr_offset = (snr_offset  240) << 2; 
910  
911 
reset_block_bap(s); 
912 
mantissa_bits = 0;

913 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
914 
AC3Block *block = &s>blocks[blk]; 
915 
// initialize grouped mantissa counts. these are set so that they are

916 
// padded to the next whole group size when bits are counted in

917 
// compute_mantissa_size_final

918 
mant_cnt[0] = mant_cnt[3] = 0; 
919 
mant_cnt[1] = mant_cnt[2] = 2; 
920 
mant_cnt[4] = 1; 
921 
for (ch = 0; ch < s>channels; ch++) { 
922 
/* Currently the only bit allocation parameters which vary across

923 
blocks within a frame are the exponent values. We can take

924 
advantage of that by reusing the bit allocation pointers

925 
whenever we reuse exponents. */

926 
if (s>exp_strategy[ch][blk] == EXP_REUSE) {

927 
memcpy(block>bap[ch], s>blocks[blk1].bap[ch], AC3_MAX_COEFS);

928 
} else {

929 
ff_ac3_bit_alloc_calc_bap(block>mask[ch], block>psd[ch], 0,

930 
s>nb_coefs[ch], snr_offset, 
931 
s>bit_alloc.floor, ff_ac3_bap_tab, 
932 
block>bap[ch]); 
933 
} 
934 
mantissa_bits += compute_mantissa_size(mant_cnt, block>bap[ch], s>nb_coefs[ch]); 
935 
} 
936 
mantissa_bits += compute_mantissa_size_final(mant_cnt); 
937 
} 
938 
return mantissa_bits;

939 
} 
940  
941  
942 
/**

943 
* Constant bitrate bit allocation search.

944 
* Find the largest SNR offset that will allow data to fit in the frame.

945 
*/

946 
static int cbr_bit_allocation(AC3EncodeContext *s) 
947 
{ 
948 
int ch;

949 
int bits_left;

950 
int snr_offset, snr_incr;

951  
952 
bits_left = 8 * s>frame_size  (s>frame_bits + s>exponent_bits);

953 
av_assert2(bits_left >= 0);

954  
955 
snr_offset = s>coarse_snr_offset << 4;

956  
957 
/* if previous frame SNR offset was 1023, check if current frame can also

958 
use SNR offset of 1023. if so, skip the search. */

959 
if ((snr_offset  s>fine_snr_offset[0]) == 1023) { 
960 
if (bit_alloc(s, 1023) <= bits_left) 
961 
return 0; 
962 
} 
963  
964 
while (snr_offset >= 0 && 
965 
bit_alloc(s, snr_offset) > bits_left) { 
966 
snr_offset = 64;

967 
} 
968 
if (snr_offset < 0) 
969 
return AVERROR(EINVAL);

970  
971 
FFSWAP(uint8_t *, s>bap_buffer, s>bap1_buffer); 
972 
for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) { 
973 
while (snr_offset + snr_incr <= 1023 && 
974 
bit_alloc(s, snr_offset + snr_incr) <= bits_left) { 
975 
snr_offset += snr_incr; 
976 
FFSWAP(uint8_t *, s>bap_buffer, s>bap1_buffer); 
977 
} 
978 
} 
979 
FFSWAP(uint8_t *, s>bap_buffer, s>bap1_buffer); 
980 
reset_block_bap(s); 
981  
982 
s>coarse_snr_offset = snr_offset >> 4;

983 
for (ch = 0; ch < s>channels; ch++) 
984 
s>fine_snr_offset[ch] = snr_offset & 0xF;

985  
986 
return 0; 
987 
} 
988  
989  
990 
/**

991 
* Downgrade exponent strategies to reduce the bits used by the exponents.

992 
* This is a fallback for when bit allocation fails with the normal exponent

993 
* strategies. Each time this function is run it only downgrades the

994 
* strategy in 1 channel of 1 block.

995 
* @return nonzero if downgrade was unsuccessful

996 
*/

997 
static int downgrade_exponents(AC3EncodeContext *s) 
998 
{ 
999 
int ch, blk;

1000  
1001 
for (ch = 0; ch < s>fbw_channels; ch++) { 
1002 
for (blk = AC3_MAX_BLOCKS1; blk >= 0; blk) { 
1003 
if (s>exp_strategy[ch][blk] == EXP_D15) {

1004 
s>exp_strategy[ch][blk] = EXP_D25; 
1005 
return 0; 
1006 
} 
1007 
} 
1008 
} 
1009 
for (ch = 0; ch < s>fbw_channels; ch++) { 
1010 
for (blk = AC3_MAX_BLOCKS1; blk >= 0; blk) { 
1011 
if (s>exp_strategy[ch][blk] == EXP_D25) {

1012 
s>exp_strategy[ch][blk] = EXP_D45; 
1013 
return 0; 
1014 
} 
1015 
} 
1016 
} 
1017 
for (ch = 0; ch < s>fbw_channels; ch++) { 
1018 
/* block 0 cannot reuse exponents, so only downgrade D45 to REUSE if

1019 
the block number > 0 */

1020 
for (blk = AC3_MAX_BLOCKS1; blk > 0; blk) { 
1021 
if (s>exp_strategy[ch][blk] > EXP_REUSE) {

1022 
s>exp_strategy[ch][blk] = EXP_REUSE; 
1023 
return 0; 
1024 
} 
1025 
} 
1026 
} 
1027 
return 1; 
1028 
} 
1029  
1030  
1031 
/**

1032 
* Reduce the bandwidth to reduce the number of bits used for a given SNR offset.

1033 
* This is a second fallback for when bit allocation still fails after exponents

1034 
* have been downgraded.

1035 
* @return nonzero if bandwidth reduction was unsuccessful

1036 
*/

1037 
static int reduce_bandwidth(AC3EncodeContext *s, int min_bw_code) 
1038 
{ 
1039 
int ch;

1040  
1041 
if (s>bandwidth_code[0] > min_bw_code) { 
1042 
for (ch = 0; ch < s>fbw_channels; ch++) { 
1043 
s>bandwidth_code[ch]; 
1044 
s>nb_coefs[ch] = s>bandwidth_code[ch] * 3 + 73; 
1045 
} 
1046 
return 0; 
1047 
} 
1048 
return 1; 
1049 
} 
1050  
1051  
1052 
/**

1053 
* Perform bit allocation search.

1054 
* Finds the SNR offset value that maximizes quality and fits in the specified

1055 
* frame size. Output is the SNR offset and a set of bit allocation pointers

1056 
* used to quantize the mantissas.

1057 
*/

1058 
static int compute_bit_allocation(AC3EncodeContext *s) 
1059 
{ 
1060 
int ret;

1061  
1062 
count_frame_bits(s); 
1063  
1064 
bit_alloc_masking(s); 
1065  
1066 
ret = cbr_bit_allocation(s); 
1067 
while (ret) {

1068 
/* fallback 1: downgrade exponents */

1069 
if (!downgrade_exponents(s)) {

1070 
extract_exponents(s); 
1071 
encode_exponents(s); 
1072 
group_exponents(s); 
1073 
ret = compute_bit_allocation(s); 
1074 
continue;

1075 
} 
1076  
1077 
/* fallback 2: reduce bandwidth */

1078 
/* only do this if the user has not specified a specific cutoff

1079 
frequency */

1080 
if (!s>cutoff && !reduce_bandwidth(s, 0)) { 
1081 
process_exponents(s); 
1082 
ret = compute_bit_allocation(s); 
1083 
continue;

1084 
} 
1085  
1086 
/* fallbacks were not enough... */

1087 
break;

1088 
} 
1089  
1090 
return ret;

1091 
} 
1092  
1093  
1094 
/**

1095 
* Symmetric quantization on 'levels' levels.

1096 
*/

1097 
static inline int sym_quant(int c, int e, int levels) 
1098 
{ 
1099 
int v;

1100  
1101 
if (c >= 0) { 
1102 
v = (levels * (c << e)) >> 24;

1103 
v = (v + 1) >> 1; 
1104 
v = (levels >> 1) + v;

1105 
} else {

1106 
v = (levels * ((c) << e)) >> 24;

1107 
v = (v + 1) >> 1; 
1108 
v = (levels >> 1)  v;

1109 
} 
1110 
av_assert2(v >= 0 && v < levels);

1111 
return v;

1112 
} 
1113  
1114  
1115 
/**

1116 
* Asymmetric quantization on 2^qbits levels.

1117 
*/

1118 
static inline int asym_quant(int c, int e, int qbits) 
1119 
{ 
1120 
int lshift, m, v;

1121  
1122 
lshift = e + qbits  24;

1123 
if (lshift >= 0) 
1124 
v = c << lshift; 
1125 
else

1126 
v = c >> (lshift); 
1127 
/* rounding */

1128 
v = (v + 1) >> 1; 
1129 
m = (1 << (qbits1)); 
1130 
if (v >= m)

1131 
v = m  1;

1132 
av_assert2(v >= m); 
1133 
return v & ((1 << qbits)1); 
1134 
} 
1135  
1136  
1137 
/**

1138 
* Quantize a set of mantissas for a single channel in a single block.

1139 
*/

1140 
static void quantize_mantissas_blk_ch(AC3EncodeContext *s, int32_t *fixed_coef, 
1141 
uint8_t *exp, 
1142 
uint8_t *bap, uint16_t *qmant, int n)

1143 
{ 
1144 
int i;

1145  
1146 
for (i = 0; i < n; i++) { 
1147 
int v;

1148 
int c = fixed_coef[i];

1149 
int e = exp[i];

1150 
int b = bap[i];

1151 
switch (b) {

1152 
case 0: 
1153 
v = 0;

1154 
break;

1155 
case 1: 
1156 
v = sym_quant(c, e, 3);

1157 
switch (s>mant1_cnt) {

1158 
case 0: 
1159 
s>qmant1_ptr = &qmant[i]; 
1160 
v = 9 * v;

1161 
s>mant1_cnt = 1;

1162 
break;

1163 
case 1: 
1164 
*s>qmant1_ptr += 3 * v;

1165 
s>mant1_cnt = 2;

1166 
v = 128;

1167 
break;

1168 
default:

1169 
*s>qmant1_ptr += v; 
1170 
s>mant1_cnt = 0;

1171 
v = 128;

1172 
break;

1173 
} 
1174 
break;

1175 
case 2: 
1176 
v = sym_quant(c, e, 5);

1177 
switch (s>mant2_cnt) {

1178 
case 0: 
1179 
s>qmant2_ptr = &qmant[i]; 
1180 
v = 25 * v;

1181 
s>mant2_cnt = 1;

1182 
break;

1183 
case 1: 
1184 
*s>qmant2_ptr += 5 * v;

1185 
s>mant2_cnt = 2;

1186 
v = 128;

1187 
break;

1188 
default:

1189 
*s>qmant2_ptr += v; 
1190 
s>mant2_cnt = 0;

1191 
v = 128;

1192 
break;

1193 
} 
1194 
break;

1195 
case 3: 
1196 
v = sym_quant(c, e, 7);

1197 
break;

1198 
case 4: 
1199 
v = sym_quant(c, e, 11);

1200 
switch (s>mant4_cnt) {

1201 
case 0: 
1202 
s>qmant4_ptr = &qmant[i]; 
1203 
v = 11 * v;

1204 
s>mant4_cnt = 1;

1205 
break;

1206 
default:

1207 
*s>qmant4_ptr += v; 
1208 
s>mant4_cnt = 0;

1209 
v = 128;

1210 
break;

1211 
} 
1212 
break;

1213 
case 5: 
1214 
v = sym_quant(c, e, 15);

1215 
break;

1216 
case 14: 
1217 
v = asym_quant(c, e, 14);

1218 
break;

1219 
case 15: 
1220 
v = asym_quant(c, e, 16);

1221 
break;

1222 
default:

1223 
v = asym_quant(c, e, b  1);

1224 
break;

1225 
} 
1226 
qmant[i] = v; 
1227 
} 
1228 
} 
1229  
1230  
1231 
/**

1232 
* Quantize mantissas using coefficients, exponents, and bit allocation pointers.

1233 
*/

1234 
static void quantize_mantissas(AC3EncodeContext *s) 
1235 
{ 
1236 
int blk, ch;

1237  
1238  
1239 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
1240 
AC3Block *block = &s>blocks[blk]; 
1241 
s>mant1_cnt = s>mant2_cnt = s>mant4_cnt = 0;

1242 
s>qmant1_ptr = s>qmant2_ptr = s>qmant4_ptr = NULL;

1243  
1244 
for (ch = 0; ch < s>channels; ch++) { 
1245 
quantize_mantissas_blk_ch(s, block>fixed_coef[ch], 
1246 
block>exp[ch], block>bap[ch], 
1247 
block>qmant[ch], s>nb_coefs[ch]); 
1248 
} 
1249 
} 
1250 
} 
1251  
1252  
1253 
/**

1254 
* Write the AC3 frame header to the output bitstream.

1255 
*/

1256 
static void output_frame_header(AC3EncodeContext *s) 
1257 
{ 
1258 
put_bits(&s>pb, 16, 0x0b77); /* frame header */ 
1259 
put_bits(&s>pb, 16, 0); /* crc1: will be filled later */ 
1260 
put_bits(&s>pb, 2, s>bit_alloc.sr_code);

1261 
put_bits(&s>pb, 6, s>frame_size_code + (s>frame_size  s>frame_size_min) / 2); 
1262 
put_bits(&s>pb, 5, s>bitstream_id);

1263 
put_bits(&s>pb, 3, s>bitstream_mode);

1264 
put_bits(&s>pb, 3, s>channel_mode);

1265 
if ((s>channel_mode & 0x01) && s>channel_mode != AC3_CHMODE_MONO) 
1266 
put_bits(&s>pb, 2, 1); /* XXX 4.5 dB */ 
1267 
if (s>channel_mode & 0x04) 
1268 
put_bits(&s>pb, 2, 1); /* XXX 6 dB */ 
1269 
if (s>channel_mode == AC3_CHMODE_STEREO)

1270 
put_bits(&s>pb, 2, 0); /* surround not indicated */ 
1271 
put_bits(&s>pb, 1, s>lfe_on); /* LFE */ 
1272 
put_bits(&s>pb, 5, 31); /* dialog norm: 31 db */ 
1273 
put_bits(&s>pb, 1, 0); /* no compression control word */ 
1274 
put_bits(&s>pb, 1, 0); /* no lang code */ 
1275 
put_bits(&s>pb, 1, 0); /* no audio production info */ 
1276 
put_bits(&s>pb, 1, 0); /* no copyright */ 
1277 
put_bits(&s>pb, 1, 1); /* original bitstream */ 
1278 
put_bits(&s>pb, 1, 0); /* no time code 1 */ 
1279 
put_bits(&s>pb, 1, 0); /* no time code 2 */ 
1280 
put_bits(&s>pb, 1, 0); /* no additional bit stream info */ 
1281 
} 
1282  
1283  
1284 
/**

1285 
* Write one audio block to the output bitstream.

1286 
*/

1287 
static void output_audio_block(AC3EncodeContext *s, int blk) 
1288 
{ 
1289 
int ch, i, baie, rbnd;

1290 
AC3Block *block = &s>blocks[blk]; 
1291  
1292 
/* block switching */

1293 
for (ch = 0; ch < s>fbw_channels; ch++) 
1294 
put_bits(&s>pb, 1, 0); 
1295  
1296 
/* dither flags */

1297 
for (ch = 0; ch < s>fbw_channels; ch++) 
1298 
put_bits(&s>pb, 1, 1); 
1299  
1300 
/* dynamic range codes */

1301 
put_bits(&s>pb, 1, 0); 
1302  
1303 
/* channel coupling */

1304 
if (!blk) {

1305 
put_bits(&s>pb, 1, 1); /* coupling strategy present */ 
1306 
put_bits(&s>pb, 1, 0); /* no coupling strategy */ 
1307 
} else {

1308 
put_bits(&s>pb, 1, 0); /* no new coupling strategy */ 
1309 
} 
1310  
1311 
/* stereo rematrixing */

1312 
if (s>channel_mode == AC3_CHMODE_STEREO) {

1313 
put_bits(&s>pb, 1, block>new_rematrixing_strategy);

1314 
if (block>new_rematrixing_strategy) {

1315 
/* rematrixing flags */

1316 
for (rbnd = 0; rbnd < s>num_rematrixing_bands; rbnd++) 
1317 
put_bits(&s>pb, 1, block>rematrixing_flags[rbnd]);

1318 
} 
1319 
} 
1320  
1321 
/* exponent strategy */

1322 
for (ch = 0; ch < s>fbw_channels; ch++) 
1323 
put_bits(&s>pb, 2, s>exp_strategy[ch][blk]);

1324 
if (s>lfe_on)

1325 
put_bits(&s>pb, 1, s>exp_strategy[s>lfe_channel][blk]);

1326  
1327 
/* bandwidth */

1328 
for (ch = 0; ch < s>fbw_channels; ch++) { 
1329 
if (s>exp_strategy[ch][blk] != EXP_REUSE)

1330 
put_bits(&s>pb, 6, s>bandwidth_code[ch]);

1331 
} 
1332  
1333 
/* exponents */

1334 
for (ch = 0; ch < s>channels; ch++) { 
1335 
int nb_groups;

1336  
1337 
if (s>exp_strategy[ch][blk] == EXP_REUSE)

1338 
continue;

1339  
1340 
/* DC exponent */

1341 
put_bits(&s>pb, 4, block>grouped_exp[ch][0]); 
1342  
1343 
/* exponent groups */

1344 
nb_groups = exponent_group_tab[s>exp_strategy[ch][blk]1][s>nb_coefs[ch]];

1345 
for (i = 1; i <= nb_groups; i++) 
1346 
put_bits(&s>pb, 7, block>grouped_exp[ch][i]);

1347  
1348 
/* gain range info */

1349 
if (ch != s>lfe_channel)

1350 
put_bits(&s>pb, 2, 0); 
1351 
} 
1352  
1353 
/* bit allocation info */

1354 
baie = (blk == 0);

1355 
put_bits(&s>pb, 1, baie);

1356 
if (baie) {

1357 
put_bits(&s>pb, 2, s>slow_decay_code);

1358 
put_bits(&s>pb, 2, s>fast_decay_code);

1359 
put_bits(&s>pb, 2, s>slow_gain_code);

1360 
put_bits(&s>pb, 2, s>db_per_bit_code);

1361 
put_bits(&s>pb, 3, s>floor_code);

1362 
} 
1363  
1364 
/* snr offset */

1365 
put_bits(&s>pb, 1, baie);

1366 
if (baie) {

1367 
put_bits(&s>pb, 6, s>coarse_snr_offset);

1368 
for (ch = 0; ch < s>channels; ch++) { 
1369 
put_bits(&s>pb, 4, s>fine_snr_offset[ch]);

1370 
put_bits(&s>pb, 3, s>fast_gain_code[ch]);

1371 
} 
1372 
} 
1373  
1374 
put_bits(&s>pb, 1, 0); /* no delta bit allocation */ 
1375 
put_bits(&s>pb, 1, 0); /* no data to skip */ 
1376  
1377 
/* mantissas */

1378 
for (ch = 0; ch < s>channels; ch++) { 
1379 
int b, q;

1380 
for (i = 0; i < s>nb_coefs[ch]; i++) { 
1381 
q = block>qmant[ch][i]; 
1382 
b = block>bap[ch][i]; 
1383 
switch (b) {

1384 
case 0: break; 
1385 
case 1: if (q != 128) put_bits(&s>pb, 5, q); break; 
1386 
case 2: if (q != 128) put_bits(&s>pb, 7, q); break; 
1387 
case 3: put_bits(&s>pb, 3, q); break; 
1388 
case 4: if (q != 128) put_bits(&s>pb, 7, q); break; 
1389 
case 14: put_bits(&s>pb, 14, q); break; 
1390 
case 15: put_bits(&s>pb, 16, q); break; 
1391 
default: put_bits(&s>pb, b1, q); break; 
1392 
} 
1393 
} 
1394 
} 
1395 
} 
1396  
1397  
1398 
/** CRC16 Polynomial */

1399 
#define CRC16_POLY ((1 << 0)  (1 << 2)  (1 << 15)  (1 << 16)) 
1400  
1401  
1402 
static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly) 
1403 
{ 
1404 
unsigned int c; 
1405  
1406 
c = 0;

1407 
while (a) {

1408 
if (a & 1) 
1409 
c ^= b; 
1410 
a = a >> 1;

1411 
b = b << 1;

1412 
if (b & (1 << 16)) 
1413 
b ^= poly; 
1414 
} 
1415 
return c;

1416 
} 
1417  
1418  
1419 
static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly) 
1420 
{ 
1421 
unsigned int r; 
1422 
r = 1;

1423 
while (n) {

1424 
if (n & 1) 
1425 
r = mul_poly(r, a, poly); 
1426 
a = mul_poly(a, a, poly); 
1427 
n >>= 1;

1428 
} 
1429 
return r;

1430 
} 
1431  
1432  
1433 
/**

1434 
* Fill the end of the frame with 0's and compute the two CRCs.

1435 
*/

1436 
static void output_frame_end(AC3EncodeContext *s) 
1437 
{ 
1438 
const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI);

1439 
int frame_size_58, pad_bytes, crc1, crc2_partial, crc2, crc_inv;

1440 
uint8_t *frame; 
1441  
1442 
frame_size_58 = ((s>frame_size >> 2) + (s>frame_size >> 4)) << 1; 
1443  
1444 
/* pad the remainder of the frame with zeros */

1445 
av_assert2(s>frame_size * 8  put_bits_count(&s>pb) >= 18); 
1446 
flush_put_bits(&s>pb); 
1447 
frame = s>pb.buf; 
1448 
pad_bytes = s>frame_size  (put_bits_ptr(&s>pb)  frame)  2;

1449 
av_assert2(pad_bytes >= 0);

1450 
if (pad_bytes > 0) 
1451 
memset(put_bits_ptr(&s>pb), 0, pad_bytes);

1452  
1453 
/* compute crc1 */

1454 
/* this is not so easy because it is at the beginning of the data... */

1455 
crc1 = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58  4)); 
1456 
crc_inv = s>crc_inv[s>frame_size > s>frame_size_min]; 
1457 
crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); 
1458 
AV_WB16(frame + 2, crc1);

1459  
1460 
/* compute crc2 */

1461 
crc2_partial = av_crc(crc_ctx, 0, frame + frame_size_58,

1462 
s>frame_size  frame_size_58  3);

1463 
crc2 = av_crc(crc_ctx, crc2_partial, frame + s>frame_size  3, 1); 
1464 
/* ensure crc2 does not match sync word by flipping crcrsv bit if needed */

1465 
if (crc2 == 0x770B) { 
1466 
frame[s>frame_size  3] ^= 0x1; 
1467 
crc2 = av_crc(crc_ctx, crc2_partial, frame + s>frame_size  3, 1); 
1468 
} 
1469 
crc2 = av_bswap16(crc2); 
1470 
AV_WB16(frame + s>frame_size  2, crc2);

1471 
} 
1472  
1473  
1474 
/**

1475 
* Write the frame to the output bitstream.

1476 
*/

1477 
static void output_frame(AC3EncodeContext *s, unsigned char *frame) 
1478 
{ 
1479 
int blk;

1480  
1481 
init_put_bits(&s>pb, frame, AC3_MAX_CODED_FRAME_SIZE); 
1482  
1483 
output_frame_header(s); 
1484  
1485 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) 
1486 
output_audio_block(s, blk); 
1487  
1488 
output_frame_end(s); 
1489 
} 
1490  
1491  
1492 
/**

1493 
* Encode a single AC3 frame.

1494 
*/

1495 
static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, 
1496 
int buf_size, void *data) 
1497 
{ 
1498 
AC3EncodeContext *s = avctx>priv_data; 
1499 
const SampleType *samples = data;

1500 
int ret;

1501  
1502 
if (s>bit_alloc.sr_code == 1) 
1503 
adjust_frame_size(s); 
1504  
1505 
deinterleave_input_samples(s, samples); 
1506  
1507 
apply_mdct(s); 
1508  
1509 
compute_rematrixing_strategy(s); 
1510  
1511 
scale_coefficients(s); 
1512  
1513 
apply_rematrixing(s); 
1514  
1515 
process_exponents(s); 
1516  
1517 
ret = compute_bit_allocation(s); 
1518 
if (ret) {

1519 
av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");

1520 
return ret;

1521 
} 
1522  
1523 
quantize_mantissas(s); 
1524  
1525 
output_frame(s, frame); 
1526  
1527 
return s>frame_size;

1528 
} 
1529  
1530  
1531 
/**

1532 
* Finalize encoding and free any memory allocated by the encoder.

1533 
*/

1534 
static av_cold int ac3_encode_close(AVCodecContext *avctx) 
1535 
{ 
1536 
int blk, ch;

1537 
AC3EncodeContext *s = avctx>priv_data; 
1538  
1539 
for (ch = 0; ch < s>channels; ch++) 
1540 
av_freep(&s>planar_samples[ch]); 
1541 
av_freep(&s>planar_samples); 
1542 
av_freep(&s>bap_buffer); 
1543 
av_freep(&s>bap1_buffer); 
1544 
av_freep(&s>mdct_coef_buffer); 
1545 
av_freep(&s>fixed_coef_buffer); 
1546 
av_freep(&s>exp_buffer); 
1547 
av_freep(&s>grouped_exp_buffer); 
1548 
av_freep(&s>psd_buffer); 
1549 
av_freep(&s>band_psd_buffer); 
1550 
av_freep(&s>mask_buffer); 
1551 
av_freep(&s>qmant_buffer); 
1552 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
1553 
AC3Block *block = &s>blocks[blk]; 
1554 
av_freep(&block>bap); 
1555 
av_freep(&block>mdct_coef); 
1556 
av_freep(&block>fixed_coef); 
1557 
av_freep(&block>exp); 
1558 
av_freep(&block>grouped_exp); 
1559 
av_freep(&block>psd); 
1560 
av_freep(&block>band_psd); 
1561 
av_freep(&block>mask); 
1562 
av_freep(&block>qmant); 
1563 
} 
1564  
1565 
mdct_end(&s>mdct); 
1566  
1567 
av_freep(&avctx>coded_frame); 
1568 
return 0; 
1569 
} 
1570  
1571  
1572 
/**

1573 
* Set channel information during initialization.

1574 
*/

1575 
static av_cold int set_channel_info(AC3EncodeContext *s, int channels, 
1576 
int64_t *channel_layout) 
1577 
{ 
1578 
int ch_layout;

1579  
1580 
if (channels < 1  channels > AC3_MAX_CHANNELS) 
1581 
return AVERROR(EINVAL);

1582 
if ((uint64_t)*channel_layout > 0x7FF) 
1583 
return AVERROR(EINVAL);

1584 
ch_layout = *channel_layout; 
1585 
if (!ch_layout)

1586 
ch_layout = avcodec_guess_channel_layout(channels, CODEC_ID_AC3, NULL);

1587 
if (av_get_channel_layout_nb_channels(ch_layout) != channels)

1588 
return AVERROR(EINVAL);

1589  
1590 
s>lfe_on = !!(ch_layout & AV_CH_LOW_FREQUENCY); 
1591 
s>channels = channels; 
1592 
s>fbw_channels = channels  s>lfe_on; 
1593 
s>lfe_channel = s>lfe_on ? s>fbw_channels : 1;

1594 
if (s>lfe_on)

1595 
ch_layout = AV_CH_LOW_FREQUENCY; 
1596  
1597 
switch (ch_layout) {

1598 
case AV_CH_LAYOUT_MONO: s>channel_mode = AC3_CHMODE_MONO; break; 
1599 
case AV_CH_LAYOUT_STEREO: s>channel_mode = AC3_CHMODE_STEREO; break; 
1600 
case AV_CH_LAYOUT_SURROUND: s>channel_mode = AC3_CHMODE_3F; break; 
1601 
case AV_CH_LAYOUT_2_1: s>channel_mode = AC3_CHMODE_2F1R; break; 
1602 
case AV_CH_LAYOUT_4POINT0: s>channel_mode = AC3_CHMODE_3F1R; break; 
1603 
case AV_CH_LAYOUT_QUAD:

1604 
case AV_CH_LAYOUT_2_2: s>channel_mode = AC3_CHMODE_2F2R; break; 
1605 
case AV_CH_LAYOUT_5POINT0:

1606 
case AV_CH_LAYOUT_5POINT0_BACK: s>channel_mode = AC3_CHMODE_3F2R; break; 
1607 
default:

1608 
return AVERROR(EINVAL);

1609 
} 
1610  
1611 
s>channel_map = ff_ac3_enc_channel_map[s>channel_mode][s>lfe_on]; 
1612 
*channel_layout = ch_layout; 
1613 
if (s>lfe_on)

1614 
*channel_layout = AV_CH_LOW_FREQUENCY; 
1615  
1616 
return 0; 
1617 
} 
1618  
1619  
1620 
static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s) 
1621 
{ 
1622 
int i, ret;

1623  
1624 
/* validate channel layout */

1625 
if (!avctx>channel_layout) {

1626 
av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "

1627 
"encoder will guess the layout, but it "

1628 
"might be incorrect.\n");

1629 
} 
1630 
ret = set_channel_info(s, avctx>channels, &avctx>channel_layout); 
1631 
if (ret) {

1632 
av_log(avctx, AV_LOG_ERROR, "invalid channel layout\n");

1633 
return ret;

1634 
} 
1635  
1636 
/* validate sample rate */

1637 
for (i = 0; i < 9; i++) { 
1638 
if ((ff_ac3_sample_rate_tab[i / 3] >> (i % 3)) == avctx>sample_rate) 
1639 
break;

1640 
} 
1641 
if (i == 9) { 
1642 
av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");

1643 
return AVERROR(EINVAL);

1644 
} 
1645 
s>sample_rate = avctx>sample_rate; 
1646 
s>bit_alloc.sr_shift = i % 3;

1647 
s>bit_alloc.sr_code = i / 3;

1648  
1649 
/* validate bit rate */

1650 
for (i = 0; i < 19; i++) { 
1651 
if ((ff_ac3_bitrate_tab[i] >> s>bit_alloc.sr_shift)*1000 == avctx>bit_rate) 
1652 
break;

1653 
} 
1654 
if (i == 19) { 
1655 
av_log(avctx, AV_LOG_ERROR, "invalid bit rate\n");

1656 
return AVERROR(EINVAL);

1657 
} 
1658 
s>bit_rate = avctx>bit_rate; 
1659 
s>frame_size_code = i << 1;

1660  
1661 
/* validate cutoff */

1662 
if (avctx>cutoff < 0) { 
1663 
av_log(avctx, AV_LOG_ERROR, "invalid cutoff frequency\n");

1664 
return AVERROR(EINVAL);

1665 
} 
1666 
s>cutoff = avctx>cutoff; 
1667 
if (s>cutoff > (s>sample_rate >> 1)) 
1668 
s>cutoff = s>sample_rate >> 1;

1669  
1670 
return 0; 
1671 
} 
1672  
1673  
1674 
/**

1675 
* Set bandwidth for all channels.

1676 
* The user can optionally supply a cutoff frequency. Otherwise an appropriate

1677 
* default value will be used.

1678 
*/

1679 
static av_cold void set_bandwidth(AC3EncodeContext *s) 
1680 
{ 
1681 
int ch, bw_code;

1682  
1683 
if (s>cutoff) {

1684 
/* calculate bandwidth based on userspecified cutoff frequency */

1685 
int fbw_coeffs;

1686 
fbw_coeffs = s>cutoff * 2 * AC3_MAX_COEFS / s>sample_rate;

1687 
bw_code = av_clip((fbw_coeffs  73) / 3, 0, 60); 
1688 
} else {

1689 
/* use default bandwidth setting */

1690 
/* XXX: should compute the bandwidth according to the frame

1691 
size, so that we avoid annoying high frequency artifacts */

1692 
bw_code = 50;

1693 
} 
1694  
1695 
/* set number of coefficients for each channel */

1696 
for (ch = 0; ch < s>fbw_channels; ch++) { 
1697 
s>bandwidth_code[ch] = bw_code; 
1698 
s>nb_coefs[ch] = bw_code * 3 + 73; 
1699 
} 
1700 
if (s>lfe_on)

1701 
s>nb_coefs[s>lfe_channel] = 7; /* LFE channel always has 7 coefs */ 
1702 
} 
1703  
1704  
1705 
static av_cold int allocate_buffers(AVCodecContext *avctx) 
1706 
{ 
1707 
int blk, ch;

1708 
AC3EncodeContext *s = avctx>priv_data; 
1709  
1710 
FF_ALLOC_OR_GOTO(avctx, s>planar_samples, s>channels * sizeof(*s>planar_samples),

1711 
alloc_fail); 
1712 
for (ch = 0; ch < s>channels; ch++) { 
1713 
FF_ALLOCZ_OR_GOTO(avctx, s>planar_samples[ch], 
1714 
(AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s>planar_samples),

1715 
alloc_fail); 
1716 
} 
1717 
FF_ALLOC_OR_GOTO(avctx, s>bap_buffer, AC3_MAX_BLOCKS * s>channels * 
1718 
AC3_MAX_COEFS * sizeof(*s>bap_buffer), alloc_fail);

1719 
FF_ALLOC_OR_GOTO(avctx, s>bap1_buffer, AC3_MAX_BLOCKS * s>channels * 
1720 
AC3_MAX_COEFS * sizeof(*s>bap1_buffer), alloc_fail);

1721 
FF_ALLOC_OR_GOTO(avctx, s>mdct_coef_buffer, AC3_MAX_BLOCKS * s>channels * 
1722 
AC3_MAX_COEFS * sizeof(*s>mdct_coef_buffer), alloc_fail);

1723 
FF_ALLOC_OR_GOTO(avctx, s>exp_buffer, AC3_MAX_BLOCKS * s>channels * 
1724 
AC3_MAX_COEFS * sizeof(*s>exp_buffer), alloc_fail);

1725 
FF_ALLOC_OR_GOTO(avctx, s>grouped_exp_buffer, AC3_MAX_BLOCKS * s>channels * 
1726 
128 * sizeof(*s>grouped_exp_buffer), alloc_fail); 
1727 
FF_ALLOC_OR_GOTO(avctx, s>psd_buffer, AC3_MAX_BLOCKS * s>channels * 
1728 
AC3_MAX_COEFS * sizeof(*s>psd_buffer), alloc_fail);

1729 
FF_ALLOC_OR_GOTO(avctx, s>band_psd_buffer, AC3_MAX_BLOCKS * s>channels * 
1730 
64 * sizeof(*s>band_psd_buffer), alloc_fail); 
1731 
FF_ALLOC_OR_GOTO(avctx, s>mask_buffer, AC3_MAX_BLOCKS * s>channels * 
1732 
64 * sizeof(*s>mask_buffer), alloc_fail); 
1733 
FF_ALLOC_OR_GOTO(avctx, s>qmant_buffer, AC3_MAX_BLOCKS * s>channels * 
1734 
AC3_MAX_COEFS * sizeof(*s>qmant_buffer), alloc_fail);

1735 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
1736 
AC3Block *block = &s>blocks[blk]; 
1737 
FF_ALLOC_OR_GOTO(avctx, block>bap, s>channels * sizeof(*block>bap),

1738 
alloc_fail); 
1739 
FF_ALLOCZ_OR_GOTO(avctx, block>mdct_coef, s>channels * sizeof(*block>mdct_coef),

1740 
alloc_fail); 
1741 
FF_ALLOCZ_OR_GOTO(avctx, block>exp, s>channels * sizeof(*block>exp),

1742 
alloc_fail); 
1743 
FF_ALLOCZ_OR_GOTO(avctx, block>grouped_exp, s>channels * sizeof(*block>grouped_exp),

1744 
alloc_fail); 
1745 
FF_ALLOCZ_OR_GOTO(avctx, block>psd, s>channels * sizeof(*block>psd),

1746 
alloc_fail); 
1747 
FF_ALLOCZ_OR_GOTO(avctx, block>band_psd, s>channels * sizeof(*block>band_psd),

1748 
alloc_fail); 
1749 
FF_ALLOCZ_OR_GOTO(avctx, block>mask, s>channels * sizeof(*block>mask),

1750 
alloc_fail); 
1751 
FF_ALLOCZ_OR_GOTO(avctx, block>qmant, s>channels * sizeof(*block>qmant),

1752 
alloc_fail); 
1753  
1754 
for (ch = 0; ch < s>channels; ch++) { 
1755 
/* arrangement: block, channel, coeff */

1756 
block>bap[ch] = &s>bap_buffer [AC3_MAX_COEFS * (blk * s>channels + ch)]; 
1757 
block>mdct_coef[ch] = &s>mdct_coef_buffer [AC3_MAX_COEFS * (blk * s>channels + ch)]; 
1758 
block>grouped_exp[ch] = &s>grouped_exp_buffer[128 * (blk * s>channels + ch)];

1759 
block>psd[ch] = &s>psd_buffer [AC3_MAX_COEFS * (blk * s>channels + ch)]; 
1760 
block>band_psd[ch] = &s>band_psd_buffer [64 * (blk * s>channels + ch)];

1761 
block>mask[ch] = &s>mask_buffer [64 * (blk * s>channels + ch)];

1762 
block>qmant[ch] = &s>qmant_buffer [AC3_MAX_COEFS * (blk * s>channels + ch)]; 
1763  
1764 
/* arrangement: channel, block, coeff */

1765 
block>exp[ch] = &s>exp_buffer [AC3_MAX_COEFS * (AC3_MAX_BLOCKS * ch + blk)]; 
1766 
} 
1767 
} 
1768  
1769 
if (CONFIG_AC3ENC_FLOAT) {

1770 
FF_ALLOC_OR_GOTO(avctx, s>fixed_coef_buffer, AC3_MAX_BLOCKS * s>channels * 
1771 
AC3_MAX_COEFS * sizeof(*s>fixed_coef_buffer), alloc_fail);

1772 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
1773 
AC3Block *block = &s>blocks[blk]; 
1774 
FF_ALLOCZ_OR_GOTO(avctx, block>fixed_coef, s>channels * 
1775 
sizeof(*block>fixed_coef), alloc_fail);

1776 
for (ch = 0; ch < s>channels; ch++) 
1777 
block>fixed_coef[ch] = &s>fixed_coef_buffer[AC3_MAX_COEFS * (blk * s>channels + ch)]; 
1778 
} 
1779 
} else {

1780 
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 
1781 
AC3Block *block = &s>blocks[blk]; 
1782 
FF_ALLOCZ_OR_GOTO(avctx, block>fixed_coef, s>channels * 
1783 
sizeof(*block>fixed_coef), alloc_fail);

1784 
for (ch = 0; ch < s>channels; ch++) 
1785 
block>fixed_coef[ch] = (int32_t *)block>mdct_coef[ch]; 
1786 
} 
1787 
} 
1788  
1789 
return 0; 
1790 
alloc_fail:

1791 
return AVERROR(ENOMEM);

1792 
} 
1793  
1794  
1795 
/**

1796 
* Initialize the encoder.

1797 
*/

1798 
static av_cold int ac3_encode_init(AVCodecContext *avctx) 
1799 
{ 
1800 
AC3EncodeContext *s = avctx>priv_data; 
1801 
int ret, frame_size_58;

1802  
1803 
avctx>frame_size = AC3_FRAME_SIZE; 
1804  
1805 
ff_ac3_common_init(); 
1806  
1807 
ret = validate_options(avctx, s); 
1808 
if (ret)

1809 
return ret;

1810  
1811 
s>bitstream_id = 8 + s>bit_alloc.sr_shift;

1812 
s>bitstream_mode = 0; /* complete main audio service */ 
1813  
1814 
s>frame_size_min = 2 * ff_ac3_frame_size_tab[s>frame_size_code][s>bit_alloc.sr_code];

1815 
s>bits_written = 0;

1816 
s>samples_written = 0;

1817 
s>frame_size = s>frame_size_min; 
1818  
1819 
/* calculate crc_inv for both possible frame sizes */

1820 
frame_size_58 = (( s>frame_size >> 2) + ( s>frame_size >> 4)) << 1; 
1821 
s>crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58)  16, CRC16_POLY); 
1822 
if (s>bit_alloc.sr_code == 1) { 
1823 
frame_size_58 = (((s>frame_size+2) >> 2) + ((s>frame_size+2) >> 4)) << 1; 
1824 
s>crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58)  16, CRC16_POLY); 
1825 
} 
1826  
1827 
set_bandwidth(s); 
1828  
1829 
rematrixing_init(s); 
1830  
1831 
exponent_init(s); 
1832  
1833 
bit_alloc_init(s); 
1834  
1835 
ret = mdct_init(avctx, &s>mdct, 9);

1836 
if (ret)

1837 
goto init_fail;

1838  
1839 
ret = allocate_buffers(avctx); 
1840 
if (ret)

1841 
goto init_fail;

1842  
1843 
avctx>coded_frame= avcodec_alloc_frame(); 
1844  
1845 
dsputil_init(&s>dsp, avctx); 
1846 
ff_ac3dsp_init(&s>ac3dsp); 
1847  
1848 
return 0; 
1849 
init_fail:

1850 
ac3_encode_close(avctx); 
1851 
return ret;

1852 
} 