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 FFmpeg.
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.
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.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * The simplest AC-3 encoder.
31 #include "libavutil/attributes.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/channel_layout.h"
35 #include "libavutil/crc.h"
36 #include "libavutil/internal.h"
37 #include "libavutil/opt.h"
48 typedef struct AC3Mant
{
49 int16_t *qmant1_ptr
, *qmant2_ptr
, *qmant4_ptr
; ///< mantissa pointers for bap=1,2,4
50 int mant1_cnt
, mant2_cnt
, mant4_cnt
; ///< mantissa counts for bap=1,2,4
53 #define CMIXLEV_NUM_OPTIONS 3
54 static const float cmixlev_options
[CMIXLEV_NUM_OPTIONS
] = {
55 LEVEL_MINUS_3DB
, LEVEL_MINUS_4POINT5DB
, LEVEL_MINUS_6DB
58 #define SURMIXLEV_NUM_OPTIONS 3
59 static const float surmixlev_options
[SURMIXLEV_NUM_OPTIONS
] = {
60 LEVEL_MINUS_3DB
, LEVEL_MINUS_6DB
, LEVEL_ZERO
63 #define EXTMIXLEV_NUM_OPTIONS 8
64 static const float extmixlev_options
[EXTMIXLEV_NUM_OPTIONS
] = {
65 LEVEL_PLUS_3DB
, LEVEL_PLUS_1POINT5DB
, LEVEL_ONE
, LEVEL_MINUS_4POINT5DB
,
66 LEVEL_MINUS_3DB
, LEVEL_MINUS_4POINT5DB
, LEVEL_MINUS_6DB
, LEVEL_ZERO
71 * LUT for number of exponent groups.
72 * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
74 static uint8_t exponent_group_tab
[2][3][256];
78 * List of supported channel layouts.
80 const uint64_t ff_ac3_channel_layouts
[19] = {
84 AV_CH_LAYOUT_SURROUND
,
89 AV_CH_LAYOUT_5POINT0_BACK
,
90 (AV_CH_LAYOUT_MONO
| AV_CH_LOW_FREQUENCY
),
91 (AV_CH_LAYOUT_STEREO
| AV_CH_LOW_FREQUENCY
),
92 (AV_CH_LAYOUT_2_1
| AV_CH_LOW_FREQUENCY
),
93 (AV_CH_LAYOUT_SURROUND
| AV_CH_LOW_FREQUENCY
),
94 (AV_CH_LAYOUT_2_2
| AV_CH_LOW_FREQUENCY
),
95 (AV_CH_LAYOUT_QUAD
| AV_CH_LOW_FREQUENCY
),
96 (AV_CH_LAYOUT_4POINT0
| AV_CH_LOW_FREQUENCY
),
98 AV_CH_LAYOUT_5POINT1_BACK
,
104 * LUT to select the bandwidth code based on the bit rate, sample rate, and
105 * number of full-bandwidth channels.
106 * bandwidth_tab[fbw_channels-1][sample rate code][bit rate code]
108 static const uint8_t ac3_bandwidth_tab
[5][3][19] = {
109 // 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
111 { { 0, 0, 0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
112 { 0, 0, 0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
113 { 0, 0, 0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
115 { { 0, 0, 0, 0, 0, 0, 0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
116 { 0, 0, 0, 0, 0, 0, 4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
117 { 0, 0, 0, 0, 0, 0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
119 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 },
120 { 0, 0, 0, 0, 0, 0, 0, 0, 4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 },
121 { 0, 0, 0, 0, 0, 0, 0, 0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } },
123 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 32, 48, 48, 48, 48, 48, 48 },
124 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 28, 36, 56, 56, 56, 56, 56, 56 },
125 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } },
127 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 20, 32, 40, 48, 48, 48, 48 },
128 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 36, 44, 56, 56, 56, 56 },
129 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 44, 60, 60, 60, 60, 60, 60 } }
134 * LUT to select the coupling start band based on the bit rate, sample rate, and
135 * number of full-bandwidth channels. -1 = coupling off
136 * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]
138 * TODO: more testing for optimal parameters.
139 * multi-channel tests at 44.1kHz and 32kHz.
141 static const int8_t ac3_coupling_start_tab
[6][3][19] = {
142 // 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
145 { { 0, 0, 0, 0, 0, 0, 0, 1, 1, 7, 8, 11, 12, -1, -1, -1, -1, -1, -1 },
146 { 0, 0, 0, 0, 0, 0, 1, 3, 5, 7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },
147 { 0, 0, 0, 0, 1, 2, 2, 9, 13, 15, -1, -1, -1, -1, -1, -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 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
152 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
157 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
160 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
161 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
162 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
165 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
166 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
167 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
170 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
171 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
172 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
177 * Adjust the frame size to make the average bit rate match the target bit rate.
178 * This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3.
180 * @param s AC-3 encoder private context
182 void ff_ac3_adjust_frame_size(AC3EncodeContext
*s
)
184 while (s
->bits_written
>= s
->bit_rate
&& s
->samples_written
>= s
->sample_rate
) {
185 s
->bits_written
-= s
->bit_rate
;
186 s
->samples_written
-= s
->sample_rate
;
188 s
->frame_size
= s
->frame_size_min
+
189 2 * (s
->bits_written
* s
->sample_rate
< s
->samples_written
* s
->bit_rate
);
190 s
->bits_written
+= s
->frame_size
* 8;
191 s
->samples_written
+= AC3_BLOCK_SIZE
* s
->num_blocks
;
196 * Set the initial coupling strategy parameters prior to coupling analysis.
198 * @param s AC-3 encoder private context
200 void ff_ac3_compute_coupling_strategy(AC3EncodeContext
*s
)
206 /* set coupling use flags for each block/channel */
207 /* TODO: turn coupling on/off and adjust start band based on bit usage */
208 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
209 AC3Block
*block
= &s
->blocks
[blk
];
210 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
211 block
->channel_in_cpl
[ch
] = s
->cpl_on
;
214 /* enable coupling for each block if at least 2 channels have coupling
215 enabled for that block */
218 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
219 AC3Block
*block
= &s
->blocks
[blk
];
220 block
->num_cpl_channels
= 0;
221 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
222 block
->num_cpl_channels
+= block
->channel_in_cpl
[ch
];
223 block
->cpl_in_use
= block
->num_cpl_channels
> 1;
224 num_cpl_blocks
+= block
->cpl_in_use
;
225 if (!block
->cpl_in_use
) {
226 block
->num_cpl_channels
= 0;
227 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
228 block
->channel_in_cpl
[ch
] = 0;
231 block
->new_cpl_strategy
= !blk
;
233 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
234 if (block
->channel_in_cpl
[ch
] != s
->blocks
[blk
-1].channel_in_cpl
[ch
]) {
235 block
->new_cpl_strategy
= 1;
240 block
->new_cpl_leak
= block
->new_cpl_strategy
;
242 if (!blk
|| (block
->cpl_in_use
&& !got_cpl_snr
)) {
243 block
->new_snr_offsets
= 1;
244 if (block
->cpl_in_use
)
247 block
->new_snr_offsets
= 0;
253 /* set bandwidth for each channel */
254 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
255 AC3Block
*block
= &s
->blocks
[blk
];
256 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
257 if (block
->channel_in_cpl
[ch
])
258 block
->end_freq
[ch
] = s
->start_freq
[CPL_CH
];
260 block
->end_freq
[ch
] = s
->bandwidth_code
* 3 + 73;
267 * Apply stereo rematrixing to coefficients based on rematrixing flags.
269 * @param s AC-3 encoder private context
271 void ff_ac3_apply_rematrixing(AC3EncodeContext
*s
)
276 uint8_t *flags
= NULL
;
278 if (!s
->rematrixing_enabled
)
281 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
282 AC3Block
*block
= &s
->blocks
[blk
];
283 if (block
->new_rematrixing_strategy
)
284 flags
= block
->rematrixing_flags
;
285 nb_coefs
= FFMIN(block
->end_freq
[1], block
->end_freq
[2]);
286 for (bnd
= 0; bnd
< block
->num_rematrixing_bands
; bnd
++) {
288 start
= ff_ac3_rematrix_band_tab
[bnd
];
289 end
= FFMIN(nb_coefs
, ff_ac3_rematrix_band_tab
[bnd
+1]);
290 for (i
= start
; i
< end
; i
++) {
291 int32_t lt
= block
->fixed_coef
[1][i
];
292 int32_t rt
= block
->fixed_coef
[2][i
];
293 block
->fixed_coef
[1][i
] = (lt
+ rt
) >> 1;
294 block
->fixed_coef
[2][i
] = (lt
- rt
) >> 1;
303 * Initialize exponent tables.
305 static av_cold
void exponent_init(AC3EncodeContext
*s
)
307 int expstr
, i
, grpsize
;
309 for (expstr
= EXP_D15
-1; expstr
<= EXP_D45
-1; expstr
++) {
310 grpsize
= 3 << expstr
;
311 for (i
= 12; i
< 256; i
++) {
312 exponent_group_tab
[0][expstr
][i
] = (i
+ grpsize
- 4) / grpsize
;
313 exponent_group_tab
[1][expstr
][i
] = (i
) / grpsize
;
317 exponent_group_tab
[0][0][7] = 2;
319 if (CONFIG_EAC3_ENCODER
&& s
->eac3
)
320 ff_eac3_exponent_init();
325 * Extract exponents from the MDCT coefficients.
327 static void extract_exponents(AC3EncodeContext
*s
)
330 int chan_size
= AC3_MAX_COEFS
* s
->num_blocks
* (s
->channels
- ch
+ 1);
331 AC3Block
*block
= &s
->blocks
[0];
333 s
->ac3dsp
.extract_exponents(block
->exp
[ch
], block
->fixed_coef
[ch
], chan_size
);
338 * Exponent Difference Threshold.
339 * New exponents are sent if their SAD exceed this number.
341 #define EXP_DIFF_THRESHOLD 500
344 * Table used to select exponent strategy based on exponent reuse block interval.
346 static const uint8_t exp_strategy_reuse_tab
[4][6] = {
347 { EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
},
348 { EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
},
349 { EXP_D25
, EXP_D25
, EXP_D15
, EXP_D15
, EXP_D15
, EXP_D15
},
350 { EXP_D45
, EXP_D25
, EXP_D25
, EXP_D15
, EXP_D15
, EXP_D15
}
354 * Calculate exponent strategies for all channels.
355 * Array arrangement is reversed to simplify the per-channel calculation.
357 static void compute_exp_strategy(AC3EncodeContext
*s
)
361 for (ch
= !s
->cpl_on
; ch
<= s
->fbw_channels
; ch
++) {
362 uint8_t *exp_strategy
= s
->exp_strategy
[ch
];
363 uint8_t *exp
= s
->blocks
[0].exp
[ch
];
366 /* estimate if the exponent variation & decide if they should be
367 reused in the next frame */
368 exp_strategy
[0] = EXP_NEW
;
369 exp
+= AC3_MAX_COEFS
;
370 for (blk
= 1; blk
< s
->num_blocks
; blk
++, exp
+= AC3_MAX_COEFS
) {
372 if (!s
->blocks
[blk
-1].cpl_in_use
) {
373 exp_strategy
[blk
] = EXP_NEW
;
375 } else if (!s
->blocks
[blk
].cpl_in_use
) {
376 exp_strategy
[blk
] = EXP_REUSE
;
379 } else if (s
->blocks
[blk
].channel_in_cpl
[ch
] != s
->blocks
[blk
-1].channel_in_cpl
[ch
]) {
380 exp_strategy
[blk
] = EXP_NEW
;
383 exp_diff
= s
->mecc
.sad
[0](NULL
, exp
, exp
- AC3_MAX_COEFS
, 16, 16);
384 exp_strategy
[blk
] = EXP_REUSE
;
385 if (ch
== CPL_CH
&& exp_diff
> (EXP_DIFF_THRESHOLD
* (s
->blocks
[blk
].end_freq
[ch
] - s
->start_freq
[ch
]) / AC3_MAX_COEFS
))
386 exp_strategy
[blk
] = EXP_NEW
;
387 else if (ch
> CPL_CH
&& exp_diff
> EXP_DIFF_THRESHOLD
)
388 exp_strategy
[blk
] = EXP_NEW
;
391 /* now select the encoding strategy type : if exponents are often
392 recoded, we use a coarse encoding */
394 while (blk
< s
->num_blocks
) {
396 while (blk1
< s
->num_blocks
&& exp_strategy
[blk1
] == EXP_REUSE
)
398 exp_strategy
[blk
] = exp_strategy_reuse_tab
[s
->num_blks_code
][blk1
-blk
-1];
404 s
->exp_strategy
[ch
][0] = EXP_D15
;
405 for (blk
= 1; blk
< s
->num_blocks
; blk
++)
406 s
->exp_strategy
[ch
][blk
] = EXP_REUSE
;
409 /* for E-AC-3, determine frame exponent strategy */
410 if (CONFIG_EAC3_ENCODER
&& s
->eac3
)
411 ff_eac3_get_frame_exp_strategy(s
);
416 * Update the exponents so that they are the ones the decoder will decode.
418 * @param[in,out] exp array of exponents for 1 block in 1 channel
419 * @param nb_exps number of exponents in active bandwidth
420 * @param exp_strategy exponent strategy for the block
421 * @param cpl indicates if the block is in the coupling channel
423 static void encode_exponents_blk_ch(uint8_t *exp
, int nb_exps
, int exp_strategy
,
428 nb_groups
= exponent_group_tab
[cpl
][exp_strategy
-1][nb_exps
] * 3;
430 /* for each group, compute the minimum exponent */
431 switch(exp_strategy
) {
433 for (i
= 1, k
= 1-cpl
; i
<= nb_groups
; i
++) {
434 uint8_t exp_min
= exp
[k
];
435 if (exp
[k
+1] < exp_min
)
437 exp
[i
-cpl
] = exp_min
;
442 for (i
= 1, k
= 1-cpl
; i
<= nb_groups
; i
++) {
443 uint8_t exp_min
= exp
[k
];
444 if (exp
[k
+1] < exp_min
)
446 if (exp
[k
+2] < exp_min
)
448 if (exp
[k
+3] < exp_min
)
450 exp
[i
-cpl
] = exp_min
;
456 /* constraint for DC exponent */
457 if (!cpl
&& exp
[0] > 15)
460 /* decrease the delta between each groups to within 2 so that they can be
461 differentially encoded */
462 for (i
= 1; i
<= nb_groups
; i
++)
463 exp
[i
] = FFMIN(exp
[i
], exp
[i
-1] + 2);
466 exp
[i
] = FFMIN(exp
[i
], exp
[i
+1] + 2);
469 exp
[-1] = exp
[0] & ~1;
471 /* now we have the exponent values the decoder will see */
472 switch (exp_strategy
) {
474 for (i
= nb_groups
, k
= (nb_groups
* 2)-cpl
; i
> 0; i
--) {
475 uint8_t exp1
= exp
[i
-cpl
];
481 for (i
= nb_groups
, k
= (nb_groups
* 4)-cpl
; i
> 0; i
--) {
482 exp
[k
] = exp
[k
-1] = exp
[k
-2] = exp
[k
-3] = exp
[i
-cpl
];
491 * Encode exponents from original extracted form to what the decoder will see.
492 * This copies and groups exponents based on exponent strategy and reduces
493 * deltas between adjacent exponent groups so that they can be differentially
496 static void encode_exponents(AC3EncodeContext
*s
)
498 int blk
, blk1
, ch
, cpl
;
499 uint8_t *exp
, *exp_strategy
;
500 int nb_coefs
, num_reuse_blocks
;
502 for (ch
= !s
->cpl_on
; ch
<= s
->channels
; ch
++) {
503 exp
= s
->blocks
[0].exp
[ch
] + s
->start_freq
[ch
];
504 exp_strategy
= s
->exp_strategy
[ch
];
506 cpl
= (ch
== CPL_CH
);
508 while (blk
< s
->num_blocks
) {
509 AC3Block
*block
= &s
->blocks
[blk
];
510 if (cpl
&& !block
->cpl_in_use
) {
511 exp
+= AC3_MAX_COEFS
;
515 nb_coefs
= block
->end_freq
[ch
] - s
->start_freq
[ch
];
518 /* count the number of EXP_REUSE blocks after the current block
519 and set exponent reference block numbers */
520 s
->exp_ref_block
[ch
][blk
] = blk
;
521 while (blk1
< s
->num_blocks
&& exp_strategy
[blk1
] == EXP_REUSE
) {
522 s
->exp_ref_block
[ch
][blk1
] = blk
;
525 num_reuse_blocks
= blk1
- blk
- 1;
527 /* for the EXP_REUSE case we select the min of the exponents */
528 s
->ac3dsp
.ac3_exponent_min(exp
-s
->start_freq
[ch
], num_reuse_blocks
,
531 encode_exponents_blk_ch(exp
, nb_coefs
, exp_strategy
[blk
], cpl
);
533 exp
+= AC3_MAX_COEFS
* (num_reuse_blocks
+ 1);
538 /* reference block numbers have been changed, so reset ref_bap_set */
544 * Count exponent bits based on bandwidth, coupling, and exponent strategies.
546 static int count_exponent_bits(AC3EncodeContext
*s
)
549 int nb_groups
, bit_count
;
552 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
553 AC3Block
*block
= &s
->blocks
[blk
];
554 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
555 int exp_strategy
= s
->exp_strategy
[ch
][blk
];
556 int cpl
= (ch
== CPL_CH
);
557 int nb_coefs
= block
->end_freq
[ch
] - s
->start_freq
[ch
];
559 if (exp_strategy
== EXP_REUSE
)
562 nb_groups
= exponent_group_tab
[cpl
][exp_strategy
-1][nb_coefs
];
563 bit_count
+= 4 + (nb_groups
* 7);
573 * 3 delta-encoded exponents are in each 7-bit group. The number of groups
574 * varies depending on exponent strategy and bandwidth.
576 * @param s AC-3 encoder private context
578 void ff_ac3_group_exponents(AC3EncodeContext
*s
)
581 int group_size
, nb_groups
;
583 int delta0
, delta1
, delta2
;
586 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
587 AC3Block
*block
= &s
->blocks
[blk
];
588 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
589 int exp_strategy
= s
->exp_strategy
[ch
][blk
];
590 if (exp_strategy
== EXP_REUSE
)
592 cpl
= (ch
== CPL_CH
);
593 group_size
= exp_strategy
+ (exp_strategy
== EXP_D45
);
594 nb_groups
= exponent_group_tab
[cpl
][exp_strategy
-1][block
->end_freq
[ch
]-s
->start_freq
[ch
]];
595 p
= block
->exp
[ch
] + s
->start_freq
[ch
] - cpl
;
599 block
->grouped_exp
[ch
][0] = exp1
;
601 /* remaining exponents are delta encoded */
602 for (i
= 1; i
<= nb_groups
; i
++) {
603 /* merge three delta in one code */
607 delta0
= exp1
- exp0
+ 2;
608 av_assert2(delta0
>= 0 && delta0
<= 4);
613 delta1
= exp1
- exp0
+ 2;
614 av_assert2(delta1
>= 0 && delta1
<= 4);
619 delta2
= exp1
- exp0
+ 2;
620 av_assert2(delta2
>= 0 && delta2
<= 4);
622 block
->grouped_exp
[ch
][i
] = ((delta0
* 5 + delta1
) * 5) + delta2
;
630 * Calculate final exponents from the supplied MDCT coefficients and exponent shift.
631 * Extract exponents from MDCT coefficients, calculate exponent strategies,
632 * and encode final exponents.
634 * @param s AC-3 encoder private context
636 void ff_ac3_process_exponents(AC3EncodeContext
*s
)
638 extract_exponents(s
);
640 compute_exp_strategy(s
);
649 * Count frame bits that are based solely on fixed parameters.
650 * This only has to be run once when the encoder is initialized.
652 static void count_frame_bits_fixed(AC3EncodeContext
*s
)
654 static const int frame_bits_inc
[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
659 * no dynamic range codes
660 * bit allocation parameters do not change between blocks
661 * no delta bit allocation
668 frame_bits
= 16; /* sync info */
670 /* bitstream info header */
673 if (s
->num_blocks
!= 0x6)
676 /* audio frame header */
677 if (s
->num_blocks
== 6)
680 /* exponent strategy */
681 if (s
->use_frame_exp_strategy
)
682 frame_bits
+= 5 * s
->fbw_channels
;
684 frame_bits
+= s
->num_blocks
* 2 * s
->fbw_channels
;
686 frame_bits
+= s
->num_blocks
;
687 /* converter exponent strategy */
688 if (s
->num_blks_code
!= 0x3)
691 frame_bits
+= s
->fbw_channels
* 5;
694 /* block start info */
695 if (s
->num_blocks
!= 1)
699 frame_bits
+= frame_bits_inc
[s
->channel_mode
];
703 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
705 /* block switch flags */
706 frame_bits
+= s
->fbw_channels
;
709 frame_bits
+= s
->fbw_channels
;
715 /* spectral extension */
720 /* exponent strategy */
721 frame_bits
+= 2 * s
->fbw_channels
;
725 /* bit allocation params */
728 frame_bits
+= 2 + 2 + 2 + 2 + 3;
731 /* converter snr offset */
736 /* delta bit allocation */
748 frame_bits
+= 1 + 16;
750 s
->frame_bits_fixed
= frame_bits
;
755 * Initialize bit allocation.
756 * Set default parameter codes and calculate parameter values.
758 static av_cold
void bit_alloc_init(AC3EncodeContext
*s
)
762 /* init default parameters */
763 s
->slow_decay_code
= 2;
764 s
->fast_decay_code
= 1;
765 s
->slow_gain_code
= 1;
766 s
->db_per_bit_code
= s
->eac3
? 2 : 3;
768 for (ch
= 0; ch
<= s
->channels
; ch
++)
769 s
->fast_gain_code
[ch
] = 4;
771 /* initial snr offset */
772 s
->coarse_snr_offset
= 40;
774 /* compute real values */
775 /* currently none of these values change during encoding, so we can just
776 set them once at initialization */
777 s
->bit_alloc
.slow_decay
= ff_ac3_slow_decay_tab
[s
->slow_decay_code
] >> s
->bit_alloc
.sr_shift
;
778 s
->bit_alloc
.fast_decay
= ff_ac3_fast_decay_tab
[s
->fast_decay_code
] >> s
->bit_alloc
.sr_shift
;
779 s
->bit_alloc
.slow_gain
= ff_ac3_slow_gain_tab
[s
->slow_gain_code
];
780 s
->bit_alloc
.db_per_bit
= ff_ac3_db_per_bit_tab
[s
->db_per_bit_code
];
781 s
->bit_alloc
.floor
= ff_ac3_floor_tab
[s
->floor_code
];
782 s
->bit_alloc
.cpl_fast_leak
= 0;
783 s
->bit_alloc
.cpl_slow_leak
= 0;
785 count_frame_bits_fixed(s
);
790 * Count the bits used to encode the frame, minus exponents and mantissas.
791 * Bits based on fixed parameters have already been counted, so now we just
792 * have to add the bits based on parameters that change during encoding.
794 static void count_frame_bits(AC3EncodeContext
*s
)
796 AC3EncOptions
*opt
= &s
->options
;
802 if (opt
->eac3_mixing_metadata
) {
803 if (s
->channel_mode
> AC3_CHMODE_STEREO
)
809 frame_bits
+= s
->lfe_on
;
810 frame_bits
+= 1 + 1 + 2;
811 if (s
->channel_mode
< AC3_CHMODE_STEREO
)
815 if (opt
->eac3_info_metadata
) {
816 frame_bits
+= 3 + 1 + 1;
817 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
819 if (s
->channel_mode
>= AC3_CHMODE_2F2R
)
822 if (opt
->audio_production_info
)
823 frame_bits
+= 5 + 2 + 1;
827 if (s
->channel_mode
> AC3_CHMODE_MONO
) {
829 for (blk
= 1; blk
< s
->num_blocks
; blk
++) {
830 AC3Block
*block
= &s
->blocks
[blk
];
832 if (block
->new_cpl_strategy
)
836 /* coupling exponent strategy */
838 if (s
->use_frame_exp_strategy
) {
839 frame_bits
+= 5 * s
->cpl_on
;
841 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
842 frame_bits
+= 2 * s
->blocks
[blk
].cpl_in_use
;
846 if (opt
->audio_production_info
)
848 if (s
->bitstream_id
== 6) {
849 if (opt
->extended_bsi_1
)
851 if (opt
->extended_bsi_2
)
857 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
858 AC3Block
*block
= &s
->blocks
[blk
];
860 /* coupling strategy */
863 if (block
->new_cpl_strategy
) {
866 if (block
->cpl_in_use
) {
869 if (!s
->eac3
|| s
->channel_mode
!= AC3_CHMODE_STEREO
)
870 frame_bits
+= s
->fbw_channels
;
871 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
877 frame_bits
+= s
->num_cpl_subbands
- 1;
881 /* coupling coordinates */
882 if (block
->cpl_in_use
) {
883 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
884 if (block
->channel_in_cpl
[ch
]) {
885 if (!s
->eac3
|| block
->new_cpl_coords
[ch
] != 2)
887 if (block
->new_cpl_coords
[ch
]) {
889 frame_bits
+= (4 + 4) * s
->num_cpl_bands
;
895 /* stereo rematrixing */
896 if (s
->channel_mode
== AC3_CHMODE_STEREO
) {
897 if (!s
->eac3
|| blk
> 0)
899 if (s
->blocks
[blk
].new_rematrixing_strategy
)
900 frame_bits
+= block
->num_rematrixing_bands
;
903 /* bandwidth codes & gain range */
904 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
905 if (s
->exp_strategy
[ch
][blk
] != EXP_REUSE
) {
906 if (!block
->channel_in_cpl
[ch
])
912 /* coupling exponent strategy */
913 if (!s
->eac3
&& block
->cpl_in_use
)
916 /* snr offsets and fast gain codes */
919 if (block
->new_snr_offsets
)
920 frame_bits
+= 6 + (s
->channels
+ block
->cpl_in_use
) * (4 + 3);
923 /* coupling leak info */
924 if (block
->cpl_in_use
) {
925 if (!s
->eac3
|| block
->new_cpl_leak
!= 2)
927 if (block
->new_cpl_leak
)
932 s
->frame_bits
= s
->frame_bits_fixed
+ frame_bits
;
937 * Calculate masking curve based on the final exponents.
938 * Also calculate the power spectral densities to use in future calculations.
940 static void bit_alloc_masking(AC3EncodeContext
*s
)
944 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
945 AC3Block
*block
= &s
->blocks
[blk
];
946 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
947 /* We only need psd and mask for calculating bap.
948 Since we currently do not calculate bap when exponent
949 strategy is EXP_REUSE we do not need to calculate psd or mask. */
950 if (s
->exp_strategy
[ch
][blk
] != EXP_REUSE
) {
951 ff_ac3_bit_alloc_calc_psd(block
->exp
[ch
], s
->start_freq
[ch
],
952 block
->end_freq
[ch
], block
->psd
[ch
],
953 block
->band_psd
[ch
]);
954 ff_ac3_bit_alloc_calc_mask(&s
->bit_alloc
, block
->band_psd
[ch
],
955 s
->start_freq
[ch
], block
->end_freq
[ch
],
956 ff_ac3_fast_gain_tab
[s
->fast_gain_code
[ch
]],
957 ch
== s
->lfe_channel
,
958 DBA_NONE
, 0, NULL
, NULL
, NULL
,
967 * Ensure that bap for each block and channel point to the current bap_buffer.
968 * They may have been switched during the bit allocation search.
970 static void reset_block_bap(AC3EncodeContext
*s
)
975 if (s
->ref_bap
[0][0] == s
->bap_buffer
&& s
->ref_bap_set
)
978 ref_bap
= s
->bap_buffer
;
979 for (ch
= 0; ch
<= s
->channels
; ch
++) {
980 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
981 s
->ref_bap
[ch
][blk
] = ref_bap
+ AC3_MAX_COEFS
* s
->exp_ref_block
[ch
][blk
];
982 ref_bap
+= AC3_MAX_COEFS
* s
->num_blocks
;
989 * Initialize mantissa counts.
990 * These are set so that they are padded to the next whole group size when bits
991 * are counted in compute_mantissa_size.
993 * @param[in,out] mant_cnt running counts for each bap value for each block
995 static void count_mantissa_bits_init(uint16_t mant_cnt
[AC3_MAX_BLOCKS
][16])
999 for (blk
= 0; blk
< AC3_MAX_BLOCKS
; blk
++) {
1000 memset(mant_cnt
[blk
], 0, sizeof(mant_cnt
[blk
]));
1001 mant_cnt
[blk
][1] = mant_cnt
[blk
][2] = 2;
1002 mant_cnt
[blk
][4] = 1;
1008 * Update mantissa bit counts for all blocks in 1 channel in a given bandwidth
1011 * @param s AC-3 encoder private context
1012 * @param ch channel index
1013 * @param[in,out] mant_cnt running counts for each bap value for each block
1014 * @param start starting coefficient bin
1015 * @param end ending coefficient bin
1017 static void count_mantissa_bits_update_ch(AC3EncodeContext
*s
, int ch
,
1018 uint16_t mant_cnt
[AC3_MAX_BLOCKS
][16],
1023 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
1024 AC3Block
*block
= &s
->blocks
[blk
];
1025 if (ch
== CPL_CH
&& !block
->cpl_in_use
)
1027 s
->ac3dsp
.update_bap_counts(mant_cnt
[blk
],
1028 s
->ref_bap
[ch
][blk
] + start
,
1029 FFMIN(end
, block
->end_freq
[ch
]) - start
);
1035 * Count the number of mantissa bits in the frame based on the bap values.
1037 static int count_mantissa_bits(AC3EncodeContext
*s
)
1039 int ch
, max_end_freq
;
1040 LOCAL_ALIGNED_16(uint16_t, mant_cnt
, [AC3_MAX_BLOCKS
], [16]);
1042 count_mantissa_bits_init(mant_cnt
);
1044 max_end_freq
= s
->bandwidth_code
* 3 + 73;
1045 for (ch
= !s
->cpl_enabled
; ch
<= s
->channels
; ch
++)
1046 count_mantissa_bits_update_ch(s
, ch
, mant_cnt
, s
->start_freq
[ch
],
1049 return s
->ac3dsp
.compute_mantissa_size(mant_cnt
);
1054 * Run the bit allocation with a given SNR offset.
1055 * This calculates the bit allocation pointers that will be used to determine
1056 * the quantization of each mantissa.
1058 * @param s AC-3 encoder private context
1059 * @param snr_offset SNR offset, 0 to 1023
1060 * @return the number of bits needed for mantissas if the given SNR offset is
1063 static int bit_alloc(AC3EncodeContext
*s
, int snr_offset
)
1067 snr_offset
= (snr_offset
- 240) << 2;
1070 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
1071 AC3Block
*block
= &s
->blocks
[blk
];
1073 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
1074 /* Currently the only bit allocation parameters which vary across
1075 blocks within a frame are the exponent values. We can take
1076 advantage of that by reusing the bit allocation pointers
1077 whenever we reuse exponents. */
1078 if (s
->exp_strategy
[ch
][blk
] != EXP_REUSE
) {
1079 s
->ac3dsp
.bit_alloc_calc_bap(block
->mask
[ch
], block
->psd
[ch
],
1080 s
->start_freq
[ch
], block
->end_freq
[ch
],
1081 snr_offset
, s
->bit_alloc
.floor
,
1082 ff_ac3_bap_tab
, s
->ref_bap
[ch
][blk
]);
1086 return count_mantissa_bits(s
);
1091 * Constant bitrate bit allocation search.
1092 * Find the largest SNR offset that will allow data to fit in the frame.
1094 static int cbr_bit_allocation(AC3EncodeContext
*s
)
1098 int snr_offset
, snr_incr
;
1100 bits_left
= 8 * s
->frame_size
- (s
->frame_bits
+ s
->exponent_bits
);
1102 return AVERROR(EINVAL
);
1104 snr_offset
= s
->coarse_snr_offset
<< 4;
1106 /* if previous frame SNR offset was 1023, check if current frame can also
1107 use SNR offset of 1023. if so, skip the search. */
1108 if ((snr_offset
| s
->fine_snr_offset
[1]) == 1023) {
1109 if (bit_alloc(s
, 1023) <= bits_left
)
1113 while (snr_offset
>= 0 &&
1114 bit_alloc(s
, snr_offset
) > bits_left
) {
1118 return AVERROR(EINVAL
);
1120 FFSWAP(uint8_t *, s
->bap_buffer
, s
->bap1_buffer
);
1121 for (snr_incr
= 64; snr_incr
> 0; snr_incr
>>= 2) {
1122 while (snr_offset
+ snr_incr
<= 1023 &&
1123 bit_alloc(s
, snr_offset
+ snr_incr
) <= bits_left
) {
1124 snr_offset
+= snr_incr
;
1125 FFSWAP(uint8_t *, s
->bap_buffer
, s
->bap1_buffer
);
1128 FFSWAP(uint8_t *, s
->bap_buffer
, s
->bap1_buffer
);
1131 s
->coarse_snr_offset
= snr_offset
>> 4;
1132 for (ch
= !s
->cpl_on
; ch
<= s
->channels
; ch
++)
1133 s
->fine_snr_offset
[ch
] = snr_offset
& 0xF;
1140 * Perform bit allocation search.
1141 * Finds the SNR offset value that maximizes quality and fits in the specified
1142 * frame size. Output is the SNR offset and a set of bit allocation pointers
1143 * used to quantize the mantissas.
1145 int ff_ac3_compute_bit_allocation(AC3EncodeContext
*s
)
1147 count_frame_bits(s
);
1149 s
->exponent_bits
= count_exponent_bits(s
);
1151 bit_alloc_masking(s
);
1153 return cbr_bit_allocation(s
);
1158 * Symmetric quantization on 'levels' levels.
1160 * @param c unquantized coefficient
1162 * @param levels number of quantization levels
1163 * @return quantized coefficient
1165 static inline int sym_quant(int c
, int e
, int levels
)
1167 int v
= (((levels
* c
) >> (24 - e
)) + levels
) >> 1;
1168 av_assert2(v
>= 0 && v
< levels
);
1174 * Asymmetric quantization on 2^qbits levels.
1176 * @param c unquantized coefficient
1178 * @param qbits number of quantization bits
1179 * @return quantized coefficient
1181 static inline int asym_quant(int c
, int e
, int qbits
)
1185 c
= (((c
<< e
) >> (24 - qbits
)) + 1) >> 1;
1186 m
= (1 << (qbits
-1));
1189 av_assert2(c
>= -m
);
1195 * Quantize a set of mantissas for a single channel in a single block.
1197 * @param s Mantissa count context
1198 * @param fixed_coef unquantized fixed-point coefficients
1199 * @param exp exponents
1200 * @param bap bit allocation pointer indices
1201 * @param[out] qmant quantized coefficients
1202 * @param start_freq starting coefficient bin
1203 * @param end_freq ending coefficient bin
1205 static void quantize_mantissas_blk_ch(AC3Mant
*s
, int32_t *fixed_coef
,
1206 uint8_t *exp
, uint8_t *bap
,
1207 int16_t *qmant
, int start_freq
,
1212 for (i
= start_freq
; i
< end_freq
; i
++) {
1213 int c
= fixed_coef
[i
];
1219 v
= sym_quant(c
, e
, 3);
1220 switch (s
->mant1_cnt
) {
1222 s
->qmant1_ptr
= &qmant
[i
];
1227 *s
->qmant1_ptr
+= 3 * v
;
1232 *s
->qmant1_ptr
+= v
;
1239 v
= sym_quant(c
, e
, 5);
1240 switch (s
->mant2_cnt
) {
1242 s
->qmant2_ptr
= &qmant
[i
];
1247 *s
->qmant2_ptr
+= 5 * v
;
1252 *s
->qmant2_ptr
+= v
;
1259 v
= sym_quant(c
, e
, 7);
1262 v
= sym_quant(c
, e
, 11);
1263 switch (s
->mant4_cnt
) {
1265 s
->qmant4_ptr
= &qmant
[i
];
1270 *s
->qmant4_ptr
+= v
;
1277 v
= sym_quant(c
, e
, 15);
1280 v
= asym_quant(c
, e
, 14);
1283 v
= asym_quant(c
, e
, 16);
1286 v
= asym_quant(c
, e
, v
- 1);
1295 * Quantize mantissas using coefficients, exponents, and bit allocation pointers.
1297 * @param s AC-3 encoder private context
1299 void ff_ac3_quantize_mantissas(AC3EncodeContext
*s
)
1301 int blk
, ch
, ch0
=0, got_cpl
;
1303 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
1304 AC3Block
*block
= &s
->blocks
[blk
];
1307 got_cpl
= !block
->cpl_in_use
;
1308 for (ch
= 1; ch
<= s
->channels
; ch
++) {
1309 if (!got_cpl
&& ch
> 1 && block
->channel_in_cpl
[ch
-1]) {
1314 quantize_mantissas_blk_ch(&m
, block
->fixed_coef
[ch
],
1315 s
->blocks
[s
->exp_ref_block
[ch
][blk
]].exp
[ch
],
1316 s
->ref_bap
[ch
][blk
], block
->qmant
[ch
],
1317 s
->start_freq
[ch
], block
->end_freq
[ch
]);
1326 * Write the AC-3 frame header to the output bitstream.
1328 static void ac3_output_frame_header(AC3EncodeContext
*s
)
1330 AC3EncOptions
*opt
= &s
->options
;
1332 put_bits(&s
->pb
, 16, 0x0b77); /* frame header */
1333 put_bits(&s
->pb
, 16, 0); /* crc1: will be filled later */
1334 put_bits(&s
->pb
, 2, s
->bit_alloc
.sr_code
);
1335 put_bits(&s
->pb
, 6, s
->frame_size_code
+ (s
->frame_size
- s
->frame_size_min
) / 2);
1336 put_bits(&s
->pb
, 5, s
->bitstream_id
);
1337 put_bits(&s
->pb
, 3, s
->bitstream_mode
);
1338 put_bits(&s
->pb
, 3, s
->channel_mode
);
1339 if ((s
->channel_mode
& 0x01) && s
->channel_mode
!= AC3_CHMODE_MONO
)
1340 put_bits(&s
->pb
, 2, s
->center_mix_level
);
1341 if (s
->channel_mode
& 0x04)
1342 put_bits(&s
->pb
, 2, s
->surround_mix_level
);
1343 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
1344 put_bits(&s
->pb
, 2, opt
->dolby_surround_mode
);
1345 put_bits(&s
->pb
, 1, s
->lfe_on
); /* LFE */
1346 put_bits(&s
->pb
, 5, -opt
->dialogue_level
);
1347 put_bits(&s
->pb
, 1, 0); /* no compression control word */
1348 put_bits(&s
->pb
, 1, 0); /* no lang code */
1349 put_bits(&s
->pb
, 1, opt
->audio_production_info
);
1350 if (opt
->audio_production_info
) {
1351 put_bits(&s
->pb
, 5, opt
->mixing_level
- 80);
1352 put_bits(&s
->pb
, 2, opt
->room_type
);
1354 put_bits(&s
->pb
, 1, opt
->copyright
);
1355 put_bits(&s
->pb
, 1, opt
->original
);
1356 if (s
->bitstream_id
== 6) {
1357 /* alternate bit stream syntax */
1358 put_bits(&s
->pb
, 1, opt
->extended_bsi_1
);
1359 if (opt
->extended_bsi_1
) {
1360 put_bits(&s
->pb
, 2, opt
->preferred_stereo_downmix
);
1361 put_bits(&s
->pb
, 3, s
->ltrt_center_mix_level
);
1362 put_bits(&s
->pb
, 3, s
->ltrt_surround_mix_level
);
1363 put_bits(&s
->pb
, 3, s
->loro_center_mix_level
);
1364 put_bits(&s
->pb
, 3, s
->loro_surround_mix_level
);
1366 put_bits(&s
->pb
, 1, opt
->extended_bsi_2
);
1367 if (opt
->extended_bsi_2
) {
1368 put_bits(&s
->pb
, 2, opt
->dolby_surround_ex_mode
);
1369 put_bits(&s
->pb
, 2, opt
->dolby_headphone_mode
);
1370 put_bits(&s
->pb
, 1, opt
->ad_converter_type
);
1371 put_bits(&s
->pb
, 9, 0); /* xbsi2 and encinfo : reserved */
1374 put_bits(&s
->pb
, 1, 0); /* no time code 1 */
1375 put_bits(&s
->pb
, 1, 0); /* no time code 2 */
1377 put_bits(&s
->pb
, 1, 0); /* no additional bit stream info */
1382 * Write one audio block to the output bitstream.
1384 static void output_audio_block(AC3EncodeContext
*s
, int blk
)
1386 int ch
, i
, baie
, bnd
, got_cpl
, av_uninit(ch0
);
1387 AC3Block
*block
= &s
->blocks
[blk
];
1389 /* block switching */
1391 for (ch
= 0; ch
< s
->fbw_channels
; ch
++)
1392 put_bits(&s
->pb
, 1, 0);
1397 for (ch
= 0; ch
< s
->fbw_channels
; ch
++)
1398 put_bits(&s
->pb
, 1, 1);
1401 /* dynamic range codes */
1402 put_bits(&s
->pb
, 1, 0);
1404 /* spectral extension */
1406 put_bits(&s
->pb
, 1, 0);
1408 /* channel coupling */
1410 put_bits(&s
->pb
, 1, block
->new_cpl_strategy
);
1411 if (block
->new_cpl_strategy
) {
1413 put_bits(&s
->pb
, 1, block
->cpl_in_use
);
1414 if (block
->cpl_in_use
) {
1415 int start_sub
, end_sub
;
1417 put_bits(&s
->pb
, 1, 0); /* enhanced coupling */
1418 if (!s
->eac3
|| s
->channel_mode
!= AC3_CHMODE_STEREO
) {
1419 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++)
1420 put_bits(&s
->pb
, 1, block
->channel_in_cpl
[ch
]);
1422 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
1423 put_bits(&s
->pb
, 1, 0); /* phase flags in use */
1424 start_sub
= (s
->start_freq
[CPL_CH
] - 37) / 12;
1425 end_sub
= (s
->cpl_end_freq
- 37) / 12;
1426 put_bits(&s
->pb
, 4, start_sub
);
1427 put_bits(&s
->pb
, 4, end_sub
- 3);
1428 /* coupling band structure */
1430 put_bits(&s
->pb
, 1, 0); /* use default */
1432 for (bnd
= start_sub
+1; bnd
< end_sub
; bnd
++)
1433 put_bits(&s
->pb
, 1, ff_eac3_default_cpl_band_struct
[bnd
]);
1438 /* coupling coordinates */
1439 if (block
->cpl_in_use
) {
1440 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
1441 if (block
->channel_in_cpl
[ch
]) {
1442 if (!s
->eac3
|| block
->new_cpl_coords
[ch
] != 2)
1443 put_bits(&s
->pb
, 1, block
->new_cpl_coords
[ch
]);
1444 if (block
->new_cpl_coords
[ch
]) {
1445 put_bits(&s
->pb
, 2, block
->cpl_master_exp
[ch
]);
1446 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
1447 put_bits(&s
->pb
, 4, block
->cpl_coord_exp
[ch
][bnd
]);
1448 put_bits(&s
->pb
, 4, block
->cpl_coord_mant
[ch
][bnd
]);
1455 /* stereo rematrixing */
1456 if (s
->channel_mode
== AC3_CHMODE_STEREO
) {
1457 if (!s
->eac3
|| blk
> 0)
1458 put_bits(&s
->pb
, 1, block
->new_rematrixing_strategy
);
1459 if (block
->new_rematrixing_strategy
) {
1460 /* rematrixing flags */
1461 for (bnd
= 0; bnd
< block
->num_rematrixing_bands
; bnd
++)
1462 put_bits(&s
->pb
, 1, block
->rematrixing_flags
[bnd
]);
1466 /* exponent strategy */
1468 for (ch
= !block
->cpl_in_use
; ch
<= s
->fbw_channels
; ch
++)
1469 put_bits(&s
->pb
, 2, s
->exp_strategy
[ch
][blk
]);
1471 put_bits(&s
->pb
, 1, s
->exp_strategy
[s
->lfe_channel
][blk
]);
1475 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
1476 if (s
->exp_strategy
[ch
][blk
] != EXP_REUSE
&& !block
->channel_in_cpl
[ch
])
1477 put_bits(&s
->pb
, 6, s
->bandwidth_code
);
1481 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
1483 int cpl
= (ch
== CPL_CH
);
1485 if (s
->exp_strategy
[ch
][blk
] == EXP_REUSE
)
1489 put_bits(&s
->pb
, 4, block
->grouped_exp
[ch
][0] >> cpl
);
1491 /* exponent groups */
1492 nb_groups
= exponent_group_tab
[cpl
][s
->exp_strategy
[ch
][blk
]-1][block
->end_freq
[ch
]-s
->start_freq
[ch
]];
1493 for (i
= 1; i
<= nb_groups
; i
++)
1494 put_bits(&s
->pb
, 7, block
->grouped_exp
[ch
][i
]);
1496 /* gain range info */
1497 if (ch
!= s
->lfe_channel
&& !cpl
)
1498 put_bits(&s
->pb
, 2, 0);
1501 /* bit allocation info */
1504 put_bits(&s
->pb
, 1, baie
);
1506 put_bits(&s
->pb
, 2, s
->slow_decay_code
);
1507 put_bits(&s
->pb
, 2, s
->fast_decay_code
);
1508 put_bits(&s
->pb
, 2, s
->slow_gain_code
);
1509 put_bits(&s
->pb
, 2, s
->db_per_bit_code
);
1510 put_bits(&s
->pb
, 3, s
->floor_code
);
1516 put_bits(&s
->pb
, 1, block
->new_snr_offsets
);
1517 if (block
->new_snr_offsets
) {
1518 put_bits(&s
->pb
, 6, s
->coarse_snr_offset
);
1519 for (ch
= !block
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
1520 put_bits(&s
->pb
, 4, s
->fine_snr_offset
[ch
]);
1521 put_bits(&s
->pb
, 3, s
->fast_gain_code
[ch
]);
1525 put_bits(&s
->pb
, 1, 0); /* no converter snr offset */
1529 if (block
->cpl_in_use
) {
1530 if (!s
->eac3
|| block
->new_cpl_leak
!= 2)
1531 put_bits(&s
->pb
, 1, block
->new_cpl_leak
);
1532 if (block
->new_cpl_leak
) {
1533 put_bits(&s
->pb
, 3, s
->bit_alloc
.cpl_fast_leak
);
1534 put_bits(&s
->pb
, 3, s
->bit_alloc
.cpl_slow_leak
);
1539 put_bits(&s
->pb
, 1, 0); /* no delta bit allocation */
1540 put_bits(&s
->pb
, 1, 0); /* no data to skip */
1544 got_cpl
= !block
->cpl_in_use
;
1545 for (ch
= 1; ch
<= s
->channels
; ch
++) {
1548 if (!got_cpl
&& ch
> 1 && block
->channel_in_cpl
[ch
-1]) {
1553 for (i
= s
->start_freq
[ch
]; i
< block
->end_freq
[ch
]; i
++) {
1554 q
= block
->qmant
[ch
][i
];
1555 b
= s
->ref_bap
[ch
][blk
][i
];
1558 case 1: if (q
!= 128) put_bits (&s
->pb
, 5, q
); break;
1559 case 2: if (q
!= 128) put_bits (&s
->pb
, 7, q
); break;
1560 case 3: put_sbits(&s
->pb
, 3, q
); break;
1561 case 4: if (q
!= 128) put_bits (&s
->pb
, 7, q
); break;
1562 case 14: put_sbits(&s
->pb
, 14, q
); break;
1563 case 15: put_sbits(&s
->pb
, 16, q
); break;
1564 default: put_sbits(&s
->pb
, b
-1, q
); break;
1573 /** CRC-16 Polynomial */
1574 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))
1577 static unsigned int mul_poly(unsigned int a
, unsigned int b
, unsigned int poly
)
1594 static unsigned int pow_poly(unsigned int a
, unsigned int n
, unsigned int poly
)
1600 r
= mul_poly(r
, a
, poly
);
1601 a
= mul_poly(a
, a
, poly
);
1609 * Fill the end of the frame with 0's and compute the two CRCs.
1611 static void output_frame_end(AC3EncodeContext
*s
)
1613 const AVCRC
*crc_ctx
= av_crc_get_table(AV_CRC_16_ANSI
);
1614 int frame_size_58
, pad_bytes
, crc1
, crc2_partial
, crc2
, crc_inv
;
1617 frame_size_58
= ((s
->frame_size
>> 2) + (s
->frame_size
>> 4)) << 1;
1619 /* pad the remainder of the frame with zeros */
1620 av_assert2(s
->frame_size
* 8 - put_bits_count(&s
->pb
) >= 18);
1621 flush_put_bits(&s
->pb
);
1623 pad_bytes
= s
->frame_size
- (put_bits_ptr(&s
->pb
) - frame
) - 2;
1624 av_assert2(pad_bytes
>= 0);
1626 memset(put_bits_ptr(&s
->pb
), 0, pad_bytes
);
1630 crc2_partial
= av_crc(crc_ctx
, 0, frame
+ 2, s
->frame_size
- 5);
1633 /* this is not so easy because it is at the beginning of the data... */
1634 crc1
= av_bswap16(av_crc(crc_ctx
, 0, frame
+ 4, frame_size_58
- 4));
1635 crc_inv
= s
->crc_inv
[s
->frame_size
> s
->frame_size_min
];
1636 crc1
= mul_poly(crc_inv
, crc1
, CRC16_POLY
);
1637 AV_WB16(frame
+ 2, crc1
);
1640 crc2_partial
= av_crc(crc_ctx
, 0, frame
+ frame_size_58
,
1641 s
->frame_size
- frame_size_58
- 3);
1643 crc2
= av_crc(crc_ctx
, crc2_partial
, frame
+ s
->frame_size
- 3, 1);
1644 /* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
1645 if (crc2
== 0x770B) {
1646 frame
[s
->frame_size
- 3] ^= 0x1;
1647 crc2
= av_crc(crc_ctx
, crc2_partial
, frame
+ s
->frame_size
- 3, 1);
1649 crc2
= av_bswap16(crc2
);
1650 AV_WB16(frame
+ s
->frame_size
- 2, crc2
);
1655 * Write the frame to the output bitstream.
1657 * @param s AC-3 encoder private context
1658 * @param frame output data buffer
1660 void ff_ac3_output_frame(AC3EncodeContext
*s
, unsigned char *frame
)
1664 init_put_bits(&s
->pb
, frame
, AC3_MAX_CODED_FRAME_SIZE
);
1666 s
->output_frame_header(s
);
1668 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
1669 output_audio_block(s
, blk
);
1671 output_frame_end(s
);
1675 static void dprint_options(AC3EncodeContext
*s
)
1678 AVCodecContext
*avctx
= s
->avctx
;
1679 AC3EncOptions
*opt
= &s
->options
;
1682 switch (s
->bitstream_id
) {
1683 case 6: av_strlcpy(strbuf
, "AC-3 (alt syntax)", 32); break;
1684 case 8: av_strlcpy(strbuf
, "AC-3 (standard)", 32); break;
1685 case 9: av_strlcpy(strbuf
, "AC-3 (dnet half-rate)", 32); break;
1686 case 10: av_strlcpy(strbuf
, "AC-3 (dnet quater-rate)", 32); break;
1687 case 16: av_strlcpy(strbuf
, "E-AC-3 (enhanced)", 32); break;
1688 default: snprintf(strbuf
, 32, "ERROR");
1690 av_dlog(avctx
, "bitstream_id: %s (%d)\n", strbuf
, s
->bitstream_id
);
1691 av_dlog(avctx
, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx
->sample_fmt
));
1692 av_get_channel_layout_string(strbuf
, 32, s
->channels
, avctx
->channel_layout
);
1693 av_dlog(avctx
, "channel_layout: %s\n", strbuf
);
1694 av_dlog(avctx
, "sample_rate: %d\n", s
->sample_rate
);
1695 av_dlog(avctx
, "bit_rate: %d\n", s
->bit_rate
);
1696 av_dlog(avctx
, "blocks/frame: %d (code=%d)\n", s
->num_blocks
, s
->num_blks_code
);
1698 av_dlog(avctx
, "cutoff: %d\n", s
->cutoff
);
1700 av_dlog(avctx
, "per_frame_metadata: %s\n",
1701 opt
->allow_per_frame_metadata
?"on":"off");
1703 av_dlog(avctx
, "center_mixlev: %0.3f (%d)\n", opt
->center_mix_level
,
1704 s
->center_mix_level
);
1706 av_dlog(avctx
, "center_mixlev: {not written}\n");
1707 if (s
->has_surround
)
1708 av_dlog(avctx
, "surround_mixlev: %0.3f (%d)\n", opt
->surround_mix_level
,
1709 s
->surround_mix_level
);
1711 av_dlog(avctx
, "surround_mixlev: {not written}\n");
1712 if (opt
->audio_production_info
) {
1713 av_dlog(avctx
, "mixing_level: %ddB\n", opt
->mixing_level
);
1714 switch (opt
->room_type
) {
1715 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1716 case AC3ENC_OPT_LARGE_ROOM
: av_strlcpy(strbuf
, "large", 32); break;
1717 case AC3ENC_OPT_SMALL_ROOM
: av_strlcpy(strbuf
, "small", 32); break;
1718 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->room_type
);
1720 av_dlog(avctx
, "room_type: %s\n", strbuf
);
1722 av_dlog(avctx
, "mixing_level: {not written}\n");
1723 av_dlog(avctx
, "room_type: {not written}\n");
1725 av_dlog(avctx
, "copyright: %s\n", opt
->copyright
?"on":"off");
1726 av_dlog(avctx
, "dialnorm: %ddB\n", opt
->dialogue_level
);
1727 if (s
->channel_mode
== AC3_CHMODE_STEREO
) {
1728 switch (opt
->dolby_surround_mode
) {
1729 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1730 case AC3ENC_OPT_MODE_ON
: av_strlcpy(strbuf
, "on", 32); break;
1731 case AC3ENC_OPT_MODE_OFF
: av_strlcpy(strbuf
, "off", 32); break;
1732 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->dolby_surround_mode
);
1734 av_dlog(avctx
, "dsur_mode: %s\n", strbuf
);
1736 av_dlog(avctx
, "dsur_mode: {not written}\n");
1738 av_dlog(avctx
, "original: %s\n", opt
->original
?"on":"off");
1740 if (s
->bitstream_id
== 6) {
1741 if (opt
->extended_bsi_1
) {
1742 switch (opt
->preferred_stereo_downmix
) {
1743 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1744 case AC3ENC_OPT_DOWNMIX_LTRT
: av_strlcpy(strbuf
, "ltrt", 32); break;
1745 case AC3ENC_OPT_DOWNMIX_LORO
: av_strlcpy(strbuf
, "loro", 32); break;
1746 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->preferred_stereo_downmix
);
1748 av_dlog(avctx
, "dmix_mode: %s\n", strbuf
);
1749 av_dlog(avctx
, "ltrt_cmixlev: %0.3f (%d)\n",
1750 opt
->ltrt_center_mix_level
, s
->ltrt_center_mix_level
);
1751 av_dlog(avctx
, "ltrt_surmixlev: %0.3f (%d)\n",
1752 opt
->ltrt_surround_mix_level
, s
->ltrt_surround_mix_level
);
1753 av_dlog(avctx
, "loro_cmixlev: %0.3f (%d)\n",
1754 opt
->loro_center_mix_level
, s
->loro_center_mix_level
);
1755 av_dlog(avctx
, "loro_surmixlev: %0.3f (%d)\n",
1756 opt
->loro_surround_mix_level
, s
->loro_surround_mix_level
);
1758 av_dlog(avctx
, "extended bitstream info 1: {not written}\n");
1760 if (opt
->extended_bsi_2
) {
1761 switch (opt
->dolby_surround_ex_mode
) {
1762 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1763 case AC3ENC_OPT_MODE_ON
: av_strlcpy(strbuf
, "on", 32); break;
1764 case AC3ENC_OPT_MODE_OFF
: av_strlcpy(strbuf
, "off", 32); break;
1765 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->dolby_surround_ex_mode
);
1767 av_dlog(avctx
, "dsurex_mode: %s\n", strbuf
);
1768 switch (opt
->dolby_headphone_mode
) {
1769 case AC3ENC_OPT_NOT_INDICATED
: av_strlcpy(strbuf
, "notindicated", 32); break;
1770 case AC3ENC_OPT_MODE_ON
: av_strlcpy(strbuf
, "on", 32); break;
1771 case AC3ENC_OPT_MODE_OFF
: av_strlcpy(strbuf
, "off", 32); break;
1772 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->dolby_headphone_mode
);
1774 av_dlog(avctx
, "dheadphone_mode: %s\n", strbuf
);
1776 switch (opt
->ad_converter_type
) {
1777 case AC3ENC_OPT_ADCONV_STANDARD
: av_strlcpy(strbuf
, "standard", 32); break;
1778 case AC3ENC_OPT_ADCONV_HDCD
: av_strlcpy(strbuf
, "hdcd", 32); break;
1779 default: snprintf(strbuf
, 32, "ERROR (%d)", opt
->ad_converter_type
);
1781 av_dlog(avctx
, "ad_conv_type: %s\n", strbuf
);
1783 av_dlog(avctx
, "extended bitstream info 2: {not written}\n");
1790 #define FLT_OPTION_THRESHOLD 0.01
1792 static int validate_float_option(float v
, const float *v_list
, int v_list_size
)
1796 for (i
= 0; i
< v_list_size
; i
++) {
1797 if (v
< (v_list
[i
] + FLT_OPTION_THRESHOLD
) &&
1798 v
> (v_list
[i
] - FLT_OPTION_THRESHOLD
))
1801 if (i
== v_list_size
)
1808 static void validate_mix_level(void *log_ctx
, const char *opt_name
,
1809 float *opt_param
, const float *list
,
1810 int list_size
, int default_value
, int min_value
,
1813 int mixlev
= validate_float_option(*opt_param
, list
, list_size
);
1814 if (mixlev
< min_value
) {
1815 mixlev
= default_value
;
1816 if (*opt_param
>= 0.0) {
1817 av_log(log_ctx
, AV_LOG_WARNING
, "requested %s is not valid. using "
1818 "default value: %0.3f\n", opt_name
, list
[mixlev
]);
1821 *opt_param
= list
[mixlev
];
1822 *ctx_param
= mixlev
;
1827 * Validate metadata options as set by AVOption system.
1828 * These values can optionally be changed per-frame.
1830 * @param s AC-3 encoder private context
1832 int ff_ac3_validate_metadata(AC3EncodeContext
*s
)
1834 AVCodecContext
*avctx
= s
->avctx
;
1835 AC3EncOptions
*opt
= &s
->options
;
1837 opt
->audio_production_info
= 0;
1838 opt
->extended_bsi_1
= 0;
1839 opt
->extended_bsi_2
= 0;
1840 opt
->eac3_mixing_metadata
= 0;
1841 opt
->eac3_info_metadata
= 0;
1843 /* determine mixing metadata / xbsi1 use */
1844 if (s
->channel_mode
> AC3_CHMODE_STEREO
&& opt
->preferred_stereo_downmix
!= AC3ENC_OPT_NONE
) {
1845 opt
->extended_bsi_1
= 1;
1846 opt
->eac3_mixing_metadata
= 1;
1848 if (s
->has_center
&&
1849 (opt
->ltrt_center_mix_level
>= 0 || opt
->loro_center_mix_level
>= 0)) {
1850 opt
->extended_bsi_1
= 1;
1851 opt
->eac3_mixing_metadata
= 1;
1853 if (s
->has_surround
&&
1854 (opt
->ltrt_surround_mix_level
>= 0 || opt
->loro_surround_mix_level
>= 0)) {
1855 opt
->extended_bsi_1
= 1;
1856 opt
->eac3_mixing_metadata
= 1;
1860 /* determine info metadata use */
1861 if (avctx
->audio_service_type
!= AV_AUDIO_SERVICE_TYPE_MAIN
)
1862 opt
->eac3_info_metadata
= 1;
1863 if (opt
->copyright
!= AC3ENC_OPT_NONE
|| opt
->original
!= AC3ENC_OPT_NONE
)
1864 opt
->eac3_info_metadata
= 1;
1865 if (s
->channel_mode
== AC3_CHMODE_STEREO
&&
1866 (opt
->dolby_headphone_mode
!= AC3ENC_OPT_NONE
|| opt
->dolby_surround_mode
!= AC3ENC_OPT_NONE
))
1867 opt
->eac3_info_metadata
= 1;
1868 if (s
->channel_mode
>= AC3_CHMODE_2F2R
&& opt
->dolby_surround_ex_mode
!= AC3ENC_OPT_NONE
)
1869 opt
->eac3_info_metadata
= 1;
1870 if (opt
->mixing_level
!= AC3ENC_OPT_NONE
|| opt
->room_type
!= AC3ENC_OPT_NONE
||
1871 opt
->ad_converter_type
!= AC3ENC_OPT_NONE
) {
1872 opt
->audio_production_info
= 1;
1873 opt
->eac3_info_metadata
= 1;
1876 /* determine audio production info use */
1877 if (opt
->mixing_level
!= AC3ENC_OPT_NONE
|| opt
->room_type
!= AC3ENC_OPT_NONE
)
1878 opt
->audio_production_info
= 1;
1880 /* determine xbsi2 use */
1881 if (s
->channel_mode
>= AC3_CHMODE_2F2R
&& opt
->dolby_surround_ex_mode
!= AC3ENC_OPT_NONE
)
1882 opt
->extended_bsi_2
= 1;
1883 if (s
->channel_mode
== AC3_CHMODE_STEREO
&& opt
->dolby_headphone_mode
!= AC3ENC_OPT_NONE
)
1884 opt
->extended_bsi_2
= 1;
1885 if (opt
->ad_converter_type
!= AC3ENC_OPT_NONE
)
1886 opt
->extended_bsi_2
= 1;
1889 /* validate AC-3 mixing levels */
1891 if (s
->has_center
) {
1892 validate_mix_level(avctx
, "center_mix_level", &opt
->center_mix_level
,
1893 cmixlev_options
, CMIXLEV_NUM_OPTIONS
, 1, 0,
1894 &s
->center_mix_level
);
1896 if (s
->has_surround
) {
1897 validate_mix_level(avctx
, "surround_mix_level", &opt
->surround_mix_level
,
1898 surmixlev_options
, SURMIXLEV_NUM_OPTIONS
, 1, 0,
1899 &s
->surround_mix_level
);
1903 /* validate extended bsi 1 / mixing metadata */
1904 if (opt
->extended_bsi_1
|| opt
->eac3_mixing_metadata
) {
1905 /* default preferred stereo downmix */
1906 if (opt
->preferred_stereo_downmix
== AC3ENC_OPT_NONE
)
1907 opt
->preferred_stereo_downmix
= AC3ENC_OPT_NOT_INDICATED
;
1908 if (!s
->eac3
|| s
->has_center
) {
1909 /* validate Lt/Rt center mix level */
1910 validate_mix_level(avctx
, "ltrt_center_mix_level",
1911 &opt
->ltrt_center_mix_level
, extmixlev_options
,
1912 EXTMIXLEV_NUM_OPTIONS
, 5, 0,
1913 &s
->ltrt_center_mix_level
);
1914 /* validate Lo/Ro center mix level */
1915 validate_mix_level(avctx
, "loro_center_mix_level",
1916 &opt
->loro_center_mix_level
, extmixlev_options
,
1917 EXTMIXLEV_NUM_OPTIONS
, 5, 0,
1918 &s
->loro_center_mix_level
);
1920 if (!s
->eac3
|| s
->has_surround
) {
1921 /* validate Lt/Rt surround mix level */
1922 validate_mix_level(avctx
, "ltrt_surround_mix_level",
1923 &opt
->ltrt_surround_mix_level
, extmixlev_options
,
1924 EXTMIXLEV_NUM_OPTIONS
, 6, 3,
1925 &s
->ltrt_surround_mix_level
);
1926 /* validate Lo/Ro surround mix level */
1927 validate_mix_level(avctx
, "loro_surround_mix_level",
1928 &opt
->loro_surround_mix_level
, extmixlev_options
,
1929 EXTMIXLEV_NUM_OPTIONS
, 6, 3,
1930 &s
->loro_surround_mix_level
);
1934 /* validate audio service type / channels combination */
1935 if ((avctx
->audio_service_type
== AV_AUDIO_SERVICE_TYPE_KARAOKE
&&
1936 avctx
->channels
== 1) ||
1937 ((avctx
->audio_service_type
== AV_AUDIO_SERVICE_TYPE_COMMENTARY
||
1938 avctx
->audio_service_type
== AV_AUDIO_SERVICE_TYPE_EMERGENCY
||
1939 avctx
->audio_service_type
== AV_AUDIO_SERVICE_TYPE_VOICE_OVER
)
1940 && avctx
->channels
> 1)) {
1941 av_log(avctx
, AV_LOG_ERROR
, "invalid audio service type for the "
1942 "specified number of channels\n");
1943 return AVERROR(EINVAL
);
1946 /* validate extended bsi 2 / info metadata */
1947 if (opt
->extended_bsi_2
|| opt
->eac3_info_metadata
) {
1948 /* default dolby headphone mode */
1949 if (opt
->dolby_headphone_mode
== AC3ENC_OPT_NONE
)
1950 opt
->dolby_headphone_mode
= AC3ENC_OPT_NOT_INDICATED
;
1951 /* default dolby surround ex mode */
1952 if (opt
->dolby_surround_ex_mode
== AC3ENC_OPT_NONE
)
1953 opt
->dolby_surround_ex_mode
= AC3ENC_OPT_NOT_INDICATED
;
1954 /* default A/D converter type */
1955 if (opt
->ad_converter_type
== AC3ENC_OPT_NONE
)
1956 opt
->ad_converter_type
= AC3ENC_OPT_ADCONV_STANDARD
;
1959 /* copyright & original defaults */
1960 if (!s
->eac3
|| opt
->eac3_info_metadata
) {
1961 /* default copyright */
1962 if (opt
->copyright
== AC3ENC_OPT_NONE
)
1963 opt
->copyright
= AC3ENC_OPT_OFF
;
1964 /* default original */
1965 if (opt
->original
== AC3ENC_OPT_NONE
)
1966 opt
->original
= AC3ENC_OPT_ON
;
1969 /* dolby surround mode default */
1970 if (!s
->eac3
|| opt
->eac3_info_metadata
) {
1971 if (opt
->dolby_surround_mode
== AC3ENC_OPT_NONE
)
1972 opt
->dolby_surround_mode
= AC3ENC_OPT_NOT_INDICATED
;
1975 /* validate audio production info */
1976 if (opt
->audio_production_info
) {
1977 if (opt
->mixing_level
== AC3ENC_OPT_NONE
) {
1978 av_log(avctx
, AV_LOG_ERROR
, "mixing_level must be set if "
1979 "room_type is set\n");
1980 return AVERROR(EINVAL
);
1982 if (opt
->mixing_level
< 80) {
1983 av_log(avctx
, AV_LOG_ERROR
, "invalid mixing level. must be between "
1984 "80dB and 111dB\n");
1985 return AVERROR(EINVAL
);
1987 /* default room type */
1988 if (opt
->room_type
== AC3ENC_OPT_NONE
)
1989 opt
->room_type
= AC3ENC_OPT_NOT_INDICATED
;
1992 /* set bitstream id for alternate bitstream syntax */
1993 if (!s
->eac3
&& (opt
->extended_bsi_1
|| opt
->extended_bsi_2
)) {
1994 if (s
->bitstream_id
> 8 && s
->bitstream_id
< 11) {
1995 static int warn_once
= 1;
1997 av_log(avctx
, AV_LOG_WARNING
, "alternate bitstream syntax is "
1998 "not compatible with reduced samplerates. writing of "
1999 "extended bitstream information will be disabled.\n");
2003 s
->bitstream_id
= 6;
2012 * Finalize encoding and free any memory allocated by the encoder.
2014 * @param avctx Codec context
2016 av_cold
int ff_ac3_encode_close(AVCodecContext
*avctx
)
2019 AC3EncodeContext
*s
= avctx
->priv_data
;
2021 av_freep(&s
->windowed_samples
);
2022 if (s
->planar_samples
)
2023 for (ch
= 0; ch
< s
->channels
; ch
++)
2024 av_freep(&s
->planar_samples
[ch
]);
2025 av_freep(&s
->planar_samples
);
2026 av_freep(&s
->bap_buffer
);
2027 av_freep(&s
->bap1_buffer
);
2028 av_freep(&s
->mdct_coef_buffer
);
2029 av_freep(&s
->fixed_coef_buffer
);
2030 av_freep(&s
->exp_buffer
);
2031 av_freep(&s
->grouped_exp_buffer
);
2032 av_freep(&s
->psd_buffer
);
2033 av_freep(&s
->band_psd_buffer
);
2034 av_freep(&s
->mask_buffer
);
2035 av_freep(&s
->qmant_buffer
);
2036 av_freep(&s
->cpl_coord_exp_buffer
);
2037 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
);
2060 * Set channel information during initialization.
2062 static av_cold
int set_channel_info(AC3EncodeContext
*s
, int channels
,
2063 uint64_t *channel_layout
)
2067 if (channels
< 1 || channels
> AC3_MAX_CHANNELS
)
2068 return AVERROR(EINVAL
);
2069 if (*channel_layout
> 0x7FF)
2070 return AVERROR(EINVAL
);
2071 ch_layout
= *channel_layout
;
2073 ch_layout
= av_get_default_channel_layout(channels
);
2075 s
->lfe_on
= !!(ch_layout
& AV_CH_LOW_FREQUENCY
);
2076 s
->channels
= channels
;
2077 s
->fbw_channels
= channels
- s
->lfe_on
;
2078 s
->lfe_channel
= s
->lfe_on
? s
->fbw_channels
+ 1 : -1;
2080 ch_layout
-= AV_CH_LOW_FREQUENCY
;
2082 switch (ch_layout
) {
2083 case AV_CH_LAYOUT_MONO
: s
->channel_mode
= AC3_CHMODE_MONO
; break;
2084 case AV_CH_LAYOUT_STEREO
: s
->channel_mode
= AC3_CHMODE_STEREO
; break;
2085 case AV_CH_LAYOUT_SURROUND
: s
->channel_mode
= AC3_CHMODE_3F
; break;
2086 case AV_CH_LAYOUT_2_1
: s
->channel_mode
= AC3_CHMODE_2F1R
; break;
2087 case AV_CH_LAYOUT_4POINT0
: s
->channel_mode
= AC3_CHMODE_3F1R
; break;
2088 case AV_CH_LAYOUT_QUAD
:
2089 case AV_CH_LAYOUT_2_2
: s
->channel_mode
= AC3_CHMODE_2F2R
; break;
2090 case AV_CH_LAYOUT_5POINT0
:
2091 case AV_CH_LAYOUT_5POINT0_BACK
: s
->channel_mode
= AC3_CHMODE_3F2R
; break;
2093 return AVERROR(EINVAL
);
2095 s
->has_center
= (s
->channel_mode
& 0x01) && s
->channel_mode
!= AC3_CHMODE_MONO
;
2096 s
->has_surround
= s
->channel_mode
& 0x04;
2098 s
->channel_map
= ff_ac3_enc_channel_map
[s
->channel_mode
][s
->lfe_on
];
2099 *channel_layout
= ch_layout
;
2101 *channel_layout
|= AV_CH_LOW_FREQUENCY
;
2107 static av_cold
int validate_options(AC3EncodeContext
*s
)
2109 AVCodecContext
*avctx
= s
->avctx
;
2112 /* validate channel layout */
2113 if (!avctx
->channel_layout
) {
2114 av_log(avctx
, AV_LOG_WARNING
, "No channel layout specified. The "
2115 "encoder will guess the layout, but it "
2116 "might be incorrect.\n");
2118 ret
= set_channel_info(s
, avctx
->channels
, &avctx
->channel_layout
);
2120 av_log(avctx
, AV_LOG_ERROR
, "invalid channel layout\n");
2124 /* validate sample rate */
2125 /* note: max_sr could be changed from 2 to 5 for E-AC-3 once we find a
2126 decoder that supports half sample rate so we can validate that
2127 the generated files are correct. */
2128 max_sr
= s
->eac3
? 2 : 8;
2129 for (i
= 0; i
<= max_sr
; i
++) {
2130 if ((ff_ac3_sample_rate_tab
[i
% 3] >> (i
/ 3)) == avctx
->sample_rate
)
2134 av_log(avctx
, AV_LOG_ERROR
, "invalid sample rate\n");
2135 return AVERROR(EINVAL
);
2137 s
->sample_rate
= avctx
->sample_rate
;
2138 s
->bit_alloc
.sr_shift
= i
/ 3;
2139 s
->bit_alloc
.sr_code
= i
% 3;
2140 s
->bitstream_id
= s
->eac3
? 16 : 8 + s
->bit_alloc
.sr_shift
;
2142 /* select a default bit rate if not set by the user */
2143 if (!avctx
->bit_rate
) {
2144 switch (s
->fbw_channels
) {
2145 case 1: avctx
->bit_rate
= 96000; break;
2146 case 2: avctx
->bit_rate
= 192000; break;
2147 case 3: avctx
->bit_rate
= 320000; break;
2148 case 4: avctx
->bit_rate
= 384000; break;
2149 case 5: avctx
->bit_rate
= 448000; break;
2153 /* validate bit rate */
2155 int max_br
, min_br
, wpf
, min_br_dist
, min_br_code
;
2156 int num_blks_code
, num_blocks
, frame_samples
;
2158 /* calculate min/max bitrate */
2159 /* TODO: More testing with 3 and 2 blocks. All E-AC-3 samples I've
2160 found use either 6 blocks or 1 block, even though 2 or 3 blocks
2161 would work as far as the bit rate is concerned. */
2162 for (num_blks_code
= 3; num_blks_code
>= 0; num_blks_code
--) {
2163 num_blocks
= ((int[]){ 1, 2, 3, 6 })[num_blks_code
];
2164 frame_samples
= AC3_BLOCK_SIZE
* num_blocks
;
2165 max_br
= 2048 * s
->sample_rate
/ frame_samples
* 16;
2166 min_br
= ((s
->sample_rate
+ (frame_samples
-1)) / frame_samples
) * 16;
2167 if (avctx
->bit_rate
<= max_br
)
2170 if (avctx
->bit_rate
< min_br
|| avctx
->bit_rate
> max_br
) {
2171 av_log(avctx
, AV_LOG_ERROR
, "invalid bit rate. must be %d to %d "
2172 "for this sample rate\n", min_br
, max_br
);
2173 return AVERROR(EINVAL
);
2175 s
->num_blks_code
= num_blks_code
;
2176 s
->num_blocks
= num_blocks
;
2178 /* calculate words-per-frame for the selected bitrate */
2179 wpf
= (avctx
->bit_rate
/ 16) * frame_samples
/ s
->sample_rate
;
2180 av_assert1(wpf
> 0 && wpf
<= 2048);
2182 /* find the closest AC-3 bitrate code to the selected bitrate.
2183 this is needed for lookup tables for bandwidth and coupling
2184 parameter selection */
2186 min_br_dist
= INT_MAX
;
2187 for (i
= 0; i
< 19; i
++) {
2188 int br_dist
= abs(ff_ac3_bitrate_tab
[i
] * 1000 - avctx
->bit_rate
);
2189 if (br_dist
< min_br_dist
) {
2190 min_br_dist
= br_dist
;
2195 /* make sure the minimum frame size is below the average frame size */
2196 s
->frame_size_code
= min_br_code
<< 1;
2197 while (wpf
> 1 && wpf
* s
->sample_rate
/ AC3_FRAME_SIZE
* 16 > avctx
->bit_rate
)
2199 s
->frame_size_min
= 2 * wpf
;
2201 int best_br
= 0, best_code
= 0, best_diff
= INT_MAX
;
2202 for (i
= 0; i
< 19; i
++) {
2203 int br
= (ff_ac3_bitrate_tab
[i
] >> s
->bit_alloc
.sr_shift
) * 1000;
2204 int diff
= abs(br
- avctx
->bit_rate
);
2205 if (diff
< best_diff
) {
2213 avctx
->bit_rate
= best_br
;
2214 s
->frame_size_code
= best_code
<< 1;
2215 s
->frame_size_min
= 2 * ff_ac3_frame_size_tab
[s
->frame_size_code
][s
->bit_alloc
.sr_code
];
2216 s
->num_blks_code
= 0x3;
2219 s
->bit_rate
= avctx
->bit_rate
;
2220 s
->frame_size
= s
->frame_size_min
;
2222 /* validate cutoff */
2223 if (avctx
->cutoff
< 0) {
2224 av_log(avctx
, AV_LOG_ERROR
, "invalid cutoff frequency\n");
2225 return AVERROR(EINVAL
);
2227 s
->cutoff
= avctx
->cutoff
;
2228 if (s
->cutoff
> (s
->sample_rate
>> 1))
2229 s
->cutoff
= s
->sample_rate
>> 1;
2231 ret
= ff_ac3_validate_metadata(s
);
2235 s
->rematrixing_enabled
= s
->options
.stereo_rematrixing
&&
2236 (s
->channel_mode
== AC3_CHMODE_STEREO
);
2238 s
->cpl_enabled
= s
->options
.channel_coupling
&&
2239 s
->channel_mode
>= AC3_CHMODE_STEREO
;
2246 * Set bandwidth for all channels.
2247 * The user can optionally supply a cutoff frequency. Otherwise an appropriate
2248 * default value will be used.
2250 static av_cold
void set_bandwidth(AC3EncodeContext
*s
)
2252 int blk
, ch
, av_uninit(cpl_start
);
2255 /* calculate bandwidth based on user-specified cutoff frequency */
2257 fbw_coeffs
= s
->cutoff
* 2 * AC3_MAX_COEFS
/ s
->sample_rate
;
2258 s
->bandwidth_code
= av_clip((fbw_coeffs
- 73) / 3, 0, 60);
2260 /* use default bandwidth setting */
2261 s
->bandwidth_code
= ac3_bandwidth_tab
[s
->fbw_channels
-1][s
->bit_alloc
.sr_code
][s
->frame_size_code
/2];
2264 /* set number of coefficients for each channel */
2265 for (ch
= 1; ch
<= s
->fbw_channels
; ch
++) {
2266 s
->start_freq
[ch
] = 0;
2267 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
2268 s
->blocks
[blk
].end_freq
[ch
] = s
->bandwidth_code
* 3 + 73;
2270 /* LFE channel always has 7 coefs */
2272 s
->start_freq
[s
->lfe_channel
] = 0;
2273 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
2274 s
->blocks
[blk
].end_freq
[ch
] = 7;
2277 /* initialize coupling strategy */
2278 if (s
->cpl_enabled
) {
2279 if (s
->options
.cpl_start
!= AC3ENC_OPT_AUTO
) {
2280 cpl_start
= s
->options
.cpl_start
;
2282 cpl_start
= ac3_coupling_start_tab
[s
->channel_mode
-2][s
->bit_alloc
.sr_code
][s
->frame_size_code
/2];
2283 if (cpl_start
< 0) {
2284 if (s
->options
.channel_coupling
== AC3ENC_OPT_AUTO
)
2291 if (s
->cpl_enabled
) {
2292 int i
, cpl_start_band
, cpl_end_band
;
2293 uint8_t *cpl_band_sizes
= s
->cpl_band_sizes
;
2295 cpl_end_band
= s
->bandwidth_code
/ 4 + 3;
2296 cpl_start_band
= av_clip(cpl_start
, 0, FFMIN(cpl_end_band
-1, 15));
2298 s
->num_cpl_subbands
= cpl_end_band
- cpl_start_band
;
2300 s
->num_cpl_bands
= 1;
2301 *cpl_band_sizes
= 12;
2302 for (i
= cpl_start_band
+ 1; i
< cpl_end_band
; i
++) {
2303 if (ff_eac3_default_cpl_band_struct
[i
]) {
2304 *cpl_band_sizes
+= 12;
2308 *cpl_band_sizes
= 12;
2312 s
->start_freq
[CPL_CH
] = cpl_start_band
* 12 + 37;
2313 s
->cpl_end_freq
= cpl_end_band
* 12 + 37;
2314 for (blk
= 0; blk
< s
->num_blocks
; blk
++)
2315 s
->blocks
[blk
].end_freq
[CPL_CH
] = s
->cpl_end_freq
;
2320 static av_cold
int allocate_buffers(AC3EncodeContext
*s
)
2322 AVCodecContext
*avctx
= s
->avctx
;
2324 int channels
= s
->channels
+ 1; /* includes coupling channel */
2325 int channel_blocks
= channels
* s
->num_blocks
;
2326 int total_coefs
= AC3_MAX_COEFS
* channel_blocks
;
2328 if (s
->allocate_sample_buffers(s
))
2331 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->bap_buffer
, total_coefs
,
2332 sizeof(*s
->bap_buffer
), alloc_fail
);
2333 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->bap1_buffer
, total_coefs
,
2334 sizeof(*s
->bap1_buffer
), alloc_fail
);
2335 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, s
->mdct_coef_buffer
, total_coefs
,
2336 sizeof(*s
->mdct_coef_buffer
), alloc_fail
);
2337 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->exp_buffer
, total_coefs
,
2338 sizeof(*s
->exp_buffer
), alloc_fail
);
2339 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->grouped_exp_buffer
, channel_blocks
, 128 *
2340 sizeof(*s
->grouped_exp_buffer
), alloc_fail
);
2341 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->psd_buffer
, total_coefs
,
2342 sizeof(*s
->psd_buffer
), alloc_fail
);
2343 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->band_psd_buffer
, channel_blocks
, 64 *
2344 sizeof(*s
->band_psd_buffer
), alloc_fail
);
2345 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->mask_buffer
, channel_blocks
, 64 *
2346 sizeof(*s
->mask_buffer
), alloc_fail
);
2347 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->qmant_buffer
, total_coefs
,
2348 sizeof(*s
->qmant_buffer
), alloc_fail
);
2349 if (s
->cpl_enabled
) {
2350 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->cpl_coord_exp_buffer
, channel_blocks
, 16 *
2351 sizeof(*s
->cpl_coord_exp_buffer
), alloc_fail
);
2352 FF_ALLOC_ARRAY_OR_GOTO(avctx
, s
->cpl_coord_mant_buffer
, channel_blocks
, 16 *
2353 sizeof(*s
->cpl_coord_mant_buffer
), alloc_fail
);
2355 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
2356 AC3Block
*block
= &s
->blocks
[blk
];
2357 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->mdct_coef
, channels
, sizeof(*block
->mdct_coef
),
2359 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->exp
, channels
, sizeof(*block
->exp
),
2361 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->grouped_exp
, channels
, sizeof(*block
->grouped_exp
),
2363 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->psd
, channels
, sizeof(*block
->psd
),
2365 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->band_psd
, channels
, sizeof(*block
->band_psd
),
2367 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->mask
, channels
, sizeof(*block
->mask
),
2369 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->qmant
, channels
, sizeof(*block
->qmant
),
2371 if (s
->cpl_enabled
) {
2372 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->cpl_coord_exp
, channels
, sizeof(*block
->cpl_coord_exp
),
2374 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->cpl_coord_mant
, channels
, sizeof(*block
->cpl_coord_mant
),
2378 for (ch
= 0; ch
< channels
; ch
++) {
2379 /* arrangement: block, channel, coeff */
2380 block
->grouped_exp
[ch
] = &s
->grouped_exp_buffer
[128 * (blk
* channels
+ ch
)];
2381 block
->psd
[ch
] = &s
->psd_buffer
[AC3_MAX_COEFS
* (blk
* channels
+ ch
)];
2382 block
->band_psd
[ch
] = &s
->band_psd_buffer
[64 * (blk
* channels
+ ch
)];
2383 block
->mask
[ch
] = &s
->mask_buffer
[64 * (blk
* channels
+ ch
)];
2384 block
->qmant
[ch
] = &s
->qmant_buffer
[AC3_MAX_COEFS
* (blk
* channels
+ ch
)];
2385 if (s
->cpl_enabled
) {
2386 block
->cpl_coord_exp
[ch
] = &s
->cpl_coord_exp_buffer
[16 * (blk
* channels
+ ch
)];
2387 block
->cpl_coord_mant
[ch
] = &s
->cpl_coord_mant_buffer
[16 * (blk
* channels
+ ch
)];
2390 /* arrangement: channel, block, coeff */
2391 block
->exp
[ch
] = &s
->exp_buffer
[AC3_MAX_COEFS
* (s
->num_blocks
* ch
+ blk
)];
2392 block
->mdct_coef
[ch
] = &s
->mdct_coef_buffer
[AC3_MAX_COEFS
* (s
->num_blocks
* ch
+ blk
)];
2396 if (!s
->fixed_point
) {
2397 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, s
->fixed_coef_buffer
, total_coefs
,
2398 sizeof(*s
->fixed_coef_buffer
), alloc_fail
);
2399 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
2400 AC3Block
*block
= &s
->blocks
[blk
];
2401 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->fixed_coef
, channels
,
2402 sizeof(*block
->fixed_coef
), alloc_fail
);
2403 for (ch
= 0; ch
< channels
; ch
++)
2404 block
->fixed_coef
[ch
] = &s
->fixed_coef_buffer
[AC3_MAX_COEFS
* (s
->num_blocks
* ch
+ blk
)];
2407 for (blk
= 0; blk
< s
->num_blocks
; blk
++) {
2408 AC3Block
*block
= &s
->blocks
[blk
];
2409 FF_ALLOCZ_ARRAY_OR_GOTO(avctx
, block
->fixed_coef
, channels
,
2410 sizeof(*block
->fixed_coef
), alloc_fail
);
2411 for (ch
= 0; ch
< channels
; ch
++)
2412 block
->fixed_coef
[ch
] = (int32_t *)block
->mdct_coef
[ch
];
2418 return AVERROR(ENOMEM
);
2422 av_cold
int ff_ac3_encode_init(AVCodecContext
*avctx
)
2424 AC3EncodeContext
*s
= avctx
->priv_data
;
2425 int ret
, frame_size_58
;
2429 s
->eac3
= avctx
->codec_id
== AV_CODEC_ID_EAC3
;
2431 ff_ac3_common_init();
2433 ret
= validate_options(s
);
2437 avctx
->frame_size
= AC3_BLOCK_SIZE
* s
->num_blocks
;
2438 avctx
->initial_padding
= AC3_BLOCK_SIZE
;
2440 s
->bitstream_mode
= avctx
->audio_service_type
;
2441 if (s
->bitstream_mode
== AV_AUDIO_SERVICE_TYPE_KARAOKE
)
2442 s
->bitstream_mode
= 0x7;
2444 s
->bits_written
= 0;
2445 s
->samples_written
= 0;
2447 /* calculate crc_inv for both possible frame sizes */
2448 frame_size_58
= (( s
->frame_size
>> 2) + ( s
->frame_size
>> 4)) << 1;
2449 s
->crc_inv
[0] = pow_poly((CRC16_POLY
>> 1), (8 * frame_size_58
) - 16, CRC16_POLY
);
2450 if (s
->bit_alloc
.sr_code
== 1) {
2451 frame_size_58
= (((s
->frame_size
+2) >> 2) + ((s
->frame_size
+2) >> 4)) << 1;
2452 s
->crc_inv
[1] = pow_poly((CRC16_POLY
>> 1), (8 * frame_size_58
) - 16, CRC16_POLY
);
2455 /* set function pointers */
2456 if (CONFIG_AC3_FIXED_ENCODER
&& s
->fixed_point
) {
2457 s
->mdct_end
= ff_ac3_fixed_mdct_end
;
2458 s
->mdct_init
= ff_ac3_fixed_mdct_init
;
2459 s
->allocate_sample_buffers
= ff_ac3_fixed_allocate_sample_buffers
;
2460 } else if (CONFIG_AC3_ENCODER
|| CONFIG_EAC3_ENCODER
) {
2461 s
->mdct_end
= ff_ac3_float_mdct_end
;
2462 s
->mdct_init
= ff_ac3_float_mdct_init
;
2463 s
->allocate_sample_buffers
= ff_ac3_float_allocate_sample_buffers
;
2465 if (CONFIG_EAC3_ENCODER
&& s
->eac3
)
2466 s
->output_frame_header
= ff_eac3_output_frame_header
;
2468 s
->output_frame_header
= ac3_output_frame_header
;
2476 ret
= s
->mdct_init(s
);
2480 ret
= allocate_buffers(s
);
2484 ff_audiodsp_init(&s
->adsp
);
2485 ff_me_cmp_init(&s
->mecc
, avctx
);
2486 ff_ac3dsp_init(&s
->ac3dsp
, avctx
->flags
& CODEC_FLAG_BITEXACT
);
2492 ff_ac3_encode_close(avctx
);