2 * The simplest AC-3 encoder
3 * Copyright (c) 2000 Fabrice Bellard
4 * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
5 * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
7 * This file is part of Libav.
9 * Libav is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * Libav is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * The simplest AC-3 encoder.
29 //#define ASSERT_LEVEL 2
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/crc.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/opt.h"
47 typedef struct AC3Mant
{
48 int16_t *qmant1_ptr
, *qmant2_ptr
, *qmant4_ptr
; ///< mantissa pointers for bap=1,2,4
49 int mant1_cnt
, mant2_cnt
, mant4_cnt
; ///< mantissa counts for bap=1,2,4
52 #define CMIXLEV_NUM_OPTIONS 3
53 static const float cmixlev_options
[CMIXLEV_NUM_OPTIONS
] = {
54 LEVEL_MINUS_3DB
, LEVEL_MINUS_4POINT5DB
, LEVEL_MINUS_6DB
57 #define SURMIXLEV_NUM_OPTIONS 3
58 static const float surmixlev_options
[SURMIXLEV_NUM_OPTIONS
] = {
59 LEVEL_MINUS_3DB
, LEVEL_MINUS_6DB
, LEVEL_ZERO
62 #define EXTMIXLEV_NUM_OPTIONS 8
63 static const float extmixlev_options
[EXTMIXLEV_NUM_OPTIONS
] = {
64 LEVEL_PLUS_3DB
, LEVEL_PLUS_1POINT5DB
, LEVEL_ONE
, LEVEL_MINUS_4POINT5DB
,
65 LEVEL_MINUS_3DB
, LEVEL_MINUS_4POINT5DB
, LEVEL_MINUS_6DB
, LEVEL_ZERO
70 * LUT for number of exponent groups.
71 * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
73 static uint8_t exponent_group_tab
[2][3][256];
77 * List of supported channel layouts.
79 const uint64_t ff_ac3_channel_layouts
[19] = {
83 AV_CH_LAYOUT_SURROUND
,
88 AV_CH_LAYOUT_5POINT0_BACK
,
89 (AV_CH_LAYOUT_MONO
| AV_CH_LOW_FREQUENCY
),
90 (AV_CH_LAYOUT_STEREO
| AV_CH_LOW_FREQUENCY
),
91 (AV_CH_LAYOUT_2_1
| AV_CH_LOW_FREQUENCY
),
92 (AV_CH_LAYOUT_SURROUND
| AV_CH_LOW_FREQUENCY
),
93 (AV_CH_LAYOUT_2_2
| AV_CH_LOW_FREQUENCY
),
94 (AV_CH_LAYOUT_QUAD
| AV_CH_LOW_FREQUENCY
),
95 (AV_CH_LAYOUT_4POINT0
| AV_CH_LOW_FREQUENCY
),
97 AV_CH_LAYOUT_5POINT1_BACK
,
103 * LUT to select the bandwidth code based on the bit rate, sample rate, and
104 * number of full-bandwidth channels.
105 * bandwidth_tab[fbw_channels-1][sample rate code][bit rate code]
107 static const uint8_t ac3_bandwidth_tab
[5][3][19] = {
108 // 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
110 { { 0, 0, 0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
111 { 0, 0, 0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
112 { 0, 0, 0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
114 { { 0, 0, 0, 0, 0, 0, 0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
115 { 0, 0, 0, 0, 0, 0, 4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
116 { 0, 0, 0, 0, 0, 0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
118 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 },
119 { 0, 0, 0, 0, 0, 0, 0, 0, 4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 },
120 { 0, 0, 0, 0, 0, 0, 0, 0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } },
122 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 32, 48, 48, 48, 48, 48, 48 },
123 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 28, 36, 56, 56, 56, 56, 56, 56 },
124 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } },
126 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 20, 32, 40, 48, 48, 48, 48 },
127 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 36, 44, 56, 56, 56, 56 },
128 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 44, 60, 60, 60, 60, 60, 60 } }
133 * LUT to select the coupling start band based on the bit rate, sample rate, and
134 * number of full-bandwidth channels. -1 = coupling off
135 * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]
137 * TODO: more testing for optimal parameters.
138 * multi-channel tests at 44.1kHz and 32kHz.
140 static const int8_t ac3_coupling_start_tab
[6][3][19] = {
141 // 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
144 { { 0, 0, 0, 0, 0, 0, 0, 1, 1, 7, 8, 11, 12, -1, -1, -1, -1, -1, -1 },
145 { 0, 0, 0, 0, 0, 0, 1, 3, 5, 7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },
146 { 0, 0, 0, 0, 1, 2, 2, 9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
149 { { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
150 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
151 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
154 { { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
155 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
156 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
159 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
160 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
161 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
164 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
165 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
166 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
169 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
170 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
171 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
176 * Adjust the frame size to make the average bit rate match the target bit rate.
177 * This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3.
179 * @param s AC-3 encoder private context
181 void ff_ac3_adjust_frame_size(AC3EncodeContext
*s
)
183 while (s
->bits_written
>= s
->bit_rate
&& s
->samples_written
>= s
->sample_rate
) {
184 s
->bits_written
-= s
->bit_rate
;
185 s
->samples_written
-= s
->sample_rate
;
187 s
->frame_size
= s
->frame_size_min
+
188 2 * (s
->bits_written
* s
->sample_rate
< s
->samples_written
* s
->bit_rate
);
189 s
->bits_written
+= s
->frame_size
* 8;
190 s
->samples_written
+= AC3_BLOCK_SIZE
* s
->num_blocks
;
195 * Set the initial coupling strategy parameters prior to coupling analysis.
197 * @param s AC-3 encoder private context
199 void ff_ac3_compute_coupling_strategy(AC3EncodeContext
*s
)
205 /* set coupling use flags for each block/channel */
206 /* TODO: turn coupling on/off and adjust start band based on bit usage */
207 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
208 AC3Block
*block
= &s
->blocks
[blk
];
209 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
210 block
->channel_in_cpl
[ch
] = s
->cpl_on
;
213 /* enable coupling for each block if at least 2 channels have coupling
214 enabled for that block */
217 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
218 AC3Block
*block
= &s
->blocks
[blk
];
219 block
->num_cpl_channels
= 0;
220 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
221 block
->num_cpl_channels
+= block
->channel_in_cpl
[ch
];
222 block
->cpl_in_use
= block
->num_cpl_channels
> 1;
223 num_cpl_blocks
+= block
->cpl_in_use
;
224 if (!block
->cpl_in_use
) {
225 block
->num_cpl_channels
= 0;
226 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
227 block
->channel_in_cpl
[ch
] = 0;
230 block
->new_cpl_strategy
= !blk
;
232 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
233 if (block
->channel_in_cpl
[ch
] != s
->blocks
[blk
-1].channel_in_cpl
[ch
]) {
234 block
->new_cpl_strategy
= 1;
239 block
->new_cpl_leak
= block
->new_cpl_strategy
;
241 if (!blk
|| (block
->cpl_in_use
&& !got_cpl_snr
)) {
242 block
->new_snr_offsets
= 1;
243 if (block
->cpl_in_use
)
246 block
->new_snr_offsets
= 0;
252 /* set bandwidth for each channel */
253 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
254 AC3Block
*block
= &s
->blocks
[blk
];
255 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
256 if (block
->channel_in_cpl
[ch
])
257 block
->end_freq
[ch
] = s
->start_freq
[CPL_CH
];
259 block
->end_freq
[ch
] = s
->bandwidth_code
* 3 + 73;
266 * Apply stereo rematrixing to coefficients based on rematrixing flags.
268 * @param s AC-3 encoder private context
270 void ff_ac3_apply_rematrixing(AC3EncodeContext
*s
)
277 if (!s
->rematrixing_enabled
)
280 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
281 AC3Block
*block
= &s
->blocks
[blk
];
282 if (block
->new_rematrixing_strategy
)
283 flags
= block
->rematrixing_flags
;
284 nb_coefs
= FFMIN(block
->end_freq
[1], block
->end_freq
[2]);
285 for (bnd
= 0; bnd
< block
->num_rematrixing_bands
; bnd
++) {
287 start
= ff_ac3_rematrix_band_tab
[bnd
];
288 end
= FFMIN(nb_coefs
, ff_ac3_rematrix_band_tab
[bnd
+1]);
289 for (i
= start
; i
< end
; i
++) {
290 int32_t lt
= block
->fixed_coef
[1][i
];
291 int32_t rt
= block
->fixed_coef
[2][i
];
292 block
->fixed_coef
[1][i
] = (lt
+ rt
) >> 1;
293 block
->fixed_coef
[2][i
] = (lt
- rt
) >> 1;
302 * Initialize exponent tables.
304 static av_cold
void exponent_init(AC3EncodeContext
*s
)
306 int expstr
, i
, grpsize
;
308 for (expstr
= EXP_D15
-1; expstr
<= EXP_D45
-1; expstr
++) {
309 grpsize
= 3 << expstr
;
310 for (i
= 12; i
< 256; i
++) {
311 exponent_group_tab
[0][expstr
][i
] = (i
+ grpsize
- 4) / grpsize
;
312 exponent_group_tab
[1][expstr
][i
] = (i
) / grpsize
;
316 exponent_group_tab
[0][0][7] = 2;
318 if (CONFIG_EAC3_ENCODER
&& s
->eac3
)
319 ff_eac3_exponent_init();
324 * Extract exponents from the MDCT coefficients.
326 static void extract_exponents(AC3EncodeContext
*s
)
329 int chan_size
= AC3_MAX_COEFS
* s
->num_blocks
* (s
->channels
- ch
+ 1);
330 AC3Block
*block
= &s
->blocks
[0];
332 s
->ac3dsp
.extract_exponents(block
->exp
[ch
], block
->fixed_coef
[ch
], chan_size
);
337 * Exponent Difference Threshold.
338 * New exponents are sent if their SAD exceed this number.
340 #define EXP_DIFF_THRESHOLD 500
343 * Table used to select exponent strategy based on exponent reuse block interval.
345 static const uint8_t exp_strategy_reuse_tab
[4][6] = {
346 { EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
},
347 { EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
},
348 { EXP_D25
, EXP_D25
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
},
349 { EXP_D45
, EXP_D25
, EXP_D25
, EXP_D15
, EXP_D15
, EXP_D15
}
353 * Calculate exponent strategies for all channels.
354 * Array arrangement is reversed to simplify the per-channel calculation.
356 static void compute_exp_strategy(AC3EncodeContext
*s
)
360 for (ch
= !s
->cpl_on
; ch
<= s
->fbw_channels
; ch
++) {
361 uint8_t *exp_strategy
= s
->exp_strategy
[ch
];
362 uint8_t *exp
= s
->blocks
[0].exp
[ch
];
365 /* estimate if the exponent variation & decide if they should be
366 reused in the next frame */
367 exp_strategy
[0] = EXP_NEW
;
368 exp
+= AC3_MAX_COEFS
;
369 for (blk
= 1; blk
< s
->num_blocks
; blk
++, exp
+= AC3_MAX_COEFS
) {
371 if (!s
->blocks
[blk
-1].cpl_in_use
) {
372 exp_strategy
[blk
] = EXP_NEW
;
374 } else if (!s
->blocks
[blk
].cpl_in_use
) {
375 exp_strategy
[blk
] = EXP_REUSE
;
378 } else if (s
->blocks
[blk
].channel_in_cpl
[ch
] != s
->blocks
[blk
-1].channel_in_cpl
[ch
]) {
379 exp_strategy
[blk
] = EXP_NEW
;
382 exp_diff
= s
->dsp
.sad
[0](NULL
, exp
, exp
- AC3_MAX_COEFS
, 16, 16);
383 exp_strategy
[blk
] = EXP_REUSE
;
384 if (ch
== CPL_CH
&& exp_diff
> (EXP_DIFF_THRESHOLD
* (s
->blocks
[blk
].end_freq
[ch
] - s
->start_freq
[ch
]) / AC3_MAX_COEFS
))
385 exp_strategy
[blk
] = EXP_NEW
;
386 else if (ch
> CPL_CH
&& exp_diff
> EXP_DIFF_THRESHOLD
)
387 exp_strategy
[blk
] = EXP_NEW
;
390 /* now select the encoding strategy type : if exponents are often
391 recoded, we use a coarse encoding */
393 while (blk
< s
->num_blocks
) {
395 while (blk1
< s
->num_blocks
&& exp_strategy
[blk1
] == EXP_REUSE
)
397 exp_strategy
[blk
] = exp_strategy_reuse_tab
[s
->num_blks_code
][blk1
-blk
-1];
403 s
->exp_strategy
[ch
][0] = EXP_D15
;
404 for (blk
= 1; blk
< s
->num_blocks
; blk
++)
405 s
->exp_strategy
[ch
][blk
] = EXP_REUSE
;
408 /* for E-AC-3, determine frame exponent strategy */
409 if (CONFIG_EAC3_ENCODER
&& s
->eac3
)
410 ff_eac3_get_frame_exp_strategy(s
);
415 * Update the exponents so that they are the ones the decoder will decode.
417 * @param[in,out] exp array of exponents for 1 block in 1 channel
418 * @param nb_exps number of exponents in active bandwidth
419 * @param exp_strategy exponent strategy for the block
420 * @param cpl indicates if the block is in the coupling channel
422 static void encode_exponents_blk_ch(uint8_t *exp
, int nb_exps
, int exp_strategy
,
427 nb_groups
= exponent_group_tab
[cpl
][exp_strategy
-1][nb_exps
] * 3;
429 /* for each group, compute the minimum exponent */
430 switch(exp_strategy
) {
432 for (i
= 1, k
= 1-cpl
; i
<= nb_groups
; i
++) {
433 uint8_t exp_min
= exp
[k
];
434 if (exp
[k
+1] < exp_min
)
436 exp
[i
-cpl
] = exp_min
;
441 for (i
= 1, k
= 1-cpl
; i
<= nb_groups
; i
++) {
442 uint8_t exp_min
= exp
[k
];
443 if (exp
[k
+1] < exp_min
)
445 if (exp
[k
+2] < exp_min
)
447 if (exp
[k
+3] < exp_min
)
449 exp
[i
-cpl
] = exp_min
;
455 /* constraint for DC exponent */
456 if (!cpl
&& exp
[0] > 15)
459 /* decrease the delta between each groups to within 2 so that they can be
460 differentially encoded */
461 for (i
= 1; i
<= nb_groups
; i
++)
462 exp
[i
] = FFMIN(exp
[i
], exp
[i
-1] + 2);
465 exp
[i
] = FFMIN(exp
[i
], exp
[i
+1] + 2);
468 exp
[-1] = exp
[0] & ~1;
470 /* now we have the exponent values the decoder will see */
471 switch (exp_strategy
) {
473 for (i
= nb_groups
, k
= (nb_groups
* 2)-cpl
; i
> 0; i
--) {
474 uint8_t exp1
= exp
[i
-cpl
];
480 for (i
= nb_groups
, k
= (nb_groups
* 4)-cpl
; i
> 0; i
--) {
481 exp
[k
] = exp
[k
-1] = exp
[k
-2] = exp
[k
-3] = exp
[i
-cpl
];
490 * Encode exponents from original extracted form to what the decoder will see.
491 * This copies and groups exponents based on exponent strategy and reduces
492 * deltas between adjacent exponent groups so that they can be differentially
495 static void encode_exponents(AC3EncodeContext
*s
)
497 int blk
, blk1
, ch
, cpl
;
498 uint8_t *exp
, *exp_strategy
;
499 int nb_coefs
, num_reuse_blocks
;
501 for (ch
= !s
->cpl_on
; ch
<= s
->channels
; ch
++) {
502 exp
= s
->blocks
[0].exp
[ch
] + s
->start_freq
[ch
];
503 exp_strategy
= s
->exp_strategy
[ch
];
505 cpl
= (ch
== CPL_CH
);
507 while (blk
< s
->num_blocks
) {
508 AC3Block
*block
= &s
->blocks
[blk
];
509 if (cpl
&& !block
->cpl_in_use
) {
510 exp
+= AC3_MAX_COEFS
;
514 nb_coefs
= block
->end_freq
[ch
] - s
->start_freq
[ch
];
517 /* count the number of EXP_REUSE blocks after the current block
518 and set exponent reference block numbers */
519 s
->exp_ref_block
[ch
][blk
] = blk
;
520 while (blk1
< s
->num_blocks
&& exp_strategy
[blk1
] == EXP_REUSE
) {
521 s
->exp_ref_block
[ch
][blk1
] = blk
;
524 num_reuse_blocks
= blk1
- blk
- 1;
526 /* for the EXP_REUSE case we select the min of the exponents */
527 s
->ac3dsp
.ac3_exponent_min(exp
-s
->start_freq
[ch
], num_reuse_blocks
,
530 encode_exponents_blk_ch(exp
, nb_coefs
, exp_strategy
[blk
], cpl
);
532 exp
+= AC3_MAX_COEFS
* (num_reuse_blocks
+ 1);
537 /* reference block numbers have been changed, so reset ref_bap_set */
543 * Count exponent bits based on bandwidth, coupling, and exponent strategies.
545 static int count_exponent_bits(AC3EncodeContext
*s
)
548 int nb_groups
, bit_count
;
551 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
552 AC3Block
*block
= &s
->blocks
[blk
];
553 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
554 int exp_strategy
= s
->exp_strategy
[ch
][blk
];
555 int cpl
= (ch
== CPL_CH
);
556 int nb_coefs
= block
->end_freq
[ch
] - s
->start_freq
[ch
];
558 if (exp_strategy
== EXP_REUSE
)
561 nb_groups
= exponent_group_tab
[cpl
][exp_strategy
-1][nb_coefs
];
562 bit_count
+= 4 + (nb_groups
* 7);
572 * 3 delta-encoded exponents are in each 7-bit group. The number of groups
573 * varies depending on exponent strategy and bandwidth.
575 * @param s AC-3 encoder private context
577 void ff_ac3_group_exponents(AC3EncodeContext
*s
)
580 int group_size
, nb_groups
;
582 int delta0
, delta1
, delta2
;
585 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
586 AC3Block
*block
= &s
->blocks
[blk
];
587 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
588 int exp_strategy
= s
->exp_strategy
[ch
][blk
];
589 if (exp_strategy
== EXP_REUSE
)
591 cpl
= (ch
== CPL_CH
);
592 group_size
= exp_strategy
+ (exp_strategy
== EXP_D45
);
593 nb_groups
= exponent_group_tab
[cpl
][exp_strategy
-1][block
->end_freq
[ch
]-s
->start_freq
[ch
]];
594 p
= block
->exp
[ch
] + s
->start_freq
[ch
] - cpl
;
598 block
->grouped_exp
[ch
][0] = exp1
;
600 /* remaining exponents are delta encoded */
601 for (i
= 1; i
<= nb_groups
; i
++) {
602 /* merge three delta in one code */
606 delta0
= exp1
- exp0
+ 2;
607 av_assert2(delta0
>= 0 && delta0
<= 4);
612 delta1
= exp1
- exp0
+ 2;
613 av_assert2(delta1
>= 0 && delta1
<= 4);
618 delta2
= exp1
- exp0
+ 2;
619 av_assert2(delta2
>= 0 && delta2
<= 4);
621 block
->grouped_exp
[ch
][i
] = ((delta0
* 5 + delta1
) * 5) + delta2
;
629 * Calculate final exponents from the supplied MDCT coefficients and exponent shift.
630 * Extract exponents from MDCT coefficients, calculate exponent strategies,
631 * and encode final exponents.
633 * @param s AC-3 encoder private context
635 void ff_ac3_process_exponents(AC3EncodeContext
*s
)
637 extract_exponents(s
);
639 compute_exp_strategy(s
);
648 * Count frame bits that are based solely on fixed parameters.
649 * This only has to be run once when the encoder is initialized.
651 static void count_frame_bits_fixed(AC3EncodeContext
*s
)
653 static const int frame_bits_inc
[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
658 * no dynamic range codes
659 * bit allocation parameters do not change between blocks
660 * no delta bit allocation
667 frame_bits
= 16; /* sync info */
669 /* bitstream info header */
672 if (s
->num_blocks
!= 0x6)
675 /* audio frame header */
676 if (s
->num_blocks
== 6)
679 /* exponent strategy */
680 if (s
->use_frame_exp_strategy
)
681 frame_bits
+= 5 * s
->fbw_channels
;
683 frame_bits
+= s
->num_blocks
* 2 * s
->fbw_channels
;
685 frame_bits
+= s
->num_blocks
;
686 /* converter exponent strategy */
687 if (s
->num_blks_code
!= 0x3)
690 frame_bits
+= s
->fbw_channels
* 5;
693 /* block start info */
694 if (s
->num_blocks
!= 1)
698 frame_bits
+= frame_bits_inc
[s
->channel_mode
];
702 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
704 /* block switch flags */
705 frame_bits
+= s
->fbw_channels
;
708 frame_bits
+= s
->fbw_channels
;
714 /* spectral extension */
719 /* exponent strategy */
720 frame_bits
+= 2 * s
->fbw_channels
;
724 /* bit allocation params */
727 frame_bits
+= 2 + 2 + 2 + 2 + 3;
730 /* converter snr offset */
735 /* delta bit allocation */
747 frame_bits
+= 1 + 16;
749 s
->frame_bits_fixed
= frame_bits
;
754 * Initialize bit allocation.
755 * Set default parameter codes and calculate parameter values.
757 static void bit_alloc_init(AC3EncodeContext
*s
)
761 /* init default parameters */
762 s
->slow_decay_code
= 2;
763 s
->fast_decay_code
= 1;
764 s
->slow_gain_code
= 1;
765 s
->db_per_bit_code
= s
->eac3
? 2 : 3;
767 for (ch
= 0; ch
<= s
->channels
; ch
++)
768 s
->fast_gain_code
[ch
] = 4;
770 /* initial snr offset */
771 s
->coarse_snr_offset
= 40;
773 /* compute real values */
774 /* currently none of these values change during encoding, so we can just
775 set them once at initialization */
776 s
->bit_alloc
.slow_decay
= ff_ac3_slow_decay_tab
[s
->slow_decay_code
] >> s
->bit_alloc
.sr_shift
;
777 s
->bit_alloc
.fast_decay
= ff_ac3_fast_decay_tab
[s
->fast_decay_code
] >> s
->bit_alloc
.sr_shift
;
778 s
->bit_alloc
.slow_gain
= ff_ac3_slow_gain_tab
[s
->slow_gain_code
];
779 s
->bit_alloc
.db_per_bit
= ff_ac3_db_per_bit_tab
[s
->db_per_bit_code
];
780 s
->bit_alloc
.floor
= ff_ac3_floor_tab
[s
->floor_code
];
781 s
->bit_alloc
.cpl_fast_leak
= 0;
782 s
->bit_alloc
.cpl_slow_leak
= 0;
784 count_frame_bits_fixed(s
);
789 * Count the bits used to encode the frame, minus exponents and mantissas.
790 * Bits based on fixed parameters have already been counted, so now we just
791 * have to add the bits based on parameters that change during encoding.
793 static void count_frame_bits(AC3EncodeContext
*s
)
795 AC3EncOptions
*opt
= &s
->options
;
801 if (opt
->eac3_mixing_metadata
) {
802 if (s
->channel_mode
> AC3_CHMODE_STEREO
)
808 frame_bits
+= s
->lfe_on
;
809 frame_bits
+= 1 + 1 + 2;
810 if (s
->channel_mode
< AC3_CHMODE_STEREO
)
814 if (opt
->eac3_info_metadata
) {
815 frame_bits
+= 3 + 1 + 1;
816 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
818 if (s
->channel_mode
>= AC3_CHMODE_2F2R
)
821 if (opt
->audio_production_info
)
822 frame_bits
+= 5 + 2 + 1;
826 if (s
->channel_mode
> AC3_CHMODE_MONO
) {
828 for (blk
= 1; blk
< s
->num_blocks
; blk
++) {
829 AC3Block
*block
= &s
->blocks
[blk
];
831 if (block
->new_cpl_strategy
)
835 /* coupling exponent strategy */
837 if (s
->use_frame_exp_strategy
) {
838 frame_bits
+= 5 * s
->cpl_on
;
840 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
841 frame_bits
+= 2 * s
->blocks
[blk
].cpl_in_use
;
845 if (opt
->audio_production_info
)
847 if (s
->bitstream_id
== 6) {
848 if (opt
->extended_bsi_1
)
850 if (opt
->extended_bsi_2
)
856 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
857 AC3Block
*block
= &s
->blocks
[blk
];
859 /* coupling strategy */
862 if (block
->new_cpl_strategy
) {
865 if (block
->cpl_in_use
) {
868 if (!s
->eac3
|| s
->channel_mode
!= AC3_CHMODE_STEREO
)
869 frame_bits
+= s
->fbw_channels
;
870 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
876 frame_bits
+= s
->num_cpl_subbands
- 1;
880 /* coupling coordinates */
881 if (block
->cpl_in_use
) {
882 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
883 if (block
->channel_in_cpl
[ch
]) {
884 if (!s
->eac3
|| block
->new_cpl_coords
[ch
] != 2)
886 if (block
->new_cpl_coords
[ch
]) {
888 frame_bits
+= (4 + 4) * s
->num_cpl_bands
;
894 /* stereo rematrixing */
895 if (s
->channel_mode
== AC3_CHMODE_STEREO
) {
896 if (!s
->eac3
|| blk
> 0)
898 if (s
->blocks
[blk
].new_rematrixing_strategy
)
899 frame_bits
+= block
->num_rematrixing_bands
;
902 /* bandwidth codes & gain range */
903 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
904 if (s
->exp_strategy
[ch
][blk
] != EXP_REUSE
) {
905 if (!block
->channel_in_cpl
[ch
])
911 /* coupling exponent strategy */
912 if (!s
->eac3
&& block
->cpl_in_use
)
915 /* snr offsets and fast gain codes */
918 if (block
->new_snr_offsets
)
919 frame_bits
+= 6 + (s
->channels
+ block
->cpl_in_use
) * (4 + 3);
922 /* coupling leak info */
923 if (block
->cpl_in_use
) {
924 if (!s
->eac3
|| block
->new_cpl_leak
!= 2)
926 if (block
->new_cpl_leak
)
931 s
->frame_bits
= s
->frame_bits_fixed
+ frame_bits
;
936 * Calculate masking curve based on the final exponents.
937 * Also calculate the power spectral densities to use in future calculations.
939 static void bit_alloc_masking(AC3EncodeContext
*s
)
943 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
944 AC3Block
*block
= &s
->blocks
[blk
];
945 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
946 /* We only need psd and mask for calculating bap.
947 Since we currently do not calculate bap when exponent
948 strategy is EXP_REUSE we do not need to calculate psd or mask. */
949 if (s
->exp_strategy
[ch
][blk
] != EXP_REUSE
) {
950 ff_ac3_bit_alloc_calc_psd(block
->exp
[ch
], s
->start_freq
[ch
],
951 block
->end_freq
[ch
], block
->psd
[ch
],
952 block
->band_psd
[ch
]);
953 ff_ac3_bit_alloc_calc_mask(&s
->bit_alloc
, block
->band_psd
[ch
],
954 s
->start_freq
[ch
], block
->end_freq
[ch
],
955 ff_ac3_fast_gain_tab
[s
->fast_gain_code
[ch
]],
956 ch
== s
->lfe_channel
,
957 DBA_NONE
, 0, NULL
, NULL
, NULL
,
966 * Ensure that bap for each block and channel point to the current bap_buffer.
967 * They may have been switched during the bit allocation search.
969 static void reset_block_bap(AC3EncodeContext
*s
)
974 if (s
->ref_bap
[0][0] == s
->bap_buffer
&& s
->ref_bap_set
)
977 ref_bap
= s
->bap_buffer
;
978 for (ch
= 0; ch
<= s
->channels
; ch
++) {
979 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
980 s
->ref_bap
[ch
][blk
] = ref_bap
+ AC3_MAX_COEFS
* s
->exp_ref_block
[ch
][blk
];
981 ref_bap
+= AC3_MAX_COEFS
* s
->num_blocks
;
988 * Initialize mantissa counts.
989 * These are set so that they are padded to the next whole group size when bits
990 * are counted in compute_mantissa_size.
992 * @param[in,out] mant_cnt running counts for each bap value for each block
994 static void count_mantissa_bits_init(uint16_t mant_cnt
[AC3_MAX_BLOCKS
][16])
998 for (blk
= 0; blk
< AC3_MAX_BLOCKS
; blk
++) {
999 memset(mant_cnt
[blk
], 0, sizeof(mant_cnt
[blk
]));
1000 mant_cnt
[blk
][1] = mant_cnt
[blk
][2] = 2;
1001 mant_cnt
[blk
][4] = 1;
1007 * Update mantissa bit counts for all blocks in 1 channel in a given bandwidth
1010 * @param s AC-3 encoder private context
1011 * @param ch channel index
1012 * @param[in,out] mant_cnt running counts for each bap value for each block
1013 * @param start starting coefficient bin
1014 * @param end ending coefficient bin
1016 static void count_mantissa_bits_update_ch(AC3EncodeContext
*s
, int ch
,
1017 uint16_t mant_cnt
[AC3_MAX_BLOCKS
][16],
1022 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
1023 AC3Block
*block
= &s
->blocks
[blk
];
1024 if (ch
== CPL_CH
&& !block
->cpl_in_use
)
1026 s
->ac3dsp
.update_bap_counts(mant_cnt
[blk
],
1027 s
->ref_bap
[ch
][blk
] + start
,
1028 FFMIN(end
, block
->end_freq
[ch
]) - start
);
1034 * Count the number of mantissa bits in the frame based on the bap values.
1036 static int count_mantissa_bits(AC3EncodeContext
*s
)
1038 int ch
, max_end_freq
;
1039 LOCAL_ALIGNED_16(uint16_t, mant_cnt
, [AC3_MAX_BLOCKS
], [16]);
1041 count_mantissa_bits_init(mant_cnt
);
1043 max_end_freq
= s
->bandwidth_code
* 3 + 73;
1044 for (ch
= !s
->cpl_enabled
; ch
<= s
->channels
; ch
++)
1045 count_mantissa_bits_update_ch(s
, ch
, mant_cnt
, s
->start_freq
[ch
],
1048 return s
->ac3dsp
.compute_mantissa_size(mant_cnt
);
1053 * Run the bit allocation with a given SNR offset.
1054 * This calculates the bit allocation pointers that will be used to determine
1055 * the quantization of each mantissa.
1057 * @param s AC-3 encoder private context
1058 * @param snr_offset SNR offset, 0 to 1023
1059 * @return the number of bits needed for mantissas if the given SNR offset is
1062 static int bit_alloc(AC3EncodeContext
*s
, int snr_offset
)
1066 snr_offset
= (snr_offset
- 240) << 2;
1069 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
1070 AC3Block
*block
= &s
->blocks
[blk
];
1072 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
1073 /* Currently the only bit allocation parameters which vary across
1074 blocks within a frame are the exponent values. We can take
1075 advantage of that by reusing the bit allocation pointers
1076 whenever we reuse exponents. */
1077 if (s
->exp_strategy
[ch
][blk
] != EXP_REUSE
) {
1078 s
->ac3dsp
.bit_alloc_calc_bap(block
->mask
[ch
], block
->psd
[ch
],
1079 s
->start_freq
[ch
], block
->end_freq
[ch
],
1080 snr_offset
, s
->bit_alloc
.floor
,
1081 ff_ac3_bap_tab
, s
->ref_bap
[ch
][blk
]);
1085 return count_mantissa_bits(s
);
1090 * Constant bitrate bit allocation search.
1091 * Find the largest SNR offset that will allow data to fit in the frame.
1093 static int cbr_bit_allocation(AC3EncodeContext
*s
)
1097 int snr_offset
, snr_incr
;
1099 bits_left
= 8 * s
->frame_size
- (s
->frame_bits
+ s
->exponent_bits
);
1101 return AVERROR(EINVAL
);
1103 snr_offset
= s
->coarse_snr_offset
<< 4;
1105 /* if previous frame SNR offset was 1023, check if current frame can also
1106 use SNR offset of 1023. if so, skip the search. */
1107 if ((snr_offset
| s
->fine_snr_offset
[1]) == 1023) {
1108 if (bit_alloc(s
, 1023) <= bits_left
)
1112 while (snr_offset
>= 0 &&
1113 bit_alloc(s
, snr_offset
) > bits_left
) {
1117 return AVERROR(EINVAL
);
1119 FFSWAP(uint8_t *, s
->bap_buffer
, s
->bap1_buffer
);
1120 for (snr_incr
= 64; snr_incr
> 0; snr_incr
>>= 2) {
1121 while (snr_offset
+ snr_incr
<= 1023 &&
1122 bit_alloc(s
, snr_offset
+ snr_incr
) <= bits_left
) {
1123 snr_offset
+= snr_incr
;
1124 FFSWAP(uint8_t *, s
->bap_buffer
, s
->bap1_buffer
);
1127 FFSWAP(uint8_t *, s
->bap_buffer
, s
->bap1_buffer
);
1130 s
->coarse_snr_offset
= snr_offset
>> 4;
1131 for (ch
= !s
->cpl_on
; ch
<= s
->channels
; ch
++)
1132 s
->fine_snr_offset
[ch
] = snr_offset
& 0xF;
1139 * Perform bit allocation search.
1140 * Finds the SNR offset value that maximizes quality and fits in the specified
1141 * frame size. Output is the SNR offset and a set of bit allocation pointers
1142 * used to quantize the mantissas.
1144 int ff_ac3_compute_bit_allocation(AC3EncodeContext
*s
)
1146 count_frame_bits(s
);
1148 s
->exponent_bits
= count_exponent_bits(s
);
1150 bit_alloc_masking(s
);
1152 return cbr_bit_allocation(s
);
1157 * Symmetric quantization on 'levels' levels.
1159 * @param c unquantized coefficient
1161 * @param levels number of quantization levels
1162 * @return quantized coefficient
1164 static inline int sym_quant(int c
, int e
, int levels
)
1166 int v
= (((levels
* c
) >> (24 - e
)) + levels
) >> 1;
1167 av_assert2(v
>= 0 && v
< levels
);
1173 * Asymmetric quantization on 2^qbits levels.
1175 * @param c unquantized coefficient
1177 * @param qbits number of quantization bits
1178 * @return quantized coefficient
1180 static inline int asym_quant(int c
, int e
, int qbits
)
1184 c
= (((c
<< e
) >> (24 - qbits
)) + 1) >> 1;
1185 m
= (1 << (qbits
-1));
1188 av_assert2(c
>= -m
);
1194 * Quantize a set of mantissas for a single channel in a single block.
1196 * @param s Mantissa count context
1197 * @param fixed_coef unquantized fixed-point coefficients
1198 * @param exp exponents
1199 * @param bap bit allocation pointer indices
1200 * @param[out] qmant quantized coefficients
1201 * @param start_freq starting coefficient bin
1202 * @param end_freq ending coefficient bin
1204 static void quantize_mantissas_blk_ch(AC3Mant
*s
, int32_t *fixed_coef
,
1205 uint8_t *exp
, uint8_t *bap
,
1206 int16_t *qmant
, int start_freq
,
1211 for (i
= start_freq
; i
< end_freq
; i
++) {
1213 int c
= fixed_coef
[i
];
1221 v
= sym_quant(c
, e
, 3);
1222 switch (s
->mant1_cnt
) {
1224 s
->qmant1_ptr
= &qmant
[i
];
1229 *s
->qmant1_ptr
+= 3 * v
;
1234 *s
->qmant1_ptr
+= v
;
1241 v
= sym_quant(c
, e
, 5);
1242 switch (s
->mant2_cnt
) {
1244 s
->qmant2_ptr
= &qmant
[i
];
1249 *s
->qmant2_ptr
+= 5 * v
;
1254 *s
->qmant2_ptr
+= v
;
1261 v
= sym_quant(c
, e
, 7);
1264 v
= sym_quant(c
, e
, 11);
1265 switch (s
->mant4_cnt
) {
1267 s
->qmant4_ptr
= &qmant
[i
];
1272 *s
->qmant4_ptr
+= v
;
1279 v
= sym_quant(c
, e
, 15);
1282 v
= asym_quant(c
, e
, 14);
1285 v
= asym_quant(c
, e
, 16);
1288 v
= asym_quant(c
, e
, b
- 1);
1297 * Quantize mantissas using coefficients, exponents, and bit allocation pointers.
1299 * @param s AC-3 encoder private context
1301 void ff_ac3_quantize_mantissas(AC3EncodeContext
*s
)
1303 int blk
, ch
, ch0
=0, got_cpl
;
1305 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
1306 AC3Block
*block
= &s
->blocks
[blk
];
1309 got_cpl
= !block
->cpl_in_use
;
1310 for (ch
= 1; ch
<= s
->channels
; ch
++) {
1311 if (!got_cpl
&& ch
> 1 && block
->channel_in_cpl
[ch
-1]) {
1316 quantize_mantissas_blk_ch(&m
, block
->fixed_coef
[ch
],
1317 s
->blocks
[s
->exp_ref_block
[ch
][blk
]].exp
[ch
],
1318 s
->ref_bap
[ch
][blk
], block
->qmant
[ch
],
1319 s
->start_freq
[ch
], block
->end_freq
[ch
]);
1328 * Write the AC-3 frame header to the output bitstream.
1330 static void ac3_output_frame_header(AC3EncodeContext
*s
)
1332 AC3EncOptions
*opt
= &s
->options
;
1334 put_bits(&s
->pb
, 16, 0x0b77); /* frame header */
1335 put_bits(&s
->pb
, 16, 0); /* crc1: will be filled later */
1336 put_bits(&s
->pb
, 2, s
->bit_alloc
.sr_code
);
1337 put_bits(&s
->pb
, 6, s
->frame_size_code
+ (s
->frame_size
- s
->frame_size_min
) / 2);
1338 put_bits(&s
->pb
, 5, s
->bitstream_id
);
1339 put_bits(&s
->pb
, 3, s
->bitstream_mode
);
1340 put_bits(&s
->pb
, 3, s
->channel_mode
);
1341 if ((s
->channel_mode
& 0x01) && s
->channel_mode
!= AC3_CHMODE_MONO
)
1342 put_bits(&s
->pb
, 2, s
->center_mix_level
);
1343 if (s
->channel_mode
& 0x04)
1344 put_bits(&s
->pb
, 2, s
->surround_mix_level
);
1345 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
1346 put_bits(&s
->pb
, 2, opt
->dolby_surround_mode
);
1347 put_bits(&s
->pb
, 1, s
->lfe_on
); /* LFE */
1348 put_bits(&s
->pb
, 5, -opt
->dialogue_level
);
1349 put_bits(&s
->pb
, 1, 0); /* no compression control word */
1350 put_bits(&s
->pb
, 1, 0); /* no lang code */
1351 put_bits(&s
->pb
, 1, opt
->audio_production_info
);
1352 if (opt
->audio_production_info
) {
1353 put_bits(&s
->pb
, 5, opt
->mixing_level
- 80);
1354 put_bits(&s
->pb
, 2, opt
->room_type
);
1356 put_bits(&s
->pb
, 1, opt
->copyright
);
1357 put_bits(&s
->pb
, 1, opt
->original
);
1358 if (s
->bitstream_id
== 6) {
1359 /* alternate bit stream syntax */
1360 put_bits(&s
->pb
, 1, opt
->extended_bsi_1
);
1361 if (opt
->extended_bsi_1
) {
1362 put_bits(&s
->pb
, 2, opt
->preferred_stereo_downmix
);
1363 put_bits(&s
->pb
, 3, s
->ltrt_center_mix_level
);
1364 put_bits(&s
->pb
, 3, s
->ltrt_surround_mix_level
);
1365 put_bits(&s
->pb
, 3, s
->loro_center_mix_level
);
1366 put_bits(&s
->pb
, 3, s
->loro_surround_mix_level
);
1368 put_bits(&s
->pb
, 1, opt
->extended_bsi_2
);
1369 if (opt
->extended_bsi_2
) {
1370 put_bits(&s
->pb
, 2, opt
->dolby_surround_ex_mode
);
1371 put_bits(&s
->pb
, 2, opt
->dolby_headphone_mode
);
1372 put_bits(&s
->pb
, 1, opt
->ad_converter_type
);
1373 put_bits(&s
->pb
, 9, 0); /* xbsi2 and encinfo : reserved */
1376 put_bits(&s
->pb
, 1, 0); /* no time code 1 */
1377 put_bits(&s
->pb
, 1, 0); /* no time code 2 */
1379 put_bits(&s
->pb
, 1, 0); /* no additional bit stream info */
1384 * Write one audio block to the output bitstream.
1386 static void output_audio_block(AC3EncodeContext
*s
, int blk
)
1388 int ch
, i
, baie
, bnd
, got_cpl
, ch0
;
1389 AC3Block
*block
= &s
->blocks
[blk
];
1391 /* block switching */
1393 for (ch
= 0; ch
< s
->fbw_channels
; ch
++)
1394 put_bits(&s
->pb
, 1, 0);
1399 for (ch
= 0; ch
< s
->fbw_channels
; ch
++)
1400 put_bits(&s
->pb
, 1, 1);
1403 /* dynamic range codes */
1404 put_bits(&s
->pb
, 1, 0);
1406 /* spectral extension */
1408 put_bits(&s
->pb
, 1, 0);
1410 /* channel coupling */
1412 put_bits(&s
->pb
, 1, block
->new_cpl_strategy
);
1413 if (block
->new_cpl_strategy
) {
1415 put_bits(&s
->pb
, 1, block
->cpl_in_use
);
1416 if (block
->cpl_in_use
) {
1417 int start_sub
, end_sub
;
1419 put_bits(&s
->pb
, 1, 0); /* enhanced coupling */
1420 if (!s
->eac3
|| s
->channel_mode
!= AC3_CHMODE_STEREO
) {
1421 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
1422 put_bits(&s
->pb
, 1, block
->channel_in_cpl
[ch
]);
1424 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
1425 put_bits(&s
->pb
, 1, 0); /* phase flags in use */
1426 start_sub
= (s
->start_freq
[CPL_CH
] - 37) / 12;
1427 end_sub
= (s
->cpl_end_freq
- 37) / 12;
1428 put_bits(&s
->pb
, 4, start_sub
);
1429 put_bits(&s
->pb
, 4, end_sub
- 3);
1430 /* coupling band structure */
1432 put_bits(&s
->pb
, 1, 0); /* use default */
1434 for (bnd
= start_sub
+1; bnd
< end_sub
; bnd
++)
1435 put_bits(&s
->pb
, 1, ff_eac3_default_cpl_band_struct
[bnd
]);
1440 /* coupling coordinates */
1441 if (block
->cpl_in_use
) {
1442 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
1443 if (block
->channel_in_cpl
[ch
]) {
1444 if (!s
->eac3
|| block
->new_cpl_coords
[ch
] != 2)
1445 put_bits(&s
->pb
, 1, block
->new_cpl_coords
[ch
]);
1446 if (block
->new_cpl_coords
[ch
]) {
1447 put_bits(&s
->pb
, 2, block
->cpl_master_exp
[ch
]);
1448 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
1449 put_bits(&s
->pb
, 4, block
->cpl_coord_exp
[ch
][bnd
]);
1450 put_bits(&s
->pb
, 4, block
->cpl_coord_mant
[ch
][bnd
]);
1457 /* stereo rematrixing */
1458 if (s
->channel_mode
== AC3_CHMODE_STEREO
) {
1459 if (!s
->eac3
|| blk
> 0)
1460 put_bits(&s
->pb
, 1, block
->new_rematrixing_strategy
);
1461 if (block
->new_rematrixing_strategy
) {
1462 /* rematrixing flags */
1463 for (bnd
= 0; bnd
< block
->num_rematrixing_bands
; bnd
++)
1464 put_bits(&s
->pb
, 1, block
->rematrixing_flags
[bnd
]);
1468 /* exponent strategy */
1470 for (ch
= !block
->cpl_in_use
; ch
<= s
->fbw_channels
; ch
++)
1471 put_bits(&s
->pb
, 2, s
->exp_strategy
[ch
][blk
]);
1473 put_bits(&s
->pb
, 1, s
->exp_strategy
[s
->lfe_channel
][blk
]);
1477 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
1478 if (s
->exp_strategy
[ch
][blk
] != EXP_REUSE
&& !block
->channel_in_cpl
[ch
])
1479 put_bits(&s
->pb
, 6, s
->bandwidth_code
);
1483 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
1485 int cpl
= (ch
== CPL_CH
);
1487 if (s
->exp_strategy
[ch
][blk
] == EXP_REUSE
)
1491 put_bits(&s
->pb
, 4, block
->grouped_exp
[ch
][0] >> cpl
);
1493 /* exponent groups */
1494 nb_groups
= exponent_group_tab
[cpl
][s
->exp_strategy
[ch
][blk
]-1][block
->end_freq
[ch
]-s
->start_freq
[ch
]];
1495 for (i
= 1; i
<= nb_groups
; i
++)
1496 put_bits(&s
->pb
, 7, block
->grouped_exp
[ch
][i
]);
1498 /* gain range info */
1499 if (ch
!= s
->lfe_channel
&& !cpl
)
1500 put_bits(&s
->pb
, 2, 0);
1503 /* bit allocation info */
1506 put_bits(&s
->pb
, 1, baie
);
1508 put_bits(&s
->pb
, 2, s
->slow_decay_code
);
1509 put_bits(&s
->pb
, 2, s
->fast_decay_code
);
1510 put_bits(&s
->pb
, 2, s
->slow_gain_code
);
1511 put_bits(&s
->pb
, 2, s
->db_per_bit_code
);
1512 put_bits(&s
->pb
, 3, s
->floor_code
);
1518 put_bits(&s
->pb
, 1, block
->new_snr_offsets
);
1519 if (block
->new_snr_offsets
) {
1520 put_bits(&s
->pb
, 6, s
->coarse_snr_offset
);
1521 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
1522 put_bits(&s
->pb
, 4, s
->fine_snr_offset
[ch
]);
1523 put_bits(&s
->pb
, 3, s
->fast_gain_code
[ch
]);
1527 put_bits(&s
->pb
, 1, 0); /* no converter snr offset */
1531 if (block
->cpl_in_use
) {
1532 if (!s
->eac3
|| block
->new_cpl_leak
!= 2)
1533 put_bits(&s
->pb
, 1, block
->new_cpl_leak
);
1534 if (block
->new_cpl_leak
) {
1535 put_bits(&s
->pb
, 3, s
->bit_alloc
.cpl_fast_leak
);
1536 put_bits(&s
->pb
, 3, s
->bit_alloc
.cpl_slow_leak
);
1541 put_bits(&s
->pb
, 1, 0); /* no delta bit allocation */
1542 put_bits(&s
->pb
, 1, 0); /* no data to skip */
1546 got_cpl
= !block
->cpl_in_use
;
1547 for (ch
= 1; ch
<= s
->channels
; ch
++) {
1550 if (!got_cpl
&& ch
> 1 && block
->channel_in_cpl
[ch
-1]) {
1555 for (i
= s
->start_freq
[ch
]; i
< block
->end_freq
[ch
]; i
++) {
1556 q
= block
->qmant
[ch
][i
];
1557 b
= s
->ref_bap
[ch
][blk
][i
];
1560 case 1: if (q
!= 128) put_bits (&s
->pb
, 5, q
); break;
1561 case 2: if (q
!= 128) put_bits (&s
->pb
, 7, q
); break;
1562 case 3: put_sbits(&s
->pb
, 3, q
); break;
1563 case 4: if (q
!= 128) put_bits (&s
->pb
, 7, q
); break;
1564 case 14: put_sbits(&s
->pb
, 14, q
); break;
1565 case 15: put_sbits(&s
->pb
, 16, q
); break;
1566 default: put_sbits(&s
->pb
, b
-1, q
); break;
1575 /** CRC-16 Polynomial */
1576 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))
1579 static unsigned int mul_poly(unsigned int a
, unsigned int b
, unsigned int poly
)
1596 static unsigned int pow_poly(unsigned int a
, unsigned int n
, unsigned int poly
)
1602 r
= mul_poly(r
, a
, poly
);
1603 a
= mul_poly(a
, a
, poly
);
1611 * Fill the end of the frame with 0's and compute the two CRCs.
1613 static void output_frame_end(AC3EncodeContext
*s
)
1615 const AVCRC
*crc_ctx
= av_crc_get_table(AV_CRC_16_ANSI
);
1616 int frame_size_58
, pad_bytes
, crc1
, crc2_partial
, crc2
, crc_inv
;
1619 frame_size_58
= ((s
->frame_size
>> 2) + (s
->frame_size
>> 4)) << 1;
1621 /* pad the remainder of the frame with zeros */
1622 av_assert2(s
->frame_size
* 8 - put_bits_count(&s
->pb
) >= 18);
1623 flush_put_bits(&s
->pb
);
1625 pad_bytes
= s
->frame_size
- (put_bits_ptr(&s
->pb
) - frame
) - 2;
1626 av_assert2(pad_bytes
>= 0);
1628 memset(put_bits_ptr(&s
->pb
), 0, pad_bytes
);
1632 crc2_partial
= av_crc(crc_ctx
, 0, frame
+ 2, s
->frame_size
- 5);
1635 /* this is not so easy because it is at the beginning of the data... */
1636 crc1
= av_bswap16(av_crc(crc_ctx
, 0, frame
+ 4, frame_size_58
- 4));
1637 crc_inv
= s
->crc_inv
[s
->frame_size
> s
->frame_size_min
];
1638 crc1
= mul_poly(crc_inv
, crc1
, CRC16_POLY
);
1639 AV_WB16(frame
+ 2, crc1
);
1642 crc2_partial
= av_crc(crc_ctx
, 0, frame
+ frame_size_58
,
1643 s
->frame_size
- frame_size_58
- 3);
1645 crc2
= av_crc(crc_ctx
, crc2_partial
, frame
+ s
->frame_size
- 3, 1);
1646 /* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
1647 if (crc2
== 0x770B) {
1648 frame
[s
->frame_size
- 3] ^= 0x1;
1649 crc2
= av_crc(crc_ctx
, crc2_partial
, frame
+ s
->frame_size
- 3, 1);
1651 crc2
= av_bswap16(crc2
);
1652 AV_WB16(frame
+ s
->frame_size
- 2, crc2
);
1657 * Write the frame to the output bitstream.
1659 * @param s AC-3 encoder private context
1660 * @param frame output data buffer
1662 void ff_ac3_output_frame(AC3EncodeContext
*s
, unsigned char *frame
)
1666 init_put_bits(&s
->pb
, frame
, AC3_MAX_CODED_FRAME_SIZE
);
1668 s
->output_frame_header(s
);
1670 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
1671 output_audio_block(s
, blk
);
1673 output_frame_end(s
);
1677 static void dprint_options(AC3EncodeContext
*s
)
1680 AVCodecContext
*avctx
= s
->avctx
;
1681 AC3EncOptions
*opt
= &s
->options
;
1684 switch (s
->bitstream_id
) {
1685 case 6: av_strlcpy(strbuf
, "AC-3 (alt syntax)", 32); break;
1686 case 8: av_strlcpy(strbuf
, "AC-3 (standard)", 32); break;
1687 case 9: av_strlcpy(strbuf
, "AC-3 (dnet half-rate)", 32); break;
1688 case 10: av_strlcpy(strbuf
, "AC-3 (dnet quater-rate)", 32); break;
1689 case 16: av_strlcpy(strbuf
, "E-AC-3 (enhanced)", 32); break;
1690 default: snprintf(strbuf
, 32, "ERROR");
1692 av_dlog(avctx
, "bitstream_id: %s (%d)\n", strbuf
, s
->bitstream_id
);
1693 av_dlog(avctx
, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx
->sample_fmt
));
1694 av_get_channel_layout_string(strbuf
, 32, s
->channels
, avctx
->channel_layout
);
1695 av_dlog(avctx
, "channel_layout: %s\n", strbuf
);
1696 av_dlog(avctx
, "sample_rate: %d\n", s
->sample_rate
);
1697 av_dlog(avctx
, "bit_rate: %d\n", s
->bit_rate
);
1698 av_dlog(avctx
, "blocks/frame: %d (code=%d)\n", s
->num_blocks
, s
->num_blks_code
);
1700 av_dlog(avctx
, "cutoff: %d\n", s
->cutoff
);
1702 av_dlog(avctx
, "per_frame_metadata: %s\n",
1703 opt
->allow_per_frame_metadata
?"on":"off");
1705 av_dlog(avctx
, "center_mixlev: %0.3f (%d)\n", opt
->center_mix_level
,
1706 s
->center_mix_level
);
1708 av_dlog(avctx
, "center_mixlev: {not written}\n");
1709 if (s
->has_surround
)
1710 av_dlog(avctx
, "surround_mixlev: %0.3f (%d)\n", opt
->surround_mix_level
,
1711 s
->surround_mix_level
);
1713 av_dlog(avctx
, "surround_mixlev: {not written}\n");
1714 if (opt
->audio_production_info
) {
1715 av_dlog(avctx
, "mixing_level: %ddB\n", opt
->mixing_level
);
1716 switch (opt
->room_type
) {
1717 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1718 case AC3ENC_OPT_LARGE_ROOM
: av_strlcpy(strbuf
, "large", 32); break;
1719 case AC3ENC_OPT_SMALL_ROOM
: av_strlcpy(strbuf
, "small", 32); break;
1720 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->room_type
);
1722 av_dlog(avctx
, "room_type: %s\n", strbuf
);
1724 av_dlog(avctx
, "mixing_level: {not written}\n");
1725 av_dlog(avctx
, "room_type: {not written}\n");
1727 av_dlog(avctx
, "copyright: %s\n", opt
->copyright
?"on":"off");
1728 av_dlog(avctx
, "dialnorm: %ddB\n", opt
->dialogue_level
);
1729 if (s
->channel_mode
== AC3_CHMODE_STEREO
) {
1730 switch (opt
->dolby_surround_mode
) {
1731 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1732 case AC3ENC_OPT_MODE_ON
: av_strlcpy(strbuf
, "on", 32); break;
1733 case AC3ENC_OPT_MODE_OFF
: av_strlcpy(strbuf
, "off", 32); break;
1734 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->dolby_surround_mode
);
1736 av_dlog(avctx
, "dsur_mode: %s\n", strbuf
);
1738 av_dlog(avctx
, "dsur_mode: {not written}\n");
1740 av_dlog(avctx
, "original: %s\n", opt
->original
?"on":"off");
1742 if (s
->bitstream_id
== 6) {
1743 if (opt
->extended_bsi_1
) {
1744 switch (opt
->preferred_stereo_downmix
) {
1745 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1746 case AC3ENC_OPT_DOWNMIX_LTRT
: av_strlcpy(strbuf
, "ltrt", 32); break;
1747 case AC3ENC_OPT_DOWNMIX_LORO
: av_strlcpy(strbuf
, "loro", 32); break;
1748 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->preferred_stereo_downmix
);
1750 av_dlog(avctx
, "dmix_mode: %s\n", strbuf
);
1751 av_dlog(avctx
, "ltrt_cmixlev: %0.3f (%d)\n",
1752 opt
->ltrt_center_mix_level
, s
->ltrt_center_mix_level
);
1753 av_dlog(avctx
, "ltrt_surmixlev: %0.3f (%d)\n",
1754 opt
->ltrt_surround_mix_level
, s
->ltrt_surround_mix_level
);
1755 av_dlog(avctx
, "loro_cmixlev: %0.3f (%d)\n",
1756 opt
->loro_center_mix_level
, s
->loro_center_mix_level
);
1757 av_dlog(avctx
, "loro_surmixlev: %0.3f (%d)\n",
1758 opt
->loro_surround_mix_level
, s
->loro_surround_mix_level
);
1760 av_dlog(avctx
, "extended bitstream info 1: {not written}\n");
1762 if (opt
->extended_bsi_2
) {
1763 switch (opt
->dolby_surround_ex_mode
) {
1764 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1765 case AC3ENC_OPT_MODE_ON
: av_strlcpy(strbuf
, "on", 32); break;
1766 case AC3ENC_OPT_MODE_OFF
: av_strlcpy(strbuf
, "off", 32); break;
1767 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->dolby_surround_ex_mode
);
1769 av_dlog(avctx
, "dsurex_mode: %s\n", strbuf
);
1770 switch (opt
->dolby_headphone_mode
) {
1771 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1772 case AC3ENC_OPT_MODE_ON
: av_strlcpy(strbuf
, "on", 32); break;
1773 case AC3ENC_OPT_MODE_OFF
: av_strlcpy(strbuf
, "off", 32); break;
1774 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->dolby_headphone_mode
);
1776 av_dlog(avctx
, "dheadphone_mode: %s\n", strbuf
);
1778 switch (opt
->ad_converter_type
) {
1779 case AC3ENC_OPT_ADCONV_STANDARD
: av_strlcpy(strbuf
, "standard", 32); break;
1780 case AC3ENC_OPT_ADCONV_HDCD
: av_strlcpy(strbuf
, "hdcd", 32); break;
1781 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->ad_converter_type
);
1783 av_dlog(avctx
, "ad_conv_type: %s\n", strbuf
);
1785 av_dlog(avctx
, "extended bitstream info 2: {not written}\n");
1792 #define FLT_OPTION_THRESHOLD 0.01
1794 static int validate_float_option(float v
, const float *v_list
, int v_list_size
)
1798 for (i
= 0; i
< v_list_size
; i
++) {
1799 if (v
< (v_list
[i
] + FLT_OPTION_THRESHOLD
) &&
1800 v
> (v_list
[i
] - FLT_OPTION_THRESHOLD
))
1803 if (i
== v_list_size
)
1810 static void validate_mix_level(void *log_ctx
, const char *opt_name
,
1811 float *opt_param
, const float *list
,
1812 int list_size
, int default_value
, int min_value
,
1815 int mixlev
= validate_float_option(*opt_param
, list
, list_size
);
1816 if (mixlev
< min_value
) {
1817 mixlev
= default_value
;
1818 if (*opt_param
>= 0.0) {
1819 av_log(log_ctx
, AV_LOG_WARNING
, "requested %s is not valid. using "
1820 "default value: %0.3f\n", opt_name
, list
[mixlev
]);
1823 *opt_param
= list
[mixlev
];
1824 *ctx_param
= mixlev
;
1829 * Validate metadata options as set by AVOption system.
1830 * These values can optionally be changed per-frame.
1832 * @param s AC-3 encoder private context
1834 int ff_ac3_validate_metadata(AC3EncodeContext
*s
)
1836 AVCodecContext
*avctx
= s
->avctx
;
1837 AC3EncOptions
*opt
= &s
->options
;
1839 opt
->audio_production_info
= 0;
1840 opt
->extended_bsi_1
= 0;
1841 opt
->extended_bsi_2
= 0;
1842 opt
->eac3_mixing_metadata
= 0;
1843 opt
->eac3_info_metadata
= 0;
1845 /* determine mixing metadata / xbsi1 use */
1846 if (s
->channel_mode
> AC3_CHMODE_STEREO
&& opt
->preferred_stereo_downmix
!= AC3ENC_OPT_NONE
) {
1847 opt
->extended_bsi_1
= 1;
1848 opt
->eac3_mixing_metadata
= 1;
1850 if (s
->has_center
&&
1851 (opt
->ltrt_center_mix_level
>= 0 || opt
->loro_center_mix_level
>= 0)) {
1852 opt
->extended_bsi_1
= 1;
1853 opt
->eac3_mixing_metadata
= 1;
1855 if (s
->has_surround
&&
1856 (opt
->ltrt_surround_mix_level
>= 0 || opt
->loro_surround_mix_level
>= 0)) {
1857 opt
->extended_bsi_1
= 1;
1858 opt
->eac3_mixing_metadata
= 1;
1862 /* determine info metadata use */
1863 if (avctx
->audio_service_type
!= AV_AUDIO_SERVICE_TYPE_MAIN
)
1864 opt
->eac3_info_metadata
= 1;
1865 if (opt
->copyright
!= AC3ENC_OPT_NONE
|| opt
->original
!= AC3ENC_OPT_NONE
)
1866 opt
->eac3_info_metadata
= 1;
1867 if (s
->channel_mode
== AC3_CHMODE_STEREO
&&
1868 (opt
->dolby_headphone_mode
!= AC3ENC_OPT_NONE
|| opt
->dolby_surround_mode
!= AC3ENC_OPT_NONE
))
1869 opt
->eac3_info_metadata
= 1;
1870 if (s
->channel_mode
>= AC3_CHMODE_2F2R
&& opt
->dolby_surround_ex_mode
!= AC3ENC_OPT_NONE
)
1871 opt
->eac3_info_metadata
= 1;
1872 if (opt
->mixing_level
!= AC3ENC_OPT_NONE
|| opt
->room_type
!= AC3ENC_OPT_NONE
||
1873 opt
->ad_converter_type
!= AC3ENC_OPT_NONE
) {
1874 opt
->audio_production_info
= 1;
1875 opt
->eac3_info_metadata
= 1;
1878 /* determine audio production info use */
1879 if (opt
->mixing_level
!= AC3ENC_OPT_NONE
|| opt
->room_type
!= AC3ENC_OPT_NONE
)
1880 opt
->audio_production_info
= 1;
1882 /* determine xbsi2 use */
1883 if (s
->channel_mode
>= AC3_CHMODE_2F2R
&& opt
->dolby_surround_ex_mode
!= AC3ENC_OPT_NONE
)
1884 opt
->extended_bsi_2
= 1;
1885 if (s
->channel_mode
== AC3_CHMODE_STEREO
&& opt
->dolby_headphone_mode
!= AC3ENC_OPT_NONE
)
1886 opt
->extended_bsi_2
= 1;
1887 if (opt
->ad_converter_type
!= AC3ENC_OPT_NONE
)
1888 opt
->extended_bsi_2
= 1;
1891 /* validate AC-3 mixing levels */
1893 if (s
->has_center
) {
1894 validate_mix_level(avctx
, "center_mix_level", &opt
->center_mix_level
,
1895 cmixlev_options
, CMIXLEV_NUM_OPTIONS
, 1, 0,
1896 &s
->center_mix_level
);
1898 if (s
->has_surround
) {
1899 validate_mix_level(avctx
, "surround_mix_level", &opt
->surround_mix_level
,
1900 surmixlev_options
, SURMIXLEV_NUM_OPTIONS
, 1, 0,
1901 &s
->surround_mix_level
);
1905 /* validate extended bsi 1 / mixing metadata */
1906 if (opt
->extended_bsi_1
|| opt
->eac3_mixing_metadata
) {
1907 /* default preferred stereo downmix */
1908 if (opt
->preferred_stereo_downmix
== AC3ENC_OPT_NONE
)
1909 opt
->preferred_stereo_downmix
= AC3ENC_OPT_NOT_INDICATED
;
1910 if (!s
->eac3
|| s
->has_center
) {
1911 /* validate Lt/Rt center mix level */
1912 validate_mix_level(avctx
, "ltrt_center_mix_level",
1913 &opt
->ltrt_center_mix_level
, extmixlev_options
,
1914 EXTMIXLEV_NUM_OPTIONS
, 5, 0,
1915 &s
->ltrt_center_mix_level
);
1916 /* validate Lo/Ro center mix level */
1917 validate_mix_level(avctx
, "loro_center_mix_level",
1918 &opt
->loro_center_mix_level
, extmixlev_options
,
1919 EXTMIXLEV_NUM_OPTIONS
, 5, 0,
1920 &s
->loro_center_mix_level
);
1922 if (!s
->eac3
|| s
->has_surround
) {
1923 /* validate Lt/Rt surround mix level */
1924 validate_mix_level(avctx
, "ltrt_surround_mix_level",
1925 &opt
->ltrt_surround_mix_level
, extmixlev_options
,
1926 EXTMIXLEV_NUM_OPTIONS
, 6, 3,
1927 &s
->ltrt_surround_mix_level
);
1928 /* validate Lo/Ro surround mix level */
1929 validate_mix_level(avctx
, "loro_surround_mix_level",
1930 &opt
->loro_surround_mix_level
, extmixlev_options
,
1931 EXTMIXLEV_NUM_OPTIONS
, 6, 3,
1932 &s
->loro_surround_mix_level
);
1936 /* validate audio service type / channels combination */
1937 if ((avctx
->audio_service_type
== AV_AUDIO_SERVICE_TYPE_KARAOKE
&&
1938 avctx
->channels
== 1) ||
1939 ((avctx
->audio_service_type
== AV_AUDIO_SERVICE_TYPE_COMMENTARY
||
1940 avctx
->audio_service_type
== AV_AUDIO_SERVICE_TYPE_EMERGENCY
||
1941 avctx
->audio_service_type
== AV_AUDIO_SERVICE_TYPE_VOICE_OVER
)
1942 && avctx
->channels
> 1)) {
1943 av_log(avctx
, AV_LOG_ERROR
, "invalid audio service type for the "
1944 "specified number of channels\n");
1945 return AVERROR(EINVAL
);
1948 /* validate extended bsi 2 / info metadata */
1949 if (opt
->extended_bsi_2
|| opt
->eac3_info_metadata
) {
1950 /* default dolby headphone mode */
1951 if (opt
->dolby_headphone_mode
== AC3ENC_OPT_NONE
)
1952 opt
->dolby_headphone_mode
= AC3ENC_OPT_NOT_INDICATED
;
1953 /* default dolby surround ex mode */
1954 if (opt
->dolby_surround_ex_mode
== AC3ENC_OPT_NONE
)
1955 opt
->dolby_surround_ex_mode
= AC3ENC_OPT_NOT_INDICATED
;
1956 /* default A/D converter type */
1957 if (opt
->ad_converter_type
== AC3ENC_OPT_NONE
)
1958 opt
->ad_converter_type
= AC3ENC_OPT_ADCONV_STANDARD
;
1961 /* copyright & original defaults */
1962 if (!s
->eac3
|| opt
->eac3_info_metadata
) {
1963 /* default copyright */
1964 if (opt
->copyright
== AC3ENC_OPT_NONE
)
1965 opt
->copyright
= AC3ENC_OPT_OFF
;
1966 /* default original */
1967 if (opt
->original
== AC3ENC_OPT_NONE
)
1968 opt
->original
= AC3ENC_OPT_ON
;
1971 /* dolby surround mode default */
1972 if (!s
->eac3
|| opt
->eac3_info_metadata
) {
1973 if (opt
->dolby_surround_mode
== AC3ENC_OPT_NONE
)
1974 opt
->dolby_surround_mode
= AC3ENC_OPT_NOT_INDICATED
;
1977 /* validate audio production info */
1978 if (opt
->audio_production_info
) {
1979 if (opt
->mixing_level
== AC3ENC_OPT_NONE
) {
1980 av_log(avctx
, AV_LOG_ERROR
, "mixing_level must be set if "
1981 "room_type is set\n");
1982 return AVERROR(EINVAL
);
1984 if (opt
->mixing_level
< 80) {
1985 av_log(avctx
, AV_LOG_ERROR
, "invalid mixing level. must be between "
1986 "80dB and 111dB\n");
1987 return AVERROR(EINVAL
);
1989 /* default room type */
1990 if (opt
->room_type
== AC3ENC_OPT_NONE
)
1991 opt
->room_type
= AC3ENC_OPT_NOT_INDICATED
;
1994 /* set bitstream id for alternate bitstream syntax */
1995 if (!s
->eac3
&& (opt
->extended_bsi_1
|| opt
->extended_bsi_2
)) {
1996 if (s
->bitstream_id
> 8 && s
->bitstream_id
< 11) {
1997 static int warn_once
= 1;
1999 av_log(avctx
, AV_LOG_WARNING
, "alternate bitstream syntax is "
2000 "not compatible with reduced samplerates. writing of "
2001 "extended bitstream information will be disabled.\n");
2005 s
->bitstream_id
= 6;
2014 * Finalize encoding and free any memory allocated by the encoder.
2016 * @param avctx Codec context
2018 av_cold
int ff_ac3_encode_close(AVCodecContext
*avctx
)
2021 AC3EncodeContext
*s
= avctx
->priv_data
;
2023 av_freep(&s
->windowed_samples
);
2024 for (ch
= 0; ch
< s
->channels
; ch
++)
2025 av_freep(&s
->planar_samples
[ch
]);
2026 av_freep(&s
->planar_samples
);
2027 av_freep(&s
->bap_buffer
);
2028 av_freep(&s
->bap1_buffer
);
2029 av_freep(&s
->mdct_coef_buffer
);
2030 av_freep(&s
->fixed_coef_buffer
);
2031 av_freep(&s
->exp_buffer
);
2032 av_freep(&s
->grouped_exp_buffer
);
2033 av_freep(&s
->psd_buffer
);
2034 av_freep(&s
->band_psd_buffer
);
2035 av_freep(&s
->mask_buffer
);
2036 av_freep(&s
->qmant_buffer
);
2037 av_freep(&s
->cpl_coord_exp_buffer
);
2038 av_freep(&s
->cpl_coord_mant_buffer
);
2039 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
2040 AC3Block
*block
= &s
->blocks
[blk
];
2041 av_freep(&block
->mdct_coef
);
2042 av_freep(&block
->fixed_coef
);
2043 av_freep(&block
->exp
);
2044 av_freep(&block
->grouped_exp
);
2045 av_freep(&block
->psd
);
2046 av_freep(&block
->band_psd
);
2047 av_freep(&block
->mask
);
2048 av_freep(&block
->qmant
);
2049 av_freep(&block
->cpl_coord_exp
);
2050 av_freep(&block
->cpl_coord_mant
);
2055 #if FF_API_OLD_ENCODE_AUDIO
2056 av_freep(&avctx
->coded_frame
);
2063 * Set channel information during initialization.
2065 static av_cold
int set_channel_info(AC3EncodeContext
*s
, int channels
,
2066 uint64_t *channel_layout
)
2070 if (channels
< 1 || channels
> AC3_MAX_CHANNELS
)
2071 return AVERROR(EINVAL
);
2072 if (*channel_layout
> 0x7FF)
2073 return AVERROR(EINVAL
);
2074 ch_layout
= *channel_layout
;
2076 ch_layout
= av_get_default_channel_layout(channels
);
2078 s
->lfe_on
= !!(ch_layout
& AV_CH_LOW_FREQUENCY
);
2079 s
->channels
= channels
;
2080 s
->fbw_channels
= channels
- s
->lfe_on
;
2081 s
->lfe_channel
= s
->lfe_on
? s
->fbw_channels
+ 1 : -1;
2083 ch_layout
-= AV_CH_LOW_FREQUENCY
;
2085 switch (ch_layout
) {
2086 case AV_CH_LAYOUT_MONO
: s
->channel_mode
= AC3_CHMODE_MONO
; break;
2087 case AV_CH_LAYOUT_STEREO
: s
->channel_mode
= AC3_CHMODE_STEREO
; break;
2088 case AV_CH_LAYOUT_SURROUND
: s
->channel_mode
= AC3_CHMODE_3F
; break;
2089 case AV_CH_LAYOUT_2_1
: s
->channel_mode
= AC3_CHMODE_2F1R
; break;
2090 case AV_CH_LAYOUT_4POINT0
: s
->channel_mode
= AC3_CHMODE_3F1R
; break;
2091 case AV_CH_LAYOUT_QUAD
:
2092 case AV_CH_LAYOUT_2_2
: s
->channel_mode
= AC3_CHMODE_2F2R
; break;
2093 case AV_CH_LAYOUT_5POINT0
:
2094 case AV_CH_LAYOUT_5POINT0_BACK
: s
->channel_mode
= AC3_CHMODE_3F2R
; break;
2096 return AVERROR(EINVAL
);
2098 s
->has_center
= (s
->channel_mode
& 0x01) && s
->channel_mode
!= AC3_CHMODE_MONO
;
2099 s
->has_surround
= s
->channel_mode
& 0x04;
2101 s
->channel_map
= ff_ac3_enc_channel_map
[s
->channel_mode
][s
->lfe_on
];
2102 *channel_layout
= ch_layout
;
2104 *channel_layout
|= AV_CH_LOW_FREQUENCY
;
2110 static av_cold
int validate_options(AC3EncodeContext
*s
)
2112 AVCodecContext
*avctx
= s
->avctx
;
2115 /* validate channel layout */
2116 if (!avctx
->channel_layout
) {
2117 av_log(avctx
, AV_LOG_WARNING
, "No channel layout specified. The "
2118 "encoder will guess the layout, but it "
2119 "might be incorrect.\n");
2121 ret
= set_channel_info(s
, avctx
->channels
, &avctx
->channel_layout
);
2123 av_log(avctx
, AV_LOG_ERROR
, "invalid channel layout\n");
2127 /* validate sample rate */
2128 /* note: max_sr could be changed from 2 to 5 for E-AC-3 once we find a
2129 decoder that supports half sample rate so we can validate that
2130 the generated files are correct. */
2131 max_sr
= s
->eac3
? 2 : 8;
2132 for (i
= 0; i
<= max_sr
; i
++) {
2133 if ((ff_ac3_sample_rate_tab
[i
% 3] >> (i
/ 3)) == avctx
->sample_rate
)
2137 av_log(avctx
, AV_LOG_ERROR
, "invalid sample rate\n");
2138 return AVERROR(EINVAL
);
2140 s
->sample_rate
= avctx
->sample_rate
;
2141 s
->bit_alloc
.sr_shift
= i
/ 3;
2142 s
->bit_alloc
.sr_code
= i
% 3;
2143 s
->bitstream_id
= s
->eac3
? 16 : 8 + s
->bit_alloc
.sr_shift
;
2145 /* select a default bit rate if not set by the user */
2146 if (!avctx
->bit_rate
) {
2147 switch (s
->fbw_channels
) {
2148 case 1: avctx
->bit_rate
= 96000; break;
2149 case 2: avctx
->bit_rate
= 192000; break;
2150 case 3: avctx
->bit_rate
= 320000; break;
2151 case 4: avctx
->bit_rate
= 384000; break;
2152 case 5: avctx
->bit_rate
= 448000; break;
2156 /* validate bit rate */
2158 int max_br
, min_br
, wpf
, min_br_dist
, min_br_code
;
2159 int num_blks_code
, num_blocks
, frame_samples
;
2161 /* calculate min/max bitrate */
2162 /* TODO: More testing with 3 and 2 blocks. All E-AC-3 samples I've
2163 found use either 6 blocks or 1 block, even though 2 or 3 blocks
2164 would work as far as the bit rate is concerned. */
2165 for (num_blks_code
= 3; num_blks_code
>= 0; num_blks_code
--) {
2166 num_blocks
= ((int[]){ 1, 2, 3, 6 })[num_blks_code
];
2167 frame_samples
= AC3_BLOCK_SIZE
* num_blocks
;
2168 max_br
= 2048 * s
->sample_rate
/ frame_samples
* 16;
2169 min_br
= ((s
->sample_rate
+ (frame_samples
-1)) / frame_samples
) * 16;
2170 if (avctx
->bit_rate
<= max_br
)
2173 if (avctx
->bit_rate
< min_br
|| avctx
->bit_rate
> max_br
) {
2174 av_log(avctx
, AV_LOG_ERROR
, "invalid bit rate. must be %d to %d "
2175 "for this sample rate\n", min_br
, max_br
);
2176 return AVERROR(EINVAL
);
2178 s
->num_blks_code
= num_blks_code
;
2179 s
->num_blocks
= num_blocks
;
2181 /* calculate words-per-frame for the selected bitrate */
2182 wpf
= (avctx
->bit_rate
/ 16) * frame_samples
/ s
->sample_rate
;
2183 av_assert1(wpf
> 0 && wpf
<= 2048);
2185 /* find the closest AC-3 bitrate code to the selected bitrate.
2186 this is needed for lookup tables for bandwidth and coupling
2187 parameter selection */
2189 min_br_dist
= INT_MAX
;
2190 for (i
= 0; i
< 19; i
++) {
2191 int br_dist
= abs(ff_ac3_bitrate_tab
[i
] * 1000 - avctx
->bit_rate
);
2192 if (br_dist
< min_br_dist
) {
2193 min_br_dist
= br_dist
;
2198 /* make sure the minimum frame size is below the average frame size */
2199 s
->frame_size_code
= min_br_code
<< 1;
2200 while (wpf
> 1 && wpf
* s
->sample_rate
/ AC3_FRAME_SIZE
* 16 > avctx
->bit_rate
)
2202 s
->frame_size_min
= 2 * wpf
;
2204 int best_br
= 0, best_code
= 0, best_diff
= INT_MAX
;
2205 for (i
= 0; i
< 19; i
++) {
2206 int br
= (ff_ac3_bitrate_tab
[i
] >> s
->bit_alloc
.sr_shift
) * 1000;
2207 int diff
= abs(br
- avctx
->bit_rate
);
2208 if (diff
< best_diff
) {
2216 avctx
->bit_rate
= best_br
;
2217 s
->frame_size_code
= best_code
<< 1;
2218 s
->frame_size_min
= 2 * ff_ac3_frame_size_tab
[s
->frame_size_code
][s
->bit_alloc
.sr_code
];
2219 s
->num_blks_code
= 0x3;
2222 s
->bit_rate
= avctx
->bit_rate
;
2223 s
->frame_size
= s
->frame_size_min
;
2225 /* validate cutoff */
2226 if (avctx
->cutoff
< 0) {
2227 av_log(avctx
, AV_LOG_ERROR
, "invalid cutoff frequency\n");
2228 return AVERROR(EINVAL
);
2230 s
->cutoff
= avctx
->cutoff
;
2231 if (s
->cutoff
> (s
->sample_rate
>> 1))
2232 s
->cutoff
= s
->sample_rate
>> 1;
2234 ret
= ff_ac3_validate_metadata(s
);
2238 s
->rematrixing_enabled
= s
->options
.stereo_rematrixing
&&
2239 (s
->channel_mode
== AC3_CHMODE_STEREO
);
2241 s
->cpl_enabled
= s
->options
.channel_coupling
&&
2242 s
->channel_mode
>= AC3_CHMODE_STEREO
;
2249 * Set bandwidth for all channels.
2250 * The user can optionally supply a cutoff frequency. Otherwise an appropriate
2251 * default value will be used.
2253 static av_cold
void set_bandwidth(AC3EncodeContext
*s
)
2255 int blk
, ch
, cpl_start
;
2258 /* calculate bandwidth based on user-specified cutoff frequency */
2260 fbw_coeffs
= s
->cutoff
* 2 * AC3_MAX_COEFS
/ s
->sample_rate
;
2261 s
->bandwidth_code
= av_clip((fbw_coeffs
- 73) / 3, 0, 60);
2263 /* use default bandwidth setting */
2264 s
->bandwidth_code
= ac3_bandwidth_tab
[s
->fbw_channels
-1][s
->bit_alloc
.sr_code
][s
->frame_size_code
/2];
2267 /* set number of coefficients for each channel */
2268 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
2269 s
->start_freq
[ch
] = 0;
2270 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
2271 s
->blocks
[blk
].end_freq
[ch
] = s
->bandwidth_code
* 3 + 73;
2273 /* LFE channel always has 7 coefs */
2275 s
->start_freq
[s
->lfe_channel
] = 0;
2276 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
2277 s
->blocks
[blk
].end_freq
[ch
] = 7;
2280 /* initialize coupling strategy */
2281 if (s
->cpl_enabled
) {
2282 if (s
->options
.cpl_start
!= AC3ENC_OPT_AUTO
) {
2283 cpl_start
= s
->options
.cpl_start
;
2285 cpl_start
= ac3_coupling_start_tab
[s
->channel_mode
-2][s
->bit_alloc
.sr_code
][s
->frame_size_code
/2];
2286 if (cpl_start
< 0) {
2287 if (s
->options
.channel_coupling
== AC3ENC_OPT_AUTO
)
2294 if (s
->cpl_enabled
) {
2295 int i
, cpl_start_band
, cpl_end_band
;
2296 uint8_t *cpl_band_sizes
= s
->cpl_band_sizes
;
2298 cpl_end_band
= s
->bandwidth_code
/ 4 + 3;
2299 cpl_start_band
= av_clip(cpl_start
, 0, FFMIN(cpl_end_band
-1, 15));
2301 s
->num_cpl_subbands
= cpl_end_band
- cpl_start_band
;
2303 s
->num_cpl_bands
= 1;
2304 *cpl_band_sizes
= 12;
2305 for (i
= cpl_start_band
+ 1; i
< cpl_end_band
; i
++) {
2306 if (ff_eac3_default_cpl_band_struct
[i
]) {
2307 *cpl_band_sizes
+= 12;
2311 *cpl_band_sizes
= 12;
2315 s
->start_freq
[CPL_CH
] = cpl_start_band
* 12 + 37;
2316 s
->cpl_end_freq
= cpl_end_band
* 12 + 37;
2317 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
2318 s
->blocks
[blk
].end_freq
[CPL_CH
] = s
->cpl_end_freq
;
2323 static av_cold
int allocate_buffers(AC3EncodeContext
*s
)
2325 AVCodecContext
*avctx
= s
->avctx
;
2327 int channels
= s
->channels
+ 1; /* includes coupling channel */
2328 int channel_blocks
= channels
* s
->num_blocks
;
2329 int total_coefs
= AC3_MAX_COEFS
* channel_blocks
;
2331 if (s
->allocate_sample_buffers(s
))
2334 FF_ALLOC_OR_GOTO(avctx
, s
->bap_buffer
, total_coefs
*
2335 sizeof(*s
->bap_buffer
), alloc_fail
);
2336 FF_ALLOC_OR_GOTO(avctx
, s
->bap1_buffer
, total_coefs
*
2337 sizeof(*s
->bap1_buffer
), alloc_fail
);
2338 FF_ALLOCZ_OR_GOTO(avctx
, s
->mdct_coef_buffer
, total_coefs
*
2339 sizeof(*s
->mdct_coef_buffer
), alloc_fail
);
2340 FF_ALLOC_OR_GOTO(avctx
, s
->exp_buffer
, total_coefs
*
2341 sizeof(*s
->exp_buffer
), alloc_fail
);
2342 FF_ALLOC_OR_GOTO(avctx
, s
->grouped_exp_buffer
, channel_blocks
* 128 *
2343 sizeof(*s
->grouped_exp_buffer
), alloc_fail
);
2344 FF_ALLOC_OR_GOTO(avctx
, s
->psd_buffer
, total_coefs
*
2345 sizeof(*s
->psd_buffer
), alloc_fail
);
2346 FF_ALLOC_OR_GOTO(avctx
, s
->band_psd_buffer
, channel_blocks
* 64 *
2347 sizeof(*s
->band_psd_buffer
), alloc_fail
);
2348 FF_ALLOC_OR_GOTO(avctx
, s
->mask_buffer
, channel_blocks
* 64 *
2349 sizeof(*s
->mask_buffer
), alloc_fail
);
2350 FF_ALLOC_OR_GOTO(avctx
, s
->qmant_buffer
, total_coefs
*
2351 sizeof(*s
->qmant_buffer
), alloc_fail
);
2352 if (s
->cpl_enabled
) {
2353 FF_ALLOC_OR_GOTO(avctx
, s
->cpl_coord_exp_buffer
, channel_blocks
* 16 *
2354 sizeof(*s
->cpl_coord_exp_buffer
), alloc_fail
);
2355 FF_ALLOC_OR_GOTO(avctx
, s
->cpl_coord_mant_buffer
, channel_blocks
* 16 *
2356 sizeof(*s
->cpl_coord_mant_buffer
), alloc_fail
);
2358 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
2359 AC3Block
*block
= &s
->blocks
[blk
];
2360 FF_ALLOCZ_OR_GOTO(avctx
, block
->mdct_coef
, channels
* sizeof(*block
->mdct_coef
),
2362 FF_ALLOCZ_OR_GOTO(avctx
, block
->exp
, channels
* sizeof(*block
->exp
),
2364 FF_ALLOCZ_OR_GOTO(avctx
, block
->grouped_exp
, channels
* sizeof(*block
->grouped_exp
),
2366 FF_ALLOCZ_OR_GOTO(avctx
, block
->psd
, channels
* sizeof(*block
->psd
),
2368 FF_ALLOCZ_OR_GOTO(avctx
, block
->band_psd
, channels
* sizeof(*block
->band_psd
),
2370 FF_ALLOCZ_OR_GOTO(avctx
, block
->mask
, channels
* sizeof(*block
->mask
),
2372 FF_ALLOCZ_OR_GOTO(avctx
, block
->qmant
, channels
* sizeof(*block
->qmant
),
2374 if (s
->cpl_enabled
) {
2375 FF_ALLOCZ_OR_GOTO(avctx
, block
->cpl_coord_exp
, channels
* sizeof(*block
->cpl_coord_exp
),
2377 FF_ALLOCZ_OR_GOTO(avctx
, block
->cpl_coord_mant
, channels
* sizeof(*block
->cpl_coord_mant
),
2381 for (ch
= 0; ch
< channels
; ch
++) {
2382 /* arrangement: block, channel, coeff */
2383 block
->grouped_exp
[ch
] = &s
->grouped_exp_buffer
[128 * (blk
* channels
+ ch
)];
2384 block
->psd
[ch
] = &s
->psd_buffer
[AC3_MAX_COEFS
* (blk
* channels
+ ch
)];
2385 block
->band_psd
[ch
] = &s
->band_psd_buffer
[64 * (blk
* channels
+ ch
)];
2386 block
->mask
[ch
] = &s
->mask_buffer
[64 * (blk
* channels
+ ch
)];
2387 block
->qmant
[ch
] = &s
->qmant_buffer
[AC3_MAX_COEFS
* (blk
* channels
+ ch
)];
2388 if (s
->cpl_enabled
) {
2389 block
->cpl_coord_exp
[ch
] = &s
->cpl_coord_exp_buffer
[16 * (blk
* channels
+ ch
)];
2390 block
->cpl_coord_mant
[ch
] = &s
->cpl_coord_mant_buffer
[16 * (blk
* channels
+ ch
)];
2393 /* arrangement: channel, block, coeff */
2394 block
->exp
[ch
] = &s
->exp_buffer
[AC3_MAX_COEFS
* (s
->num_blocks
* ch
+ blk
)];
2395 block
->mdct_coef
[ch
] = &s
->mdct_coef_buffer
[AC3_MAX_COEFS
* (s
->num_blocks
* ch
+ blk
)];
2399 if (!s
->fixed_point
) {
2400 FF_ALLOCZ_OR_GOTO(avctx
, s
->fixed_coef_buffer
, total_coefs
*
2401 sizeof(*s
->fixed_coef_buffer
), alloc_fail
);
2402 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
2403 AC3Block
*block
= &s
->blocks
[blk
];
2404 FF_ALLOCZ_OR_GOTO(avctx
, block
->fixed_coef
, channels
*
2405 sizeof(*block
->fixed_coef
), alloc_fail
);
2406 for (ch
= 0; ch
< channels
; ch
++)
2407 block
->fixed_coef
[ch
] = &s
->fixed_coef_buffer
[AC3_MAX_COEFS
* (s
->num_blocks
* ch
+ blk
)];
2410 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
2411 AC3Block
*block
= &s
->blocks
[blk
];
2412 FF_ALLOCZ_OR_GOTO(avctx
, block
->fixed_coef
, channels
*
2413 sizeof(*block
->fixed_coef
), alloc_fail
);
2414 for (ch
= 0; ch
< channels
; ch
++)
2415 block
->fixed_coef
[ch
] = (int32_t *)block
->mdct_coef
[ch
];
2421 return AVERROR(ENOMEM
);
2425 av_cold
int ff_ac3_encode_init(AVCodecContext
*avctx
)
2427 AC3EncodeContext
*s
= avctx
->priv_data
;
2428 int ret
, frame_size_58
;
2432 s
->eac3
= avctx
->codec_id
== AV_CODEC_ID_EAC3
;
2434 ff_ac3_common_init();
2436 ret
= validate_options(s
);
2440 avctx
->frame_size
= AC3_BLOCK_SIZE
* s
->num_blocks
;
2441 avctx
->delay
= AC3_BLOCK_SIZE
;
2443 s
->bitstream_mode
= avctx
->audio_service_type
;
2444 if (s
->bitstream_mode
== AV_AUDIO_SERVICE_TYPE_KARAOKE
)
2445 s
->bitstream_mode
= 0x7;
2447 s
->bits_written
= 0;
2448 s
->samples_written
= 0;
2450 /* calculate crc_inv for both possible frame sizes */
2451 frame_size_58
= (( s
->frame_size
>> 2) + ( s
->frame_size
>> 4)) << 1;
2452 s
->crc_inv
[0] = pow_poly((CRC16_POLY
>> 1), (8 * frame_size_58
) - 16, CRC16_POLY
);
2453 if (s
->bit_alloc
.sr_code
== 1) {
2454 frame_size_58
= (((s
->frame_size
+2) >> 2) + ((s
->frame_size
+2) >> 4)) << 1;
2455 s
->crc_inv
[1] = pow_poly((CRC16_POLY
>> 1), (8 * frame_size_58
) - 16, CRC16_POLY
);
2458 /* set function pointers */
2459 if (CONFIG_AC3_FIXED_ENCODER
&& s
->fixed_point
) {
2460 s
->mdct_end
= ff_ac3_fixed_mdct_end
;
2461 s
->mdct_init
= ff_ac3_fixed_mdct_init
;
2462 s
->allocate_sample_buffers
= ff_ac3_fixed_allocate_sample_buffers
;
2463 } else if (CONFIG_AC3_ENCODER
|| CONFIG_EAC3_ENCODER
) {
2464 s
->mdct_end
= ff_ac3_float_mdct_end
;
2465 s
->mdct_init
= ff_ac3_float_mdct_init
;
2466 s
->allocate_sample_buffers
= ff_ac3_float_allocate_sample_buffers
;
2468 if (CONFIG_EAC3_ENCODER
&& s
->eac3
)
2469 s
->output_frame_header
= ff_eac3_output_frame_header
;
2471 s
->output_frame_header
= ac3_output_frame_header
;
2479 ret
= s
->mdct_init(s
);
2483 ret
= allocate_buffers(s
);
2487 #if FF_API_OLD_ENCODE_AUDIO
2488 avctx
->coded_frame
= avcodec_alloc_frame();
2489 if (!avctx
->coded_frame
) {
2490 ret
= AVERROR(ENOMEM
);
2495 ff_dsputil_init(&s
->dsp
, avctx
);
2496 avpriv_float_dsp_init(&s
->fdsp
, avctx
->flags
& CODEC_FLAG_BITEXACT
);
2497 ff_ac3dsp_init(&s
->ac3dsp
, avctx
->flags
& CODEC_FLAG_BITEXACT
);
2503 ff_ac3_encode_close(avctx
);