WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavcodec/ac3enc.c

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* The simplest AC-3 encoder
		3	* Copyright (c) 2000 Fabrice Bellard
		4	* Copyright (c) 2006-2010 Justin Ruggles
		5	* Copyright (c) 2006-2010 Prakash Punnoor
		6	*
		7	* This file is part of FFmpeg.
		8	*
		9	* FFmpeg is free software; you can redistribute it and/or
		10	* modify it under the terms of the GNU Lesser General Public
		11	* License as published by the Free Software Foundation; either
		12	* version 2.1 of the License, or (at your option) any later version.
		13	*
		14	* FFmpeg is distributed in the hope that it will be useful,
		15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		17	* Lesser General Public License for more details.
		18	*
		19	* You should have received a copy of the GNU Lesser General Public
		20	* License along with FFmpeg; if not, write to the Free Software
		21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		22	*/
		23
		24	/**
		25	* @file
		26	* The simplest AC-3 encoder.
		27	*/
		28
		29	#include
		30
		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"
		38	#include "avcodec.h"
		39	#include "put_bits.h"
		40	#include "ac3dsp.h"
		41	#include "ac3.h"
		42	#include "fft.h"
		43	#include "ac3enc.h"
		44	#include "eac3enc.h"
		45
		46	typedef struct AC3Mant {
		47	int16_t qmant1_ptr, qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
		48	int mant1_cnt, mant2_cnt, mant4_cnt; ///< mantissa counts for bap=1,2,4
		49	} AC3Mant;
		50
		51	#define CMIXLEV_NUM_OPTIONS 3
		52	static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = {
		53	LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB
		54	};
		55
		56	#define SURMIXLEV_NUM_OPTIONS 3
		57	static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = {
		58	LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO
		59	};
		60
		61	#define EXTMIXLEV_NUM_OPTIONS 8
		62	static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = {
		63	LEVEL_PLUS_3DB, LEVEL_PLUS_1POINT5DB, LEVEL_ONE, LEVEL_MINUS_4POINT5DB,
		64	LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB, LEVEL_ZERO
		65	};
		66
		67
		68	/**
		69	* LUT for number of exponent groups.
		70	* exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
		71	*/
		72	static uint8_t exponent_group_tab[2][3][256];
		73
		74
		75	/**
		76	* List of supported channel layouts.
		77	*/
		78	const uint64_t ff_ac3_channel_layouts[19] = {
		79	AV_CH_LAYOUT_MONO,
		80	AV_CH_LAYOUT_STEREO,
		81	AV_CH_LAYOUT_2_1,
		82	AV_CH_LAYOUT_SURROUND,
		83	AV_CH_LAYOUT_2_2,
		84	AV_CH_LAYOUT_QUAD,
		85	AV_CH_LAYOUT_4POINT0,
		86	AV_CH_LAYOUT_5POINT0,
		87	AV_CH_LAYOUT_5POINT0_BACK,
		88	(AV_CH_LAYOUT_MONO \| AV_CH_LOW_FREQUENCY),
		89	(AV_CH_LAYOUT_STEREO \| AV_CH_LOW_FREQUENCY),
		90	(AV_CH_LAYOUT_2_1 \| AV_CH_LOW_FREQUENCY),
		91	(AV_CH_LAYOUT_SURROUND \| AV_CH_LOW_FREQUENCY),
		92	(AV_CH_LAYOUT_2_2 \| AV_CH_LOW_FREQUENCY),
		93	(AV_CH_LAYOUT_QUAD \| AV_CH_LOW_FREQUENCY),
		94	(AV_CH_LAYOUT_4POINT0 \| AV_CH_LOW_FREQUENCY),
		95	AV_CH_LAYOUT_5POINT1,
		96	AV_CH_LAYOUT_5POINT1_BACK,
		97
		98	};
		99
		100
		101	/**
		102	* LUT to select the bandwidth code based on the bit rate, sample rate, and
		103	* number of full-bandwidth channels.
		104	* bandwidth_tab[fbw_channels-1][sample rate code][bit rate code]
		105	*/
		106	static const uint8_t ac3_bandwidth_tab[5][3][19] = {
		107	// 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
		108
		109	{ { 0, 0, 0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
		110	{ 0, 0, 0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
		111	{ 0, 0, 0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
		112
		113	{ { 0, 0, 0, 0, 0, 0, 0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
		114	{ 0, 0, 0, 0, 0, 0, 4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
		115	{ 0, 0, 0, 0, 0, 0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
		116
		117	{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 },
		118	{ 0, 0, 0, 0, 0, 0, 0, 0, 4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 },
		119	{ 0, 0, 0, 0, 0, 0, 0, 0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } },
		120
		121	{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 32, 48, 48, 48, 48, 48, 48 },
		122	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 28, 36, 56, 56, 56, 56, 56, 56 },
		123	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } },
		124
		125	{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 20, 32, 40, 48, 48, 48, 48 },
		126	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 36, 44, 56, 56, 56, 56 },
		127	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 44, 60, 60, 60, 60, 60, 60 } }
		128	};
		129
		130
		131	/**
		132	* LUT to select the coupling start band based on the bit rate, sample rate, and
		133	* number of full-bandwidth channels. -1 = coupling off
		134	* ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]
		135	*
		136	* TODO: more testing for optimal parameters.
		137	* multi-channel tests at 44.1kHz and 32kHz.
		138	*/
		139	static const int8_t ac3_coupling_start_tab[6][3][19] = {
		140	// 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
		141
		142	// 2/0
		143	{ { 0, 0, 0, 0, 0, 0, 0, 1, 1, 7, 8, 11, 12, -1, -1, -1, -1, -1, -1 },
		144	{ 0, 0, 0, 0, 0, 0, 1, 3, 5, 7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },
		145	{ 0, 0, 0, 0, 1, 2, 2, 9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
		146
		147	// 3/0
		148	{ { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -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	{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
		151
		152	// 2/1 - untested
		153	{ { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -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	{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
		156
		157	// 3/1
		158	{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
		159	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
		160	{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
		161
		162	// 2/2 - untested
		163	{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
		164	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
		165	{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
		166
		167	// 3/2
		168	{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
		169	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
		170	{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
		171	};
		172
		173
		174	/**
		175	* Adjust the frame size to make the average bit rate match the target bit rate.
		176	* This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3.
		177	*
		178	* @param s AC-3 encoder private context
		179	*/
		180	void ff_ac3_adjust_frame_size(AC3EncodeContext *s)
		181	{
		182	while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
		183	s->bits_written -= s->bit_rate;
		184	s->samples_written -= s->sample_rate;
		185	}
		186	s->frame_size = s->frame_size_min +
		187	2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
		188	s->bits_written += s->frame_size * 8;
		189	s->samples_written += AC3_BLOCK_SIZE * s->num_blocks;
		190	}
		191
		192
		193	/**
		194	* Set the initial coupling strategy parameters prior to coupling analysis.
		195	*
		196	* @param s AC-3 encoder private context
		197	*/
		198	void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
		199	{
		200	int blk, ch;
		201	int got_cpl_snr;
		202	int num_cpl_blocks;
		203
		204	/* set coupling use flags for each block/channel */
		205	/* TODO: turn coupling on/off and adjust start band based on bit usage */
		206	for (blk = 0; blk < s->num_blocks; blk++) {
		207	AC3Block *block = &s->blocks[blk];
		208	for (ch = 1; ch <= s->fbw_channels; ch++)
		209	block->channel_in_cpl[ch] = s->cpl_on;
		210	}
		211
		212	/* enable coupling for each block if at least 2 channels have coupling
		213	enabled for that block */
		214	got_cpl_snr = 0;
		215	num_cpl_blocks = 0;
		216	for (blk = 0; blk < s->num_blocks; blk++) {
		217	AC3Block *block = &s->blocks[blk];
		218	block->num_cpl_channels = 0;
		219	for (ch = 1; ch <= s->fbw_channels; ch++)
		220	block->num_cpl_channels += block->channel_in_cpl[ch];
		221	block->cpl_in_use = block->num_cpl_channels > 1;
		222	num_cpl_blocks += block->cpl_in_use;
		223	if (!block->cpl_in_use) {
		224	block->num_cpl_channels = 0;
		225	for (ch = 1; ch <= s->fbw_channels; ch++)
		226	block->channel_in_cpl[ch] = 0;
		227	}
		228
		229	block->new_cpl_strategy = !blk;
		230	if (blk) {
		231	for (ch = 1; ch <= s->fbw_channels; ch++) {
		232	if (block->channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
		233	block->new_cpl_strategy = 1;
		234	break;
		235	}
		236	}
		237	}
		238	block->new_cpl_leak = block->new_cpl_strategy;
		239
		240	if (!blk \|\| (block->cpl_in_use && !got_cpl_snr)) {
		241	block->new_snr_offsets = 1;
		242	if (block->cpl_in_use)
		243	got_cpl_snr = 1;
		244	} else {
		245	block->new_snr_offsets = 0;
		246	}
		247	}
		248	if (!num_cpl_blocks)
		249	s->cpl_on = 0;
		250
		251	/* set bandwidth for each channel */
		252	for (blk = 0; blk < s->num_blocks; blk++) {
		253	AC3Block *block = &s->blocks[blk];
		254	for (ch = 1; ch <= s->fbw_channels; ch++) {
		255	if (block->channel_in_cpl[ch])
		256	block->end_freq[ch] = s->start_freq[CPL_CH];
		257	else
		258	block->end_freq[ch] = s->bandwidth_code * 3 + 73;
		259	}
		260	}
		261	}
		262
		263
		264	/**
		265	* Apply stereo rematrixing to coefficients based on rematrixing flags.
		266	*
		267	* @param s AC-3 encoder private context
		268	*/
		269	void ff_ac3_apply_rematrixing(AC3EncodeContext *s)
		270	{
		271	int nb_coefs;
		272	int blk, bnd, i;
		273	int start, end;
		274	uint8_t *flags = NULL;
		275
		276	if (!s->rematrixing_enabled)
		277	return;
		278
		279	for (blk = 0; blk < s->num_blocks; blk++) {
		280	AC3Block *block = &s->blocks[blk];
		281	if (block->new_rematrixing_strategy)
		282	flags = block->rematrixing_flags;
		283	nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
		284	for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
		285	if (flags[bnd]) {
		286	start = ff_ac3_rematrix_band_tab[bnd];
		287	end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
		288	for (i = start; i < end; i++) {
		289	int32_t lt = block->fixed_coef[1][i];
		290	int32_t rt = block->fixed_coef[2][i];
		291	block->fixed_coef[1][i] = (lt + rt) >> 1;
		292	block->fixed_coef[2][i] = (lt - rt) >> 1;
		293	}
		294	}
		295	}
		296	}
		297	}
		298
		299
		300	/*
		301	* Initialize exponent tables.
		302	*/
		303	static av_cold void exponent_init(AC3EncodeContext *s)
		304	{
		305	int expstr, i, grpsize;
		306
		307	for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {
		308	grpsize = 3 << expstr;
		309	for (i = 12; i < 256; i++) {
		310	exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize;
		311	exponent_group_tab[1][expstr][i] = (i ) / grpsize;
		312	}
		313	}
		314	/* LFE */
		315	exponent_group_tab[0][0][7] = 2;
		316
		317	if (CONFIG_EAC3_ENCODER && s->eac3)
		318	ff_eac3_exponent_init();
		319	}
		320
		321
		322	/*
		323	* Extract exponents from the MDCT coefficients.
		324	*/
		325	static void extract_exponents(AC3EncodeContext *s)
		326	{
		327	int ch = !s->cpl_on;
		328	int chan_size = AC3_MAX_COEFS * s->num_blocks * (s->channels - ch + 1);
		329	AC3Block *block = &s->blocks[0];
		330
		331	s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], chan_size);
		332	}
		333
		334
		335	/**
		336	* Exponent Difference Threshold.
		337	* New exponents are sent if their SAD exceed this number.
		338	*/
		339	#define EXP_DIFF_THRESHOLD 500
		340
		341	/**
		342	* Table used to select exponent strategy based on exponent reuse block interval.
		343	*/
		344	static const uint8_t exp_strategy_reuse_tab[4][6] = {
		345	{ EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
		346	{ EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
		347	{ EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
		348	{ EXP_D45, EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15 }
		349	};
		350
		351	/*
		352	* Calculate exponent strategies for all channels.
		353	* Array arrangement is reversed to simplify the per-channel calculation.
		354	*/
		355	static void compute_exp_strategy(AC3EncodeContext *s)
		356	{
		357	int ch, blk, blk1;
		358
		359	for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) {
		360	uint8_t *exp_strategy = s->exp_strategy[ch];
		361	uint8_t *exp = s->blocks[0].exp[ch];
		362	int exp_diff;
		363
		364	/* estimate if the exponent variation & decide if they should be
		365	reused in the next frame */
		366	exp_strategy[0] = EXP_NEW;
		367	exp += AC3_MAX_COEFS;
		368	for (blk = 1; blk < s->num_blocks; blk++, exp += AC3_MAX_COEFS) {
		369	if (ch == CPL_CH) {
		370	if (!s->blocks[blk-1].cpl_in_use) {
		371	exp_strategy[blk] = EXP_NEW;
		372	continue;
		373	} else if (!s->blocks[blk].cpl_in_use) {
		374	exp_strategy[blk] = EXP_REUSE;
		375	continue;
		376	}
		377	} else if (s->blocks[blk].channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
		378	exp_strategy[blk] = EXP_NEW;
		379	continue;
		380	}
		381	exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
		382	exp_strategy[blk] = EXP_REUSE;
		383	if (ch == CPL_CH && exp_diff > (EXP_DIFF_THRESHOLD * (s->blocks[blk].end_freq[ch] - s->start_freq[ch]) / AC3_MAX_COEFS))
		384	exp_strategy[blk] = EXP_NEW;
		385	else if (ch > CPL_CH && exp_diff > EXP_DIFF_THRESHOLD)
		386	exp_strategy[blk] = EXP_NEW;
		387	}
		388
		389	/* now select the encoding strategy type : if exponents are often
		390	recoded, we use a coarse encoding */
		391	blk = 0;
		392	while (blk < s->num_blocks) {
		393	blk1 = blk + 1;
		394	while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE)
		395	blk1++;
		396	exp_strategy[blk] = exp_strategy_reuse_tab[s->num_blks_code][blk1-blk-1];
		397	blk = blk1;
		398	}
		399	}
		400	if (s->lfe_on) {
		401	ch = s->lfe_channel;
		402	s->exp_strategy[ch][0] = EXP_D15;
		403	for (blk = 1; blk < s->num_blocks; blk++)
		404	s->exp_strategy[ch][blk] = EXP_REUSE;
		405	}
		406
		407	/* for E-AC-3, determine frame exponent strategy */
		408	if (CONFIG_EAC3_ENCODER && s->eac3)
		409	ff_eac3_get_frame_exp_strategy(s);
		410	}
		411
		412
		413	/**
		414	* Update the exponents so that they are the ones the decoder will decode.
		415	*
		416	* @param[in,out] exp array of exponents for 1 block in 1 channel
		417	* @param nb_exps number of exponents in active bandwidth
		418	* @param exp_strategy exponent strategy for the block
		419	* @param cpl indicates if the block is in the coupling channel
		420	*/
		421	static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,
		422	int cpl)
		423	{
		424	int nb_groups, i, k;
		425
		426	nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;
		427
		428	/* for each group, compute the minimum exponent */
		429	switch(exp_strategy) {
		430	case EXP_D25:
		431	for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
		432	uint8_t exp_min = exp[k];
		433	if (exp[k+1] < exp_min)
		434	exp_min = exp[k+1];
		435	exp[i-cpl] = exp_min;
		436	k += 2;
		437	}
		438	break;
		439	case EXP_D45:
		440	for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
		441	uint8_t exp_min = exp[k];
		442	if (exp[k+1] < exp_min)
		443	exp_min = exp[k+1];
		444	if (exp[k+2] < exp_min)
		445	exp_min = exp[k+2];
		446	if (exp[k+3] < exp_min)
		447	exp_min = exp[k+3];
		448	exp[i-cpl] = exp_min;
		449	k += 4;
		450	}
		451	break;
		452	}
		453
		454	/* constraint for DC exponent */
		455	if (!cpl && exp[0] > 15)
		456	exp[0] = 15;
		457
		458	/* decrease the delta between each groups to within 2 so that they can be
		459	differentially encoded */
		460	for (i = 1; i <= nb_groups; i++)
		461	exp[i] = FFMIN(exp[i], exp[i-1] + 2);
		462	i--;
		463	while (--i >= 0)
		464	exp[i] = FFMIN(exp[i], exp[i+1] + 2);
		465
		466	if (cpl)
		467	exp[-1] = exp[0] & ~1;
		468
		469	/* now we have the exponent values the decoder will see */
		470	switch (exp_strategy) {
		471	case EXP_D25:
		472	for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) {
		473	uint8_t exp1 = exp[i-cpl];
		474	exp[k--] = exp1;
		475	exp[k--] = exp1;
		476	}
		477	break;
		478	case EXP_D45:
		479	for (i = nb_groups, k = (nb_groups * 4)-cpl; i > 0; i--) {
		480	exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i-cpl];
		481	k -= 4;
		482	}
		483	break;
		484	}
		485	}
		486
		487
		488	/*
		489	* Encode exponents from original extracted form to what the decoder will see.
		490	* This copies and groups exponents based on exponent strategy and reduces
		491	* deltas between adjacent exponent groups so that they can be differentially
		492	* encoded.
		493	*/
		494	static void encode_exponents(AC3EncodeContext *s)
		495	{
		496	int blk, blk1, ch, cpl;
		497	uint8_t exp, exp_strategy;
		498	int nb_coefs, num_reuse_blocks;
		499
		500	for (ch = !s->cpl_on; ch <= s->channels; ch++) {
		501	exp = s->blocks[0].exp[ch] + s->start_freq[ch];
		502	exp_strategy = s->exp_strategy[ch];
		503
		504	cpl = (ch == CPL_CH);
		505	blk = 0;
		506	while (blk < s->num_blocks) {
		507	AC3Block *block = &s->blocks[blk];
		508	if (cpl && !block->cpl_in_use) {
		509	exp += AC3_MAX_COEFS;
		510	blk++;
		511	continue;
		512	}
		513	nb_coefs = block->end_freq[ch] - s->start_freq[ch];
		514	blk1 = blk + 1;
		515
		516	/* count the number of EXP_REUSE blocks after the current block
		517	and set exponent reference block numbers */
		518	s->exp_ref_block[ch][blk] = blk;
		519	while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE) {
		520	s->exp_ref_block[ch][blk1] = blk;
		521	blk1++;
		522	}
		523	num_reuse_blocks = blk1 - blk - 1;
		524
		525	/* for the EXP_REUSE case we select the min of the exponents */
		526	s->ac3dsp.ac3_exponent_min(exp-s->start_freq[ch], num_reuse_blocks,
		527	AC3_MAX_COEFS);
		528
		529	encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk], cpl);
		530
		531	exp += AC3_MAX_COEFS * (num_reuse_blocks + 1);
		532	blk = blk1;
		533	}
		534	}
		535
		536	/* reference block numbers have been changed, so reset ref_bap_set */
		537	s->ref_bap_set = 0;
		538	}
		539
		540
		541	/*
		542	* Count exponent bits based on bandwidth, coupling, and exponent strategies.
		543	*/
		544	static int count_exponent_bits(AC3EncodeContext *s)
		545	{
		546	int blk, ch;
		547	int nb_groups, bit_count;
		548
		549	bit_count = 0;
		550	for (blk = 0; blk < s->num_blocks; blk++) {
		551	AC3Block *block = &s->blocks[blk];
		552	for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
		553	int exp_strategy = s->exp_strategy[ch][blk];
		554	int cpl = (ch == CPL_CH);
		555	int nb_coefs = block->end_freq[ch] - s->start_freq[ch];
		556
		557	if (exp_strategy == EXP_REUSE)
		558	continue;
		559
		560	nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_coefs];
		561	bit_count += 4 + (nb_groups * 7);
		562	}
		563	}
		564
		565	return bit_count;
		566	}
		567
		568
		569	/**
		570	* Group exponents.
		571	* 3 delta-encoded exponents are in each 7-bit group. The number of groups
		572	* varies depending on exponent strategy and bandwidth.
		573	*
		574	* @param s AC-3 encoder private context
		575	*/
		576	void ff_ac3_group_exponents(AC3EncodeContext *s)
		577	{
		578	int blk, ch, i, cpl;
		579	int group_size, nb_groups;
		580	uint8_t *p;
		581	int delta0, delta1, delta2;
		582	int exp0, exp1;
		583
		584	for (blk = 0; blk < s->num_blocks; blk++) {
		585	AC3Block *block = &s->blocks[blk];
		586	for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
		587	int exp_strategy = s->exp_strategy[ch][blk];
		588	if (exp_strategy == EXP_REUSE)
		589	continue;
		590	cpl = (ch == CPL_CH);
		591	group_size = exp_strategy + (exp_strategy == EXP_D45);
		592	nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]];
		593	p = block->exp[ch] + s->start_freq[ch] - cpl;
		594
		595	/* DC exponent */
		596	exp1 = *p++;
		597	block->grouped_exp[ch][0] = exp1;
		598
		599	/* remaining exponents are delta encoded */
		600	for (i = 1; i <= nb_groups; i++) {
		601	/* merge three delta in one code */
		602	exp0 = exp1;
		603	exp1 = p[0];
		604	p += group_size;
		605	delta0 = exp1 - exp0 + 2;
		606	av_assert2(delta0 >= 0 && delta0 <= 4);
		607
		608	exp0 = exp1;
		609	exp1 = p[0];
		610	p += group_size;
		611	delta1 = exp1 - exp0 + 2;
		612	av_assert2(delta1 >= 0 && delta1 <= 4);
		613
		614	exp0 = exp1;
		615	exp1 = p[0];
		616	p += group_size;
		617	delta2 = exp1 - exp0 + 2;
		618	av_assert2(delta2 >= 0 && delta2 <= 4);
		619
		620	block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
		621	}
		622	}
		623	}
		624	}
		625
		626
		627	/**
		628	* Calculate final exponents from the supplied MDCT coefficients and exponent shift.
		629	* Extract exponents from MDCT coefficients, calculate exponent strategies,
		630	* and encode final exponents.
		631	*
		632	* @param s AC-3 encoder private context
		633	*/
		634	void ff_ac3_process_exponents(AC3EncodeContext *s)
		635	{
		636	extract_exponents(s);
		637
		638	compute_exp_strategy(s);
		639
		640	encode_exponents(s);
		641
		642	emms_c();
		643	}
		644
		645
		646	/*
		647	* Count frame bits that are based solely on fixed parameters.
		648	* This only has to be run once when the encoder is initialized.
		649	*/
		650	static void count_frame_bits_fixed(AC3EncodeContext *s)
		651	{
		652	static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
		653	int blk;
		654	int frame_bits;
		655
		656	/* assumptions:
		657	* no dynamic range codes
		658	* bit allocation parameters do not change between blocks
		659	* no delta bit allocation
		660	* no skipped data
		661	* no auxiliary data
		662	* no E-AC-3 metadata
		663	*/
		664
		665	/* header */
		666	frame_bits = 16; /* sync info */
		667	if (s->eac3) {
		668	/* bitstream info header */
		669	frame_bits += 35;
		670	frame_bits += 1 + 1;
		671	if (s->num_blocks != 0x6)
		672	frame_bits++;
		673	frame_bits++;
		674	/* audio frame header */
		675	if (s->num_blocks == 6)
		676	frame_bits += 2;
		677	frame_bits += 10;
		678	/* exponent strategy */
		679	if (s->use_frame_exp_strategy)
		680	frame_bits += 5 * s->fbw_channels;
		681	else
		682	frame_bits += s->num_blocks * 2 * s->fbw_channels;
		683	if (s->lfe_on)
		684	frame_bits += s->num_blocks;
		685	/* converter exponent strategy */
		686	if (s->num_blks_code != 0x3)
		687	frame_bits++;
		688	else
		689	frame_bits += s->fbw_channels * 5;
		690	/* snr offsets */
		691	frame_bits += 10;
		692	/* block start info */
		693	if (s->num_blocks != 1)
		694	frame_bits++;
		695	} else {
		696	frame_bits += 49;
		697	frame_bits += frame_bits_inc[s->channel_mode];
		698	}
		699
		700	/* audio blocks */
		701	for (blk = 0; blk < s->num_blocks; blk++) {
		702	if (!s->eac3) {
		703	/* block switch flags */
		704	frame_bits += s->fbw_channels;
		705
		706	/* dither flags */
		707	frame_bits += s->fbw_channels;
		708	}
		709
		710	/* dynamic range */
		711	frame_bits++;
		712
		713	/* spectral extension */
		714	if (s->eac3)
		715	frame_bits++;
		716
		717	if (!s->eac3) {
		718	/* exponent strategy */
		719	frame_bits += 2 * s->fbw_channels;
		720	if (s->lfe_on)
		721	frame_bits++;
		722
		723	/* bit allocation params */
		724	frame_bits++;
		725	if (!blk)
		726	frame_bits += 2 + 2 + 2 + 2 + 3;
		727	}
		728
		729	/* converter snr offset */
		730	if (s->eac3)
		731	frame_bits++;
		732
		733	if (!s->eac3) {
		734	/* delta bit allocation */
		735	frame_bits++;
		736
		737	/* skipped data */
		738	frame_bits++;
		739	}
		740	}
		741
		742	/* auxiliary data */
		743	frame_bits++;
		744
		745	/* CRC */
		746	frame_bits += 1 + 16;
		747
		748	s->frame_bits_fixed = frame_bits;
		749	}
		750
		751
		752	/*
		753	* Initialize bit allocation.
		754	* Set default parameter codes and calculate parameter values.
		755	*/
		756	static av_cold void bit_alloc_init(AC3EncodeContext *s)
		757	{
		758	int ch;
		759
		760	/* init default parameters */
		761	s->slow_decay_code = 2;
		762	s->fast_decay_code = 1;
		763	s->slow_gain_code = 1;
		764	s->db_per_bit_code = s->eac3 ? 2 : 3;
		765	s->floor_code = 7;
		766	for (ch = 0; ch <= s->channels; ch++)
		767	s->fast_gain_code[ch] = 4;
		768
		769	/* initial snr offset */
		770	s->coarse_snr_offset = 40;
		771
		772	/* compute real values */
		773	/* currently none of these values change during encoding, so we can just
		774	set them once at initialization */
		775	s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->bit_alloc.sr_shift;
		776	s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->bit_alloc.sr_shift;
		777	s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code];
		778	s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
		779	s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code];
		780	s->bit_alloc.cpl_fast_leak = 0;
		781	s->bit_alloc.cpl_slow_leak = 0;
		782
		783	count_frame_bits_fixed(s);
		784	}
		785
		786
		787	/*
		788	* Count the bits used to encode the frame, minus exponents and mantissas.
		789	* Bits based on fixed parameters have already been counted, so now we just
		790	* have to add the bits based on parameters that change during encoding.
		791	*/
		792	static void count_frame_bits(AC3EncodeContext *s)
		793	{
		794	AC3EncOptions *opt = &s->options;
		795	int blk, ch;
		796	int frame_bits = 0;
		797
		798	/* header */
		799	if (s->eac3) {
		800	if (opt->eac3_mixing_metadata) {
		801	if (s->channel_mode > AC3_CHMODE_STEREO)
		802	frame_bits += 2;
		803	if (s->has_center)
		804	frame_bits += 6;
		805	if (s->has_surround)
		806	frame_bits += 6;
		807	frame_bits += s->lfe_on;
		808	frame_bits += 1 + 1 + 2;
		809	if (s->channel_mode < AC3_CHMODE_STEREO)
		810	frame_bits++;
		811	frame_bits++;
		812	}
		813	if (opt->eac3_info_metadata) {
		814	frame_bits += 3 + 1 + 1;
		815	if (s->channel_mode == AC3_CHMODE_STEREO)
		816	frame_bits += 2 + 2;
		817	if (s->channel_mode >= AC3_CHMODE_2F2R)
		818	frame_bits += 2;
		819	frame_bits++;
		820	if (opt->audio_production_info)
		821	frame_bits += 5 + 2 + 1;
		822	frame_bits++;
		823	}
		824	/* coupling */
		825	if (s->channel_mode > AC3_CHMODE_MONO) {
		826	frame_bits++;
		827	for (blk = 1; blk < s->num_blocks; blk++) {
		828	AC3Block *block = &s->blocks[blk];
		829	frame_bits++;
		830	if (block->new_cpl_strategy)
		831	frame_bits++;
		832	}
		833	}
		834	/* coupling exponent strategy */
		835	if (s->cpl_on) {
		836	if (s->use_frame_exp_strategy) {
		837	frame_bits += 5 * s->cpl_on;
		838	} else {
		839	for (blk = 0; blk < s->num_blocks; blk++)
		840	frame_bits += 2 * s->blocks[blk].cpl_in_use;
		841	}
		842	}
		843	} else {
		844	if (opt->audio_production_info)
		845	frame_bits += 7;
		846	if (s->bitstream_id == 6) {
		847	if (opt->extended_bsi_1)
		848	frame_bits += 14;
		849	if (opt->extended_bsi_2)
		850	frame_bits += 14;
		851	}
		852	}
		853
		854	/* audio blocks */
		855	for (blk = 0; blk < s->num_blocks; blk++) {
		856	AC3Block *block = &s->blocks[blk];
		857
		858	/* coupling strategy */
		859	if (!s->eac3)
		860	frame_bits++;
		861	if (block->new_cpl_strategy) {
		862	if (!s->eac3)
		863	frame_bits++;
		864	if (block->cpl_in_use) {
		865	if (s->eac3)
		866	frame_bits++;
		867	if (!s->eac3 \|\| s->channel_mode != AC3_CHMODE_STEREO)
		868	frame_bits += s->fbw_channels;
		869	if (s->channel_mode == AC3_CHMODE_STEREO)
		870	frame_bits++;
		871	frame_bits += 4 + 4;
		872	if (s->eac3)
		873	frame_bits++;
		874	else
		875	frame_bits += s->num_cpl_subbands - 1;
		876	}
		877	}
		878
		879	/* coupling coordinates */
		880	if (block->cpl_in_use) {
		881	for (ch = 1; ch <= s->fbw_channels; ch++) {
		882	if (block->channel_in_cpl[ch]) {
		883	if (!s->eac3 \|\| block->new_cpl_coords[ch] != 2)
		884	frame_bits++;
		885	if (block->new_cpl_coords[ch]) {
		886	frame_bits += 2;
		887	frame_bits += (4 + 4) * s->num_cpl_bands;
		888	}
		889	}
		890	}
		891	}
		892
		893	/* stereo rematrixing */
		894	if (s->channel_mode == AC3_CHMODE_STEREO) {
		895	if (!s->eac3 \|\| blk > 0)
		896	frame_bits++;
		897	if (s->blocks[blk].new_rematrixing_strategy)
		898	frame_bits += block->num_rematrixing_bands;
		899	}
		900
		901	/* bandwidth codes & gain range */
		902	for (ch = 1; ch <= s->fbw_channels; ch++) {
		903	if (s->exp_strategy[ch][blk] != EXP_REUSE) {
		904	if (!block->channel_in_cpl[ch])
		905	frame_bits += 6;
		906	frame_bits += 2;
		907	}
		908	}
		909
		910	/* coupling exponent strategy */
		911	if (!s->eac3 && block->cpl_in_use)
		912	frame_bits += 2;
		913
		914	/* snr offsets and fast gain codes */
		915	if (!s->eac3) {
		916	frame_bits++;
		917	if (block->new_snr_offsets)
		918	frame_bits += 6 + (s->channels + block->cpl_in_use) * (4 + 3);
		919	}
		920
		921	/* coupling leak info */
		922	if (block->cpl_in_use) {
		923	if (!s->eac3 \|\| block->new_cpl_leak != 2)
		924	frame_bits++;
		925	if (block->new_cpl_leak)
		926	frame_bits += 3 + 3;
		927	}
		928	}
		929
		930	s->frame_bits = s->frame_bits_fixed + frame_bits;
		931	}
		932
		933
		934	/*
		935	* Calculate masking curve based on the final exponents.
		936	* Also calculate the power spectral densities to use in future calculations.
		937	*/
		938	static void bit_alloc_masking(AC3EncodeContext *s)
		939	{
		940	int blk, ch;
		941
		942	for (blk = 0; blk < s->num_blocks; blk++) {
		943	AC3Block *block = &s->blocks[blk];
		944	for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
		945	/* We only need psd and mask for calculating bap.
		946	Since we currently do not calculate bap when exponent
		947	strategy is EXP_REUSE we do not need to calculate psd or mask. */
		948	if (s->exp_strategy[ch][blk] != EXP_REUSE) {
		949	ff_ac3_bit_alloc_calc_psd(block->exp[ch], s->start_freq[ch],
		950	block->end_freq[ch], block->psd[ch],
		951	block->band_psd[ch]);
		952	ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch],
		953	s->start_freq[ch], block->end_freq[ch],
		954	ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
		955	ch == s->lfe_channel,
		956	DBA_NONE, 0, NULL, NULL, NULL,
		957	block->mask[ch]);
		958	}
		959	}
		960	}
		961	}
		962
		963
		964	/*
		965	* Ensure that bap for each block and channel point to the current bap_buffer.
		966	* They may have been switched during the bit allocation search.
		967	*/
		968	static void reset_block_bap(AC3EncodeContext *s)
		969	{
		970	int blk, ch;
		971	uint8_t *ref_bap;
		972
		973	if (s->ref_bap[0][0] == s->bap_buffer && s->ref_bap_set)
		974	return;
		975
		976	ref_bap = s->bap_buffer;
		977	for (ch = 0; ch <= s->channels; ch++) {
		978	for (blk = 0; blk < s->num_blocks; blk++)
		979	s->ref_bap[ch][blk] = ref_bap + AC3_MAX_COEFS * s->exp_ref_block[ch][blk];
		980	ref_bap += AC3_MAX_COEFS * s->num_blocks;
		981	}
		982	s->ref_bap_set = 1;
		983	}
		984
		985
		986	/**
		987	* Initialize mantissa counts.
		988	* These are set so that they are padded to the next whole group size when bits
		989	* are counted in compute_mantissa_size.
		990	*
		991	* @param[in,out] mant_cnt running counts for each bap value for each block
		992	*/
		993	static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
		994	{
		995	int blk;
		996
		997	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
		998	memset(mant_cnt[blk], 0, sizeof(mant_cnt[blk]));
		999	mant_cnt[blk][1] = mant_cnt[blk][2] = 2;
		1000	mant_cnt[blk][4] = 1;
		1001	}
		1002	}
		1003
		1004
		1005	/**
		1006	* Update mantissa bit counts for all blocks in 1 channel in a given bandwidth
		1007	* range.
		1008	*
		1009	* @param s AC-3 encoder private context
		1010	* @param ch channel index
		1011	* @param[in,out] mant_cnt running counts for each bap value for each block
		1012	* @param start starting coefficient bin
		1013	* @param end ending coefficient bin
		1014	*/
		1015	static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch,
		1016	uint16_t mant_cnt[AC3_MAX_BLOCKS][16],
		1017	int start, int end)
		1018	{
		1019	int blk;
		1020
		1021	for (blk = 0; blk < s->num_blocks; blk++) {
		1022	AC3Block *block = &s->blocks[blk];
		1023	if (ch == CPL_CH && !block->cpl_in_use)
		1024	continue;
		1025	s->ac3dsp.update_bap_counts(mant_cnt[blk],
		1026	s->ref_bap[ch][blk] + start,
		1027	FFMIN(end, block->end_freq[ch]) - start);
		1028	}
		1029	}
		1030
		1031
		1032	/*
		1033	* Count the number of mantissa bits in the frame based on the bap values.
		1034	*/
		1035	static int count_mantissa_bits(AC3EncodeContext *s)
		1036	{
		1037	int ch, max_end_freq;
		1038	LOCAL_ALIGNED_16(uint16_t, mant_cnt, [AC3_MAX_BLOCKS], [16]);
		1039
		1040	count_mantissa_bits_init(mant_cnt);
		1041
		1042	max_end_freq = s->bandwidth_code * 3 + 73;
		1043	for (ch = !s->cpl_enabled; ch <= s->channels; ch++)
		1044	count_mantissa_bits_update_ch(s, ch, mant_cnt, s->start_freq[ch],
		1045	max_end_freq);
		1046
		1047	return s->ac3dsp.compute_mantissa_size(mant_cnt);
		1048	}
		1049
		1050
		1051	/**
		1052	* Run the bit allocation with a given SNR offset.
		1053	* This calculates the bit allocation pointers that will be used to determine
		1054	* the quantization of each mantissa.
		1055	*
		1056	* @param s AC-3 encoder private context
		1057	* @param snr_offset SNR offset, 0 to 1023
		1058	* @return the number of bits needed for mantissas if the given SNR offset is
		1059	* is used.
		1060	*/
		1061	static int bit_alloc(AC3EncodeContext *s, int snr_offset)
		1062	{
		1063	int blk, ch;
		1064
		1065	snr_offset = (snr_offset - 240) << 2;
		1066
		1067	reset_block_bap(s);
		1068	for (blk = 0; blk < s->num_blocks; blk++) {
		1069	AC3Block *block = &s->blocks[blk];
		1070
		1071	for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
		1072	/* Currently the only bit allocation parameters which vary across
		1073	blocks within a frame are the exponent values. We can take
		1074	advantage of that by reusing the bit allocation pointers
		1075	whenever we reuse exponents. */
		1076	if (s->exp_strategy[ch][blk] != EXP_REUSE) {
		1077	s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch],
		1078	s->start_freq[ch], block->end_freq[ch],
		1079	snr_offset, s->bit_alloc.floor,
		1080	ff_ac3_bap_tab, s->ref_bap[ch][blk]);
		1081	}
		1082	}
		1083	}
		1084	return count_mantissa_bits(s);
		1085	}
		1086
		1087
		1088	/*
		1089	* Constant bitrate bit allocation search.
		1090	* Find the largest SNR offset that will allow data to fit in the frame.
		1091	*/
		1092	static int cbr_bit_allocation(AC3EncodeContext *s)
		1093	{
		1094	int ch;
		1095	int bits_left;
		1096	int snr_offset, snr_incr;
		1097
		1098	bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
		1099	if (bits_left < 0)
		1100	return AVERROR(EINVAL);
		1101
		1102	snr_offset = s->coarse_snr_offset << 4;
		1103
		1104	/* if previous frame SNR offset was 1023, check if current frame can also
		1105	use SNR offset of 1023. if so, skip the search. */
		1106	if ((snr_offset \| s->fine_snr_offset[1]) == 1023) {
		1107	if (bit_alloc(s, 1023) <= bits_left)
		1108	return 0;
		1109	}
		1110
		1111	while (snr_offset >= 0 &&
		1112	bit_alloc(s, snr_offset) > bits_left) {
		1113	snr_offset -= 64;
		1114	}
		1115	if (snr_offset < 0)
		1116	return AVERROR(EINVAL);
		1117
		1118	FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
		1119	for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) {
		1120	while (snr_offset + snr_incr <= 1023 &&
		1121	bit_alloc(s, snr_offset + snr_incr) <= bits_left) {
		1122	snr_offset += snr_incr;
		1123	FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
		1124	}
		1125	}
		1126	FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
		1127	reset_block_bap(s);
		1128
		1129	s->coarse_snr_offset = snr_offset >> 4;
		1130	for (ch = !s->cpl_on; ch <= s->channels; ch++)
		1131	s->fine_snr_offset[ch] = snr_offset & 0xF;
		1132
		1133	return 0;
		1134	}
		1135
		1136
		1137	/*
		1138	* Perform bit allocation search.
		1139	* Finds the SNR offset value that maximizes quality and fits in the specified
		1140	* frame size. Output is the SNR offset and a set of bit allocation pointers
		1141	* used to quantize the mantissas.
		1142	*/
		1143	int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
		1144	{
		1145	count_frame_bits(s);
		1146
		1147	s->exponent_bits = count_exponent_bits(s);
		1148
		1149	bit_alloc_masking(s);
		1150
		1151	return cbr_bit_allocation(s);
		1152	}
		1153
		1154
		1155	/**
		1156	* Symmetric quantization on 'levels' levels.
		1157	*
		1158	* @param c unquantized coefficient
		1159	* @param e exponent
		1160	* @param levels number of quantization levels
		1161	* @return quantized coefficient
		1162	*/
		1163	static inline int sym_quant(int c, int e, int levels)
		1164	{
		1165	int v = (((levels * c) >> (24 - e)) + levels) >> 1;
		1166	av_assert2(v >= 0 && v < levels);
		1167	return v;
		1168	}
		1169
		1170
		1171	/**
		1172	* Asymmetric quantization on 2^qbits levels.
		1173	*
		1174	* @param c unquantized coefficient
		1175	* @param e exponent
		1176	* @param qbits number of quantization bits
		1177	* @return quantized coefficient
		1178	*/
		1179	static inline int asym_quant(int c, int e, int qbits)
		1180	{
		1181	int m;
		1182
		1183	c = (((c << e) >> (24 - qbits)) + 1) >> 1;
		1184	m = (1 << (qbits-1));
		1185	if (c >= m)
		1186	c = m - 1;
		1187	av_assert2(c >= -m);
		1188	return c;
		1189	}
		1190
		1191
		1192	/**
		1193	* Quantize a set of mantissas for a single channel in a single block.
		1194	*
		1195	* @param s Mantissa count context
		1196	* @param fixed_coef unquantized fixed-point coefficients
		1197	* @param exp exponents
		1198	* @param bap bit allocation pointer indices
		1199	* @param[out] qmant quantized coefficients
		1200	* @param start_freq starting coefficient bin
		1201	* @param end_freq ending coefficient bin
		1202	*/
		1203	static void quantize_mantissas_blk_ch(AC3Mant s, int32_t fixed_coef,
		1204	uint8_t exp, uint8_t bap,
		1205	int16_t *qmant, int start_freq,
		1206	int end_freq)
		1207	{
		1208	int i;
		1209
		1210	for (i = start_freq; i < end_freq; i++) {
		1211	int c = fixed_coef[i];
		1212	int e = exp[i];
		1213	int v = bap[i];
		1214	if (v)
		1215	switch (v) {
		1216	case 1:
		1217	v = sym_quant(c, e, 3);
		1218	switch (s->mant1_cnt) {
		1219	case 0:
		1220	s->qmant1_ptr = &qmant[i];
		1221	v = 9 * v;
		1222	s->mant1_cnt = 1;
		1223	break;
		1224	case 1:
		1225	s->qmant1_ptr += 3 v;
		1226	s->mant1_cnt = 2;
		1227	v = 128;
		1228	break;
		1229	default:
		1230	*s->qmant1_ptr += v;
		1231	s->mant1_cnt = 0;
		1232	v = 128;
		1233	break;
		1234	}
		1235	break;
		1236	case 2:
		1237	v = sym_quant(c, e, 5);
		1238	switch (s->mant2_cnt) {
		1239	case 0:
		1240	s->qmant2_ptr = &qmant[i];
		1241	v = 25 * v;
		1242	s->mant2_cnt = 1;
		1243	break;
		1244	case 1:
		1245	s->qmant2_ptr += 5 v;
		1246	s->mant2_cnt = 2;
		1247	v = 128;
		1248	break;
		1249	default:
		1250	*s->qmant2_ptr += v;
		1251	s->mant2_cnt = 0;
		1252	v = 128;
		1253	break;
		1254	}
		1255	break;
		1256	case 3:
		1257	v = sym_quant(c, e, 7);
		1258	break;
		1259	case 4:
		1260	v = sym_quant(c, e, 11);
		1261	switch (s->mant4_cnt) {
		1262	case 0:
		1263	s->qmant4_ptr = &qmant[i];
		1264	v = 11 * v;
		1265	s->mant4_cnt = 1;
		1266	break;
		1267	default:
		1268	*s->qmant4_ptr += v;
		1269	s->mant4_cnt = 0;
		1270	v = 128;
		1271	break;
		1272	}
		1273	break;
		1274	case 5:
		1275	v = sym_quant(c, e, 15);
		1276	break;
		1277	case 14:
		1278	v = asym_quant(c, e, 14);
		1279	break;
		1280	case 15:
		1281	v = asym_quant(c, e, 16);
		1282	break;
		1283	default:
		1284	v = asym_quant(c, e, v - 1);
		1285	break;
		1286	}
		1287	qmant[i] = v;
		1288	}
		1289	}
		1290
		1291
		1292	/**
		1293	* Quantize mantissas using coefficients, exponents, and bit allocation pointers.
		1294	*
		1295	* @param s AC-3 encoder private context
		1296	*/
		1297	void ff_ac3_quantize_mantissas(AC3EncodeContext *s)
		1298	{
		1299	int blk, ch, ch0=0, got_cpl;
		1300
		1301	for (blk = 0; blk < s->num_blocks; blk++) {
		1302	AC3Block *block = &s->blocks[blk];
		1303	AC3Mant m = { 0 };
		1304
		1305	got_cpl = !block->cpl_in_use;
		1306	for (ch = 1; ch <= s->channels; ch++) {
		1307	if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
		1308	ch0 = ch - 1;
		1309	ch = CPL_CH;
		1310	got_cpl = 1;
		1311	}
		1312	quantize_mantissas_blk_ch(&m, block->fixed_coef[ch],
		1313	s->blocks[s->exp_ref_block[ch][blk]].exp[ch],
		1314	s->ref_bap[ch][blk], block->qmant[ch],
		1315	s->start_freq[ch], block->end_freq[ch]);
		1316	if (ch == CPL_CH)
		1317	ch = ch0;
		1318	}
		1319	}
		1320	}
		1321
		1322
		1323	/*
		1324	* Write the AC-3 frame header to the output bitstream.
		1325	*/
		1326	static void ac3_output_frame_header(AC3EncodeContext *s)
		1327	{
		1328	AC3EncOptions *opt = &s->options;
		1329
		1330	put_bits(&s->pb, 16, 0x0b77); /* frame header */
		1331	put_bits(&s->pb, 16, 0); /* crc1: will be filled later */
		1332	put_bits(&s->pb, 2, s->bit_alloc.sr_code);
		1333	put_bits(&s->pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min) / 2);
		1334	put_bits(&s->pb, 5, s->bitstream_id);
		1335	put_bits(&s->pb, 3, s->bitstream_mode);
		1336	put_bits(&s->pb, 3, s->channel_mode);
		1337	if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO)
		1338	put_bits(&s->pb, 2, s->center_mix_level);
		1339	if (s->channel_mode & 0x04)
		1340	put_bits(&s->pb, 2, s->surround_mix_level);
		1341	if (s->channel_mode == AC3_CHMODE_STEREO)
		1342	put_bits(&s->pb, 2, opt->dolby_surround_mode);
		1343	put_bits(&s->pb, 1, s->lfe_on); /* LFE */
		1344	put_bits(&s->pb, 5, -opt->dialogue_level);
		1345	put_bits(&s->pb, 1, 0); /* no compression control word */
		1346	put_bits(&s->pb, 1, 0); /* no lang code */
		1347	put_bits(&s->pb, 1, opt->audio_production_info);
		1348	if (opt->audio_production_info) {
		1349	put_bits(&s->pb, 5, opt->mixing_level - 80);
		1350	put_bits(&s->pb, 2, opt->room_type);
		1351	}
		1352	put_bits(&s->pb, 1, opt->copyright);
		1353	put_bits(&s->pb, 1, opt->original);
		1354	if (s->bitstream_id == 6) {
		1355	/* alternate bit stream syntax */
		1356	put_bits(&s->pb, 1, opt->extended_bsi_1);
		1357	if (opt->extended_bsi_1) {
		1358	put_bits(&s->pb, 2, opt->preferred_stereo_downmix);
		1359	put_bits(&s->pb, 3, s->ltrt_center_mix_level);
		1360	put_bits(&s->pb, 3, s->ltrt_surround_mix_level);
		1361	put_bits(&s->pb, 3, s->loro_center_mix_level);
		1362	put_bits(&s->pb, 3, s->loro_surround_mix_level);
		1363	}
		1364	put_bits(&s->pb, 1, opt->extended_bsi_2);
		1365	if (opt->extended_bsi_2) {
		1366	put_bits(&s->pb, 2, opt->dolby_surround_ex_mode);
		1367	put_bits(&s->pb, 2, opt->dolby_headphone_mode);
		1368	put_bits(&s->pb, 1, opt->ad_converter_type);
		1369	put_bits(&s->pb, 9, 0); /* xbsi2 and encinfo : reserved */
		1370	}
		1371	} else {
		1372	put_bits(&s->pb, 1, 0); /* no time code 1 */
		1373	put_bits(&s->pb, 1, 0); /* no time code 2 */
		1374	}
		1375	put_bits(&s->pb, 1, 0); /* no additional bit stream info */
		1376	}
		1377
		1378
		1379	/*
		1380	* Write one audio block to the output bitstream.
		1381	*/
		1382	static void output_audio_block(AC3EncodeContext *s, int blk)
		1383	{
		1384	int ch, i, baie, bnd, got_cpl, ch0;
		1385	AC3Block *block = &s->blocks[blk];
		1386
		1387	/* block switching */
		1388	if (!s->eac3) {
		1389	for (ch = 0; ch < s->fbw_channels; ch++)
		1390	put_bits(&s->pb, 1, 0);
		1391	}
		1392
		1393	/* dither flags */
		1394	if (!s->eac3) {
		1395	for (ch = 0; ch < s->fbw_channels; ch++)
		1396	put_bits(&s->pb, 1, 1);
		1397	}
		1398
		1399	/* dynamic range codes */
		1400	put_bits(&s->pb, 1, 0);
		1401
		1402	/* spectral extension */
		1403	if (s->eac3)
		1404	put_bits(&s->pb, 1, 0);
		1405
		1406	/* channel coupling */
		1407	if (!s->eac3)
		1408	put_bits(&s->pb, 1, block->new_cpl_strategy);
		1409	if (block->new_cpl_strategy) {
		1410	if (!s->eac3)
		1411	put_bits(&s->pb, 1, block->cpl_in_use);
		1412	if (block->cpl_in_use) {
		1413	int start_sub, end_sub;
		1414	if (s->eac3)
		1415	put_bits(&s->pb, 1, 0); /* enhanced coupling */
		1416	if (!s->eac3 \|\| s->channel_mode != AC3_CHMODE_STEREO) {
		1417	for (ch = 1; ch <= s->fbw_channels; ch++)
		1418	put_bits(&s->pb, 1, block->channel_in_cpl[ch]);
		1419	}
		1420	if (s->channel_mode == AC3_CHMODE_STEREO)
		1421	put_bits(&s->pb, 1, 0); /* phase flags in use */
		1422	start_sub = (s->start_freq[CPL_CH] - 37) / 12;
		1423	end_sub = (s->cpl_end_freq - 37) / 12;
		1424	put_bits(&s->pb, 4, start_sub);
		1425	put_bits(&s->pb, 4, end_sub - 3);
		1426	/* coupling band structure */
		1427	if (s->eac3) {
		1428	put_bits(&s->pb, 1, 0); /* use default */
		1429	} else {
		1430	for (bnd = start_sub+1; bnd < end_sub; bnd++)
		1431	put_bits(&s->pb, 1, ff_eac3_default_cpl_band_struct[bnd]);
		1432	}
		1433	}
		1434	}
		1435
		1436	/* coupling coordinates */
		1437	if (block->cpl_in_use) {
		1438	for (ch = 1; ch <= s->fbw_channels; ch++) {
		1439	if (block->channel_in_cpl[ch]) {
		1440	if (!s->eac3 \|\| block->new_cpl_coords[ch] != 2)
		1441	put_bits(&s->pb, 1, block->new_cpl_coords[ch]);
		1442	if (block->new_cpl_coords[ch]) {
		1443	put_bits(&s->pb, 2, block->cpl_master_exp[ch]);
		1444	for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
		1445	put_bits(&s->pb, 4, block->cpl_coord_exp [ch][bnd]);
		1446	put_bits(&s->pb, 4, block->cpl_coord_mant[ch][bnd]);
		1447	}
		1448	}
		1449	}
		1450	}
		1451	}
		1452
		1453	/* stereo rematrixing */
		1454	if (s->channel_mode == AC3_CHMODE_STEREO) {
		1455	if (!s->eac3 \|\| blk > 0)
		1456	put_bits(&s->pb, 1, block->new_rematrixing_strategy);
		1457	if (block->new_rematrixing_strategy) {
		1458	/* rematrixing flags */
		1459	for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++)
		1460	put_bits(&s->pb, 1, block->rematrixing_flags[bnd]);
		1461	}
		1462	}
		1463
		1464	/* exponent strategy */
		1465	if (!s->eac3) {
		1466	for (ch = !block->cpl_in_use; ch <= s->fbw_channels; ch++)
		1467	put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
		1468	if (s->lfe_on)
		1469	put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
		1470	}
		1471
		1472	/* bandwidth */
		1473	for (ch = 1; ch <= s->fbw_channels; ch++) {
		1474	if (s->exp_strategy[ch][blk] != EXP_REUSE && !block->channel_in_cpl[ch])
		1475	put_bits(&s->pb, 6, s->bandwidth_code);
		1476	}
		1477
		1478	/* exponents */
		1479	for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
		1480	int nb_groups;
		1481	int cpl = (ch == CPL_CH);
		1482
		1483	if (s->exp_strategy[ch][blk] == EXP_REUSE)
		1484	continue;
		1485
		1486	/* DC exponent */
		1487	put_bits(&s->pb, 4, block->grouped_exp[ch][0] >> cpl);
		1488
		1489	/* exponent groups */
		1490	nb_groups = exponent_group_tab[cpl][s->exp_strategy[ch][blk]-1][block->end_freq[ch]-s->start_freq[ch]];
		1491	for (i = 1; i <= nb_groups; i++)
		1492	put_bits(&s->pb, 7, block->grouped_exp[ch][i]);
		1493
		1494	/* gain range info */
		1495	if (ch != s->lfe_channel && !cpl)
		1496	put_bits(&s->pb, 2, 0);
		1497	}
		1498
		1499	/* bit allocation info */
		1500	if (!s->eac3) {
		1501	baie = (blk == 0);
		1502	put_bits(&s->pb, 1, baie);
		1503	if (baie) {
		1504	put_bits(&s->pb, 2, s->slow_decay_code);
		1505	put_bits(&s->pb, 2, s->fast_decay_code);
		1506	put_bits(&s->pb, 2, s->slow_gain_code);
		1507	put_bits(&s->pb, 2, s->db_per_bit_code);
		1508	put_bits(&s->pb, 3, s->floor_code);
		1509	}
		1510	}
		1511
		1512	/* snr offset */
		1513	if (!s->eac3) {
		1514	put_bits(&s->pb, 1, block->new_snr_offsets);
		1515	if (block->new_snr_offsets) {
		1516	put_bits(&s->pb, 6, s->coarse_snr_offset);
		1517	for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
		1518	put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
		1519	put_bits(&s->pb, 3, s->fast_gain_code[ch]);
		1520	}
		1521	}
		1522	} else {
		1523	put_bits(&s->pb, 1, 0); /* no converter snr offset */
		1524	}
		1525
		1526	/* coupling leak */
		1527	if (block->cpl_in_use) {
		1528	if (!s->eac3 \|\| block->new_cpl_leak != 2)
		1529	put_bits(&s->pb, 1, block->new_cpl_leak);
		1530	if (block->new_cpl_leak) {
		1531	put_bits(&s->pb, 3, s->bit_alloc.cpl_fast_leak);
		1532	put_bits(&s->pb, 3, s->bit_alloc.cpl_slow_leak);
		1533	}
		1534	}
		1535
		1536	if (!s->eac3) {
		1537	put_bits(&s->pb, 1, 0); /* no delta bit allocation */
		1538	put_bits(&s->pb, 1, 0); /* no data to skip */
		1539	}
		1540
		1541	/* mantissas */
		1542	got_cpl = !block->cpl_in_use;
		1543	for (ch = 1; ch <= s->channels; ch++) {
		1544	int b, q;
		1545
		1546	if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
		1547	ch0 = ch - 1;
		1548	ch = CPL_CH;
		1549	got_cpl = 1;
		1550	}
		1551	for (i = s->start_freq[ch]; i < block->end_freq[ch]; i++) {
		1552	q = block->qmant[ch][i];
		1553	b = s->ref_bap[ch][blk][i];
		1554	switch (b) {
		1555	case 0: break;
		1556	case 1: if (q != 128) put_bits (&s->pb, 5, q); break;
		1557	case 2: if (q != 128) put_bits (&s->pb, 7, q); break;
		1558	case 3: put_sbits(&s->pb, 3, q); break;
		1559	case 4: if (q != 128) put_bits (&s->pb, 7, q); break;
		1560	case 14: put_sbits(&s->pb, 14, q); break;
		1561	case 15: put_sbits(&s->pb, 16, q); break;
		1562	default: put_sbits(&s->pb, b-1, q); break;
		1563	}
		1564	}
		1565	if (ch == CPL_CH)
		1566	ch = ch0;
		1567	}
		1568	}
		1569
		1570
		1571	/** CRC-16 Polynomial */
		1572	#define CRC16_POLY ((1 << 0) \| (1 << 2) \| (1 << 15) \| (1 << 16))
		1573
		1574
		1575	static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
		1576	{
		1577	unsigned int c;
		1578
		1579	c = 0;
		1580	while (a) {
		1581	if (a & 1)
		1582	c ^= b;
		1583	a = a >> 1;
		1584	b = b << 1;
		1585	if (b & (1 << 16))
		1586	b ^= poly;
		1587	}
		1588	return c;
		1589	}
		1590
		1591
		1592	static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
		1593	{
		1594	unsigned int r;
		1595	r = 1;
		1596	while (n) {
		1597	if (n & 1)
		1598	r = mul_poly(r, a, poly);
		1599	a = mul_poly(a, a, poly);
		1600	n >>= 1;
		1601	}
		1602	return r;
		1603	}
		1604
		1605
		1606	/*
		1607	* Fill the end of the frame with 0's and compute the two CRCs.
		1608	*/
		1609	static void output_frame_end(AC3EncodeContext *s)
		1610	{
		1611	const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI);
		1612	int frame_size_58, pad_bytes, crc1, crc2_partial, crc2, crc_inv;
		1613	uint8_t *frame;
		1614
		1615	frame_size_58 = ((s->frame_size >> 2) + (s->frame_size >> 4)) << 1;
		1616
		1617	/* pad the remainder of the frame with zeros */
		1618	av_assert2(s->frame_size * 8 - put_bits_count(&s->pb) >= 18);
		1619	flush_put_bits(&s->pb);
		1620	frame = s->pb.buf;
		1621	pad_bytes = s->frame_size - (put_bits_ptr(&s->pb) - frame) - 2;
		1622	av_assert2(pad_bytes >= 0);
		1623	if (pad_bytes > 0)
		1624	memset(put_bits_ptr(&s->pb), 0, pad_bytes);
		1625
		1626	if (s->eac3) {
		1627	/* compute crc2 */
		1628	crc2_partial = av_crc(crc_ctx, 0, frame + 2, s->frame_size - 5);
		1629	} else {
		1630	/* compute crc1 */
		1631	/* this is not so easy because it is at the beginning of the data... */
		1632	crc1 = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58 - 4));
		1633	crc_inv = s->crc_inv[s->frame_size > s->frame_size_min];
		1634	crc1 = mul_poly(crc_inv, crc1, CRC16_POLY);
		1635	AV_WB16(frame + 2, crc1);
		1636
		1637	/* compute crc2 */
		1638	crc2_partial = av_crc(crc_ctx, 0, frame + frame_size_58,
		1639	s->frame_size - frame_size_58 - 3);
		1640	}
		1641	crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
		1642	/* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
		1643	if (crc2 == 0x770B) {
		1644	frame[s->frame_size - 3] ^= 0x1;
		1645	crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
		1646	}
		1647	crc2 = av_bswap16(crc2);
		1648	AV_WB16(frame + s->frame_size - 2, crc2);
		1649	}
		1650
		1651
		1652	/**
		1653	* Write the frame to the output bitstream.
		1654	*
		1655	* @param s AC-3 encoder private context
		1656	* @param frame output data buffer
		1657	*/
		1658	void ff_ac3_output_frame(AC3EncodeContext s, unsigned char frame)
		1659	{
		1660	int blk;
		1661
		1662	init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);
		1663
		1664	s->output_frame_header(s);
		1665
		1666	for (blk = 0; blk < s->num_blocks; blk++)
		1667	output_audio_block(s, blk);
		1668
		1669	output_frame_end(s);
		1670	}
		1671
		1672
		1673	static void dprint_options(AC3EncodeContext *s)
		1674	{
		1675	#ifdef DEBUG
		1676	AVCodecContext *avctx = s->avctx;
		1677	AC3EncOptions *opt = &s->options;
		1678	char strbuf[32];
		1679
		1680	switch (s->bitstream_id) {
		1681	case 6: av_strlcpy(strbuf, "AC-3 (alt syntax)", 32); break;
		1682	case 8: av_strlcpy(strbuf, "AC-3 (standard)", 32); break;
		1683	case 9: av_strlcpy(strbuf, "AC-3 (dnet half-rate)", 32); break;
		1684	case 10: av_strlcpy(strbuf, "AC-3 (dnet quater-rate)", 32); break;
		1685	case 16: av_strlcpy(strbuf, "E-AC-3 (enhanced)", 32); break;
		1686	default: snprintf(strbuf, 32, "ERROR");
		1687	}
		1688	av_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id);
		1689	av_dlog(avctx, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx->sample_fmt));
		1690	av_get_channel_layout_string(strbuf, 32, s->channels, avctx->channel_layout);
		1691	av_dlog(avctx, "channel_layout: %s\n", strbuf);
		1692	av_dlog(avctx, "sample_rate: %d\n", s->sample_rate);
		1693	av_dlog(avctx, "bit_rate: %d\n", s->bit_rate);
		1694	av_dlog(avctx, "blocks/frame: %d (code=%d)\n", s->num_blocks, s->num_blks_code);
		1695	if (s->cutoff)
		1696	av_dlog(avctx, "cutoff: %d\n", s->cutoff);
		1697
		1698	av_dlog(avctx, "per_frame_metadata: %s\n",
		1699	opt->allow_per_frame_metadata?"on":"off");
		1700	if (s->has_center)
		1701	av_dlog(avctx, "center_mixlev: %0.3f (%d)\n", opt->center_mix_level,
		1702	s->center_mix_level);
		1703	else
		1704	av_dlog(avctx, "center_mixlev: {not written}\n");
		1705	if (s->has_surround)
		1706	av_dlog(avctx, "surround_mixlev: %0.3f (%d)\n", opt->surround_mix_level,
		1707	s->surround_mix_level);
		1708	else
		1709	av_dlog(avctx, "surround_mixlev: {not written}\n");
		1710	if (opt->audio_production_info) {
		1711	av_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level);
		1712	switch (opt->room_type) {
		1713	case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
		1714	case AC3ENC_OPT_LARGE_ROOM: av_strlcpy(strbuf, "large", 32); break;
		1715	case AC3ENC_OPT_SMALL_ROOM: av_strlcpy(strbuf, "small", 32); break;
		1716	default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type);
		1717	}
		1718	av_dlog(avctx, "room_type: %s\n", strbuf);
		1719	} else {
		1720	av_dlog(avctx, "mixing_level: {not written}\n");
		1721	av_dlog(avctx, "room_type: {not written}\n");
		1722	}
		1723	av_dlog(avctx, "copyright: %s\n", opt->copyright?"on":"off");
		1724	av_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level);
		1725	if (s->channel_mode == AC3_CHMODE_STEREO) {
		1726	switch (opt->dolby_surround_mode) {
		1727	case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
		1728	case AC3ENC_OPT_MODE_ON: av_strlcpy(strbuf, "on", 32); break;
		1729	case AC3ENC_OPT_MODE_OFF: av_strlcpy(strbuf, "off", 32); break;
		1730	default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode);
		1731	}
		1732	av_dlog(avctx, "dsur_mode: %s\n", strbuf);
		1733	} else {
		1734	av_dlog(avctx, "dsur_mode: {not written}\n");
		1735	}
		1736	av_dlog(avctx, "original: %s\n", opt->original?"on":"off");
		1737
		1738	if (s->bitstream_id == 6) {
		1739	if (opt->extended_bsi_1) {
		1740	switch (opt->preferred_stereo_downmix) {
		1741	case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
		1742	case AC3ENC_OPT_DOWNMIX_LTRT: av_strlcpy(strbuf, "ltrt", 32); break;
		1743	case AC3ENC_OPT_DOWNMIX_LORO: av_strlcpy(strbuf, "loro", 32); break;
		1744	default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix);
		1745	}
		1746	av_dlog(avctx, "dmix_mode: %s\n", strbuf);
		1747	av_dlog(avctx, "ltrt_cmixlev: %0.3f (%d)\n",
		1748	opt->ltrt_center_mix_level, s->ltrt_center_mix_level);
		1749	av_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n",
		1750	opt->ltrt_surround_mix_level, s->ltrt_surround_mix_level);
		1751	av_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n",
		1752	opt->loro_center_mix_level, s->loro_center_mix_level);
		1753	av_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n",
		1754	opt->loro_surround_mix_level, s->loro_surround_mix_level);
		1755	} else {
		1756	av_dlog(avctx, "extended bitstream info 1: {not written}\n");
		1757	}
		1758	if (opt->extended_bsi_2) {
		1759	switch (opt->dolby_surround_ex_mode) {
		1760	case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
		1761	case AC3ENC_OPT_MODE_ON: av_strlcpy(strbuf, "on", 32); break;
		1762	case AC3ENC_OPT_MODE_OFF: av_strlcpy(strbuf, "off", 32); break;
		1763	default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode);
		1764	}
		1765	av_dlog(avctx, "dsurex_mode: %s\n", strbuf);
		1766	switch (opt->dolby_headphone_mode) {
		1767	case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
		1768	case AC3ENC_OPT_MODE_ON: av_strlcpy(strbuf, "on", 32); break;
		1769	case AC3ENC_OPT_MODE_OFF: av_strlcpy(strbuf, "off", 32); break;
		1770	default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode);
		1771	}
		1772	av_dlog(avctx, "dheadphone_mode: %s\n", strbuf);
		1773
		1774	switch (opt->ad_converter_type) {
		1775	case AC3ENC_OPT_ADCONV_STANDARD: av_strlcpy(strbuf, "standard", 32); break;
		1776	case AC3ENC_OPT_ADCONV_HDCD: av_strlcpy(strbuf, "hdcd", 32); break;
		1777	default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type);
		1778	}
		1779	av_dlog(avctx, "ad_conv_type: %s\n", strbuf);
		1780	} else {
		1781	av_dlog(avctx, "extended bitstream info 2: {not written}\n");
		1782	}
		1783	}
		1784	#endif
		1785	}
		1786
		1787
		1788	#define FLT_OPTION_THRESHOLD 0.01
		1789
		1790	static int validate_float_option(float v, const float *v_list, int v_list_size)
		1791	{
		1792	int i;
		1793
		1794	for (i = 0; i < v_list_size; i++) {
		1795	if (v < (v_list[i] + FLT_OPTION_THRESHOLD) &&
		1796	v > (v_list[i] - FLT_OPTION_THRESHOLD))
		1797	break;
		1798	}
		1799	if (i == v_list_size)
		1800	return -1;
		1801
		1802	return i;
		1803	}
		1804
		1805
		1806	static void validate_mix_level(void log_ctx, const char opt_name,
		1807	float opt_param, const float list,
		1808	int list_size, int default_value, int min_value,
		1809	int *ctx_param)
		1810	{
		1811	int mixlev = validate_float_option(*opt_param, list, list_size);
		1812	if (mixlev < min_value) {
		1813	mixlev = default_value;
		1814	if (*opt_param >= 0.0) {
		1815	av_log(log_ctx, AV_LOG_WARNING, "requested %s is not valid. using "
		1816	"default value: %0.3f\n", opt_name, list[mixlev]);
		1817	}
		1818	}
		1819	*opt_param = list[mixlev];
		1820	*ctx_param = mixlev;
		1821	}
		1822
		1823
		1824	/**
		1825	* Validate metadata options as set by AVOption system.
		1826	* These values can optionally be changed per-frame.
		1827	*
		1828	* @param s AC-3 encoder private context
		1829	*/
		1830	int ff_ac3_validate_metadata(AC3EncodeContext *s)
		1831	{
		1832	AVCodecContext *avctx = s->avctx;
		1833	AC3EncOptions *opt = &s->options;
		1834
		1835	opt->audio_production_info = 0;
		1836	opt->extended_bsi_1 = 0;
		1837	opt->extended_bsi_2 = 0;
		1838	opt->eac3_mixing_metadata = 0;
		1839	opt->eac3_info_metadata = 0;
		1840
		1841	/* determine mixing metadata / xbsi1 use */
		1842	if (s->channel_mode > AC3_CHMODE_STEREO && opt->preferred_stereo_downmix != AC3ENC_OPT_NONE) {
		1843	opt->extended_bsi_1 = 1;
		1844	opt->eac3_mixing_metadata = 1;
		1845	}
		1846	if (s->has_center &&
		1847	(opt->ltrt_center_mix_level >= 0 \|\| opt->loro_center_mix_level >= 0)) {
		1848	opt->extended_bsi_1 = 1;
		1849	opt->eac3_mixing_metadata = 1;
		1850	}
		1851	if (s->has_surround &&
		1852	(opt->ltrt_surround_mix_level >= 0 \|\| opt->loro_surround_mix_level >= 0)) {
		1853	opt->extended_bsi_1 = 1;
		1854	opt->eac3_mixing_metadata = 1;
		1855	}
		1856
		1857	if (s->eac3) {
		1858	/* determine info metadata use */
		1859	if (avctx->audio_service_type != AV_AUDIO_SERVICE_TYPE_MAIN)
		1860	opt->eac3_info_metadata = 1;
		1861	if (opt->copyright != AC3ENC_OPT_NONE \|\| opt->original != AC3ENC_OPT_NONE)
		1862	opt->eac3_info_metadata = 1;
		1863	if (s->channel_mode == AC3_CHMODE_STEREO &&
		1864	(opt->dolby_headphone_mode != AC3ENC_OPT_NONE \|\| opt->dolby_surround_mode != AC3ENC_OPT_NONE))
		1865	opt->eac3_info_metadata = 1;
		1866	if (s->channel_mode >= AC3_CHMODE_2F2R && opt->dolby_surround_ex_mode != AC3ENC_OPT_NONE)
		1867	opt->eac3_info_metadata = 1;
		1868	if (opt->mixing_level != AC3ENC_OPT_NONE \|\| opt->room_type != AC3ENC_OPT_NONE \|\|
		1869	opt->ad_converter_type != AC3ENC_OPT_NONE) {
		1870	opt->audio_production_info = 1;
		1871	opt->eac3_info_metadata = 1;
		1872	}
		1873	} else {
		1874	/* determine audio production info use */
		1875	if (opt->mixing_level != AC3ENC_OPT_NONE \|\| opt->room_type != AC3ENC_OPT_NONE)
		1876	opt->audio_production_info = 1;
		1877
		1878	/* determine xbsi2 use */
		1879	if (s->channel_mode >= AC3_CHMODE_2F2R && opt->dolby_surround_ex_mode != AC3ENC_OPT_NONE)
		1880	opt->extended_bsi_2 = 1;
		1881	if (s->channel_mode == AC3_CHMODE_STEREO && opt->dolby_headphone_mode != AC3ENC_OPT_NONE)
		1882	opt->extended_bsi_2 = 1;
		1883	if (opt->ad_converter_type != AC3ENC_OPT_NONE)
		1884	opt->extended_bsi_2 = 1;
		1885	}
		1886
		1887	/* validate AC-3 mixing levels */
		1888	if (!s->eac3) {
		1889	if (s->has_center) {
		1890	validate_mix_level(avctx, "center_mix_level", &opt->center_mix_level,
		1891	cmixlev_options, CMIXLEV_NUM_OPTIONS, 1, 0,
		1892	&s->center_mix_level);
		1893	}
		1894	if (s->has_surround) {
		1895	validate_mix_level(avctx, "surround_mix_level", &opt->surround_mix_level,
		1896	surmixlev_options, SURMIXLEV_NUM_OPTIONS, 1, 0,
		1897	&s->surround_mix_level);
		1898	}
		1899	}
		1900
		1901	/* validate extended bsi 1 / mixing metadata */
		1902	if (opt->extended_bsi_1 \|\| opt->eac3_mixing_metadata) {
		1903	/* default preferred stereo downmix */
		1904	if (opt->preferred_stereo_downmix == AC3ENC_OPT_NONE)
		1905	opt->preferred_stereo_downmix = AC3ENC_OPT_NOT_INDICATED;
		1906	if (!s->eac3 \|\| s->has_center) {
		1907	/* validate Lt/Rt center mix level */
		1908	validate_mix_level(avctx, "ltrt_center_mix_level",
		1909	&opt->ltrt_center_mix_level, extmixlev_options,
		1910	EXTMIXLEV_NUM_OPTIONS, 5, 0,
		1911	&s->ltrt_center_mix_level);
		1912	/* validate Lo/Ro center mix level */
		1913	validate_mix_level(avctx, "loro_center_mix_level",
		1914	&opt->loro_center_mix_level, extmixlev_options,
		1915	EXTMIXLEV_NUM_OPTIONS, 5, 0,
		1916	&s->loro_center_mix_level);
		1917	}
		1918	if (!s->eac3 \|\| s->has_surround) {
		1919	/* validate Lt/Rt surround mix level */
		1920	validate_mix_level(avctx, "ltrt_surround_mix_level",
		1921	&opt->ltrt_surround_mix_level, extmixlev_options,
		1922	EXTMIXLEV_NUM_OPTIONS, 6, 3,
		1923	&s->ltrt_surround_mix_level);
		1924	/* validate Lo/Ro surround mix level */
		1925	validate_mix_level(avctx, "loro_surround_mix_level",
		1926	&opt->loro_surround_mix_level, extmixlev_options,
		1927	EXTMIXLEV_NUM_OPTIONS, 6, 3,
		1928	&s->loro_surround_mix_level);
		1929	}
		1930	}
		1931
		1932	/* validate audio service type / channels combination */
		1933	if ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_KARAOKE &&
		1934	avctx->channels == 1) \|\|
		1935	((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_COMMENTARY \|\|
		1936	avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_EMERGENCY \|\|
		1937	avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_VOICE_OVER)
		1938	&& avctx->channels > 1)) {
		1939	av_log(avctx, AV_LOG_ERROR, "invalid audio service type for the "
		1940	"specified number of channels\n");
		1941	return AVERROR(EINVAL);
		1942	}
		1943
		1944	/* validate extended bsi 2 / info metadata */
		1945	if (opt->extended_bsi_2 \|\| opt->eac3_info_metadata) {
		1946	/* default dolby headphone mode */
		1947	if (opt->dolby_headphone_mode == AC3ENC_OPT_NONE)
		1948	opt->dolby_headphone_mode = AC3ENC_OPT_NOT_INDICATED;
		1949	/* default dolby surround ex mode */
		1950	if (opt->dolby_surround_ex_mode == AC3ENC_OPT_NONE)
		1951	opt->dolby_surround_ex_mode = AC3ENC_OPT_NOT_INDICATED;
		1952	/* default A/D converter type */
		1953	if (opt->ad_converter_type == AC3ENC_OPT_NONE)
		1954	opt->ad_converter_type = AC3ENC_OPT_ADCONV_STANDARD;
		1955	}
		1956
		1957	/* copyright & original defaults */
		1958	if (!s->eac3 \|\| opt->eac3_info_metadata) {
		1959	/* default copyright */
		1960	if (opt->copyright == AC3ENC_OPT_NONE)
		1961	opt->copyright = AC3ENC_OPT_OFF;
		1962	/* default original */
		1963	if (opt->original == AC3ENC_OPT_NONE)
		1964	opt->original = AC3ENC_OPT_ON;
		1965	}
		1966
		1967	/* dolby surround mode default */
		1968	if (!s->eac3 \|\| opt->eac3_info_metadata) {
		1969	if (opt->dolby_surround_mode == AC3ENC_OPT_NONE)
		1970	opt->dolby_surround_mode = AC3ENC_OPT_NOT_INDICATED;
		1971	}
		1972
		1973	/* validate audio production info */
		1974	if (opt->audio_production_info) {
		1975	if (opt->mixing_level == AC3ENC_OPT_NONE) {
		1976	av_log(avctx, AV_LOG_ERROR, "mixing_level must be set if "
		1977	"room_type is set\n");
		1978	return AVERROR(EINVAL);
		1979	}
		1980	if (opt->mixing_level < 80) {
		1981	av_log(avctx, AV_LOG_ERROR, "invalid mixing level. must be between "
		1982	"80dB and 111dB\n");
		1983	return AVERROR(EINVAL);
		1984	}
		1985	/* default room type */
		1986	if (opt->room_type == AC3ENC_OPT_NONE)
		1987	opt->room_type = AC3ENC_OPT_NOT_INDICATED;
		1988	}
		1989
		1990	/* set bitstream id for alternate bitstream syntax */
		1991	if (!s->eac3 && (opt->extended_bsi_1 \|\| opt->extended_bsi_2)) {
		1992	if (s->bitstream_id > 8 && s->bitstream_id < 11) {
		1993	static int warn_once = 1;
		1994	if (warn_once) {
		1995	av_log(avctx, AV_LOG_WARNING, "alternate bitstream syntax is "
		1996	"not compatible with reduced samplerates. writing of "
		1997	"extended bitstream information will be disabled.\n");
		1998	warn_once = 0;
		1999	}
		2000	} else {
		2001	s->bitstream_id = 6;
		2002	}
		2003	}
		2004
		2005	return 0;
		2006	}
		2007
		2008
		2009	/**
		2010	* Finalize encoding and free any memory allocated by the encoder.
		2011	*
		2012	* @param avctx Codec context
		2013	*/
		2014	av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
		2015	{
		2016	int blk, ch;
		2017	AC3EncodeContext *s = avctx->priv_data;
		2018
		2019	av_freep(&s->windowed_samples);
		2020	if (s->planar_samples)
		2021	for (ch = 0; ch < s->channels; ch++)
		2022	av_freep(&s->planar_samples[ch]);
		2023	av_freep(&s->planar_samples);
		2024	av_freep(&s->bap_buffer);
		2025	av_freep(&s->bap1_buffer);
		2026	av_freep(&s->mdct_coef_buffer);
		2027	av_freep(&s->fixed_coef_buffer);
		2028	av_freep(&s->exp_buffer);
		2029	av_freep(&s->grouped_exp_buffer);
		2030	av_freep(&s->psd_buffer);
		2031	av_freep(&s->band_psd_buffer);
		2032	av_freep(&s->mask_buffer);
		2033	av_freep(&s->qmant_buffer);
		2034	av_freep(&s->cpl_coord_exp_buffer);
		2035	av_freep(&s->cpl_coord_mant_buffer);
		2036	for (blk = 0; blk < s->num_blocks; blk++) {
		2037	AC3Block *block = &s->blocks[blk];
		2038	av_freep(&block->mdct_coef);
		2039	av_freep(&block->fixed_coef);
		2040	av_freep(&block->exp);
		2041	av_freep(&block->grouped_exp);
		2042	av_freep(&block->psd);
		2043	av_freep(&block->band_psd);
		2044	av_freep(&block->mask);
		2045	av_freep(&block->qmant);
		2046	av_freep(&block->cpl_coord_exp);
		2047	av_freep(&block->cpl_coord_mant);
		2048	}
		2049
		2050	s->mdct_end(s);
		2051
		2052	return 0;
		2053	}
		2054
		2055
		2056	/*
		2057	* Set channel information during initialization.
		2058	*/
		2059	static av_cold int set_channel_info(AC3EncodeContext *s, int channels,
		2060	uint64_t *channel_layout)
		2061	{
		2062	int ch_layout;
		2063
		2064	if (channels < 1 \|\| channels > AC3_MAX_CHANNELS)
		2065	return AVERROR(EINVAL);
		2066	if (*channel_layout > 0x7FF)
		2067	return AVERROR(EINVAL);
		2068	ch_layout = *channel_layout;
		2069	if (!ch_layout)
		2070	ch_layout = av_get_default_channel_layout(channels);
		2071
		2072	s->lfe_on = !!(ch_layout & AV_CH_LOW_FREQUENCY);
		2073	s->channels = channels;
		2074	s->fbw_channels = channels - s->lfe_on;
		2075	s->lfe_channel = s->lfe_on ? s->fbw_channels + 1 : -1;
		2076	if (s->lfe_on)
		2077	ch_layout -= AV_CH_LOW_FREQUENCY;
		2078
		2079	switch (ch_layout) {
		2080	case AV_CH_LAYOUT_MONO: s->channel_mode = AC3_CHMODE_MONO; break;
		2081	case AV_CH_LAYOUT_STEREO: s->channel_mode = AC3_CHMODE_STEREO; break;
		2082	case AV_CH_LAYOUT_SURROUND: s->channel_mode = AC3_CHMODE_3F; break;
		2083	case AV_CH_LAYOUT_2_1: s->channel_mode = AC3_CHMODE_2F1R; break;
		2084	case AV_CH_LAYOUT_4POINT0: s->channel_mode = AC3_CHMODE_3F1R; break;
		2085	case AV_CH_LAYOUT_QUAD:
		2086	case AV_CH_LAYOUT_2_2: s->channel_mode = AC3_CHMODE_2F2R; break;
		2087	case AV_CH_LAYOUT_5POINT0:
		2088	case AV_CH_LAYOUT_5POINT0_BACK: s->channel_mode = AC3_CHMODE_3F2R; break;
		2089	default:
		2090	return AVERROR(EINVAL);
		2091	}
		2092	s->has_center = (s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO;
		2093	s->has_surround = s->channel_mode & 0x04;
		2094
		2095	s->channel_map = ff_ac3_enc_channel_map[s->channel_mode][s->lfe_on];
		2096	*channel_layout = ch_layout;
		2097	if (s->lfe_on)
		2098	*channel_layout \|= AV_CH_LOW_FREQUENCY;
		2099
		2100	return 0;
		2101	}
		2102
		2103
		2104	static av_cold int validate_options(AC3EncodeContext *s)
		2105	{
		2106	AVCodecContext *avctx = s->avctx;
		2107	int i, ret, max_sr;
		2108
		2109	/* validate channel layout */
		2110	if (!avctx->channel_layout) {
		2111	av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
		2112	"encoder will guess the layout, but it "
		2113	"might be incorrect.\n");
		2114	}
		2115	ret = set_channel_info(s, avctx->channels, &avctx->channel_layout);
		2116	if (ret) {
		2117	av_log(avctx, AV_LOG_ERROR, "invalid channel layout\n");
		2118	return ret;
		2119	}
		2120
		2121	/* validate sample rate */
		2122	/* note: max_sr could be changed from 2 to 5 for E-AC-3 once we find a
		2123	decoder that supports half sample rate so we can validate that
		2124	the generated files are correct. */
		2125	max_sr = s->eac3 ? 2 : 8;
		2126	for (i = 0; i <= max_sr; i++) {
		2127	if ((ff_ac3_sample_rate_tab[i % 3] >> (i / 3)) == avctx->sample_rate)
		2128	break;
		2129	}
		2130	if (i > max_sr) {
		2131	av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
		2132	return AVERROR(EINVAL);
		2133	}
		2134	s->sample_rate = avctx->sample_rate;
		2135	s->bit_alloc.sr_shift = i / 3;
		2136	s->bit_alloc.sr_code = i % 3;
		2137	s->bitstream_id = s->eac3 ? 16 : 8 + s->bit_alloc.sr_shift;
		2138
		2139	/* select a default bit rate if not set by the user */
		2140	if (!avctx->bit_rate) {
		2141	switch (s->fbw_channels) {
		2142	case 1: avctx->bit_rate = 96000; break;
		2143	case 2: avctx->bit_rate = 192000; break;
		2144	case 3: avctx->bit_rate = 320000; break;
		2145	case 4: avctx->bit_rate = 384000; break;
		2146	case 5: avctx->bit_rate = 448000; break;
		2147	}
		2148	}
		2149
		2150	/* validate bit rate */
		2151	if (s->eac3) {
		2152	int max_br, min_br, wpf, min_br_dist, min_br_code;
		2153	int num_blks_code, num_blocks, frame_samples;
		2154
		2155	/* calculate min/max bitrate */
		2156	/* TODO: More testing with 3 and 2 blocks. All E-AC-3 samples I've
		2157	found use either 6 blocks or 1 block, even though 2 or 3 blocks
		2158	would work as far as the bit rate is concerned. */
		2159	for (num_blks_code = 3; num_blks_code >= 0; num_blks_code--) {
		2160	num_blocks = ((int[]){ 1, 2, 3, 6 })[num_blks_code];
		2161	frame_samples = AC3_BLOCK_SIZE * num_blocks;
		2162	max_br = 2048 * s->sample_rate / frame_samples * 16;
		2163	min_br = ((s->sample_rate + (frame_samples-1)) / frame_samples) * 16;
		2164	if (avctx->bit_rate <= max_br)
		2165	break;
		2166	}
		2167	if (avctx->bit_rate < min_br \|\| avctx->bit_rate > max_br) {
		2168	av_log(avctx, AV_LOG_ERROR, "invalid bit rate. must be %d to %d "
		2169	"for this sample rate\n", min_br, max_br);
		2170	return AVERROR(EINVAL);
		2171	}
		2172	s->num_blks_code = num_blks_code;
		2173	s->num_blocks = num_blocks;
		2174
		2175	/* calculate words-per-frame for the selected bitrate */
		2176	wpf = (avctx->bit_rate / 16) * frame_samples / s->sample_rate;
		2177	av_assert1(wpf > 0 && wpf <= 2048);
		2178
		2179	/* find the closest AC-3 bitrate code to the selected bitrate.
		2180	this is needed for lookup tables for bandwidth and coupling
		2181	parameter selection */
		2182	min_br_code = -1;
		2183	min_br_dist = INT_MAX;
		2184	for (i = 0; i < 19; i++) {
		2185	int br_dist = abs(ff_ac3_bitrate_tab[i] * 1000 - avctx->bit_rate);
		2186	if (br_dist < min_br_dist) {
		2187	min_br_dist = br_dist;
		2188	min_br_code = i;
		2189	}
		2190	}
		2191
		2192	/* make sure the minimum frame size is below the average frame size */
		2193	s->frame_size_code = min_br_code << 1;
		2194	while (wpf > 1 && wpf * s->sample_rate / AC3_FRAME_SIZE * 16 > avctx->bit_rate)
		2195	wpf--;
		2196	s->frame_size_min = 2 * wpf;
		2197	} else {
		2198	int best_br = 0, best_code = 0, best_diff = INT_MAX;
		2199	for (i = 0; i < 19; i++) {
		2200	int br = (ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift) * 1000;
		2201	int diff = abs(br - avctx->bit_rate);
		2202	if (diff < best_diff) {
		2203	best_br = br;
		2204	best_code = i;
		2205	best_diff = diff;
		2206	}
		2207	if (!best_diff)
		2208	break;
		2209	}
		2210	avctx->bit_rate = best_br;
		2211	s->frame_size_code = best_code << 1;
		2212	s->frame_size_min = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
		2213	s->num_blks_code = 0x3;
		2214	s->num_blocks = 6;
		2215	}
		2216	s->bit_rate = avctx->bit_rate;
		2217	s->frame_size = s->frame_size_min;
		2218
		2219	/* validate cutoff */
		2220	if (avctx->cutoff < 0) {
		2221	av_log(avctx, AV_LOG_ERROR, "invalid cutoff frequency\n");
		2222	return AVERROR(EINVAL);
		2223	}
		2224	s->cutoff = avctx->cutoff;
		2225	if (s->cutoff > (s->sample_rate >> 1))
		2226	s->cutoff = s->sample_rate >> 1;
		2227
		2228	ret = ff_ac3_validate_metadata(s);
		2229	if (ret)
		2230	return ret;
		2231
		2232	s->rematrixing_enabled = s->options.stereo_rematrixing &&
		2233	(s->channel_mode == AC3_CHMODE_STEREO);
		2234
		2235	s->cpl_enabled = s->options.channel_coupling &&
		2236	s->channel_mode >= AC3_CHMODE_STEREO;
		2237
		2238	return 0;
		2239	}
		2240
		2241
		2242	/*
		2243	* Set bandwidth for all channels.
		2244	* The user can optionally supply a cutoff frequency. Otherwise an appropriate
		2245	* default value will be used.
		2246	*/
		2247	static av_cold void set_bandwidth(AC3EncodeContext *s)
		2248	{
		2249	int blk, ch, cpl_start;
		2250
		2251	if (s->cutoff) {
		2252	/* calculate bandwidth based on user-specified cutoff frequency */
		2253	int fbw_coeffs;
		2254	fbw_coeffs = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
		2255	s->bandwidth_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
		2256	} else {
		2257	/* use default bandwidth setting */
		2258	s->bandwidth_code = ac3_bandwidth_tab[s->fbw_channels-1][s->bit_alloc.sr_code][s->frame_size_code/2];
		2259	}
		2260
		2261	/* set number of coefficients for each channel */
		2262	for (ch = 1; ch <= s->fbw_channels; ch++) {
		2263	s->start_freq[ch] = 0;
		2264	for (blk = 0; blk < s->num_blocks; blk++)
		2265	s->blocks[blk].end_freq[ch] = s->bandwidth_code * 3 + 73;
		2266	}
		2267	/* LFE channel always has 7 coefs */
		2268	if (s->lfe_on) {
		2269	s->start_freq[s->lfe_channel] = 0;
		2270	for (blk = 0; blk < s->num_blocks; blk++)
		2271	s->blocks[blk].end_freq[ch] = 7;
		2272	}
		2273
		2274	/* initialize coupling strategy */
		2275	if (s->cpl_enabled) {
		2276	if (s->options.cpl_start != AC3ENC_OPT_AUTO) {
		2277	cpl_start = s->options.cpl_start;
		2278	} else {
		2279	cpl_start = ac3_coupling_start_tab[s->channel_mode-2][s->bit_alloc.sr_code][s->frame_size_code/2];
		2280	if (cpl_start < 0) {
		2281	if (s->options.channel_coupling == AC3ENC_OPT_AUTO)
		2282	s->cpl_enabled = 0;
		2283	else
		2284	cpl_start = 15;
		2285	}
		2286	}
		2287	}
		2288	if (s->cpl_enabled) {
		2289	int i, cpl_start_band, cpl_end_band;
		2290	uint8_t *cpl_band_sizes = s->cpl_band_sizes;
		2291
		2292	cpl_end_band = s->bandwidth_code / 4 + 3;
		2293	cpl_start_band = av_clip(cpl_start, 0, FFMIN(cpl_end_band-1, 15));
		2294
		2295	s->num_cpl_subbands = cpl_end_band - cpl_start_band;
		2296
		2297	s->num_cpl_bands = 1;
		2298	*cpl_band_sizes = 12;
		2299	for (i = cpl_start_band + 1; i < cpl_end_band; i++) {
		2300	if (ff_eac3_default_cpl_band_struct[i]) {
		2301	*cpl_band_sizes += 12;
		2302	} else {
		2303	s->num_cpl_bands++;
		2304	cpl_band_sizes++;
		2305	*cpl_band_sizes = 12;
		2306	}
		2307	}
		2308
		2309	s->start_freq[CPL_CH] = cpl_start_band * 12 + 37;
		2310	s->cpl_end_freq = cpl_end_band * 12 + 37;
		2311	for (blk = 0; blk < s->num_blocks; blk++)
		2312	s->blocks[blk].end_freq[CPL_CH] = s->cpl_end_freq;
		2313	}
		2314	}
		2315
		2316
		2317	static av_cold int allocate_buffers(AC3EncodeContext *s)
		2318	{
		2319	AVCodecContext *avctx = s->avctx;
		2320	int blk, ch;
		2321	int channels = s->channels + 1; /* includes coupling channel */
		2322	int channel_blocks = channels * s->num_blocks;
		2323	int total_coefs = AC3_MAX_COEFS * channel_blocks;
		2324
		2325	if (s->allocate_sample_buffers(s))
		2326	goto alloc_fail;
		2327
		2328	FF_ALLOC_OR_GOTO(avctx, s->bap_buffer, total_coefs *
		2329	sizeof(*s->bap_buffer), alloc_fail);
		2330	FF_ALLOC_OR_GOTO(avctx, s->bap1_buffer, total_coefs *
		2331	sizeof(*s->bap1_buffer), alloc_fail);
		2332	FF_ALLOCZ_OR_GOTO(avctx, s->mdct_coef_buffer, total_coefs *
		2333	sizeof(*s->mdct_coef_buffer), alloc_fail);
		2334	FF_ALLOC_OR_GOTO(avctx, s->exp_buffer, total_coefs *
		2335	sizeof(*s->exp_buffer), alloc_fail);
		2336	FF_ALLOC_OR_GOTO(avctx, s->grouped_exp_buffer, channel_blocks * 128 *
		2337	sizeof(*s->grouped_exp_buffer), alloc_fail);
		2338	FF_ALLOC_OR_GOTO(avctx, s->psd_buffer, total_coefs *
		2339	sizeof(*s->psd_buffer), alloc_fail);
		2340	FF_ALLOC_OR_GOTO(avctx, s->band_psd_buffer, channel_blocks * 64 *
		2341	sizeof(*s->band_psd_buffer), alloc_fail);
		2342	FF_ALLOC_OR_GOTO(avctx, s->mask_buffer, channel_blocks * 64 *
		2343	sizeof(*s->mask_buffer), alloc_fail);
		2344	FF_ALLOC_OR_GOTO(avctx, s->qmant_buffer, total_coefs *
		2345	sizeof(*s->qmant_buffer), alloc_fail);
		2346	if (s->cpl_enabled) {
		2347	FF_ALLOC_OR_GOTO(avctx, s->cpl_coord_exp_buffer, channel_blocks * 16 *
		2348	sizeof(*s->cpl_coord_exp_buffer), alloc_fail);
		2349	FF_ALLOC_OR_GOTO(avctx, s->cpl_coord_mant_buffer, channel_blocks * 16 *
		2350	sizeof(*s->cpl_coord_mant_buffer), alloc_fail);
		2351	}
		2352	for (blk = 0; blk < s->num_blocks; blk++) {
		2353	AC3Block *block = &s->blocks[blk];
		2354	FF_ALLOCZ_OR_GOTO(avctx, block->mdct_coef, channels * sizeof(*block->mdct_coef),
		2355	alloc_fail);
		2356	FF_ALLOCZ_OR_GOTO(avctx, block->exp, channels * sizeof(*block->exp),
		2357	alloc_fail);
		2358	FF_ALLOCZ_OR_GOTO(avctx, block->grouped_exp, channels * sizeof(*block->grouped_exp),
		2359	alloc_fail);
		2360	FF_ALLOCZ_OR_GOTO(avctx, block->psd, channels * sizeof(*block->psd),
		2361	alloc_fail);
		2362	FF_ALLOCZ_OR_GOTO(avctx, block->band_psd, channels * sizeof(*block->band_psd),
		2363	alloc_fail);
		2364	FF_ALLOCZ_OR_GOTO(avctx, block->mask, channels * sizeof(*block->mask),
		2365	alloc_fail);
		2366	FF_ALLOCZ_OR_GOTO(avctx, block->qmant, channels * sizeof(*block->qmant),
		2367	alloc_fail);
		2368	if (s->cpl_enabled) {
		2369	FF_ALLOCZ_OR_GOTO(avctx, block->cpl_coord_exp, channels * sizeof(*block->cpl_coord_exp),
		2370	alloc_fail);
		2371	FF_ALLOCZ_OR_GOTO(avctx, block->cpl_coord_mant, channels * sizeof(*block->cpl_coord_mant),
		2372	alloc_fail);
		2373	}
		2374
		2375	for (ch = 0; ch < channels; ch++) {
		2376	/* arrangement: block, channel, coeff */
		2377	block->grouped_exp[ch] = &s->grouped_exp_buffer[128 * (blk * channels + ch)];
		2378	block->psd[ch] = &s->psd_buffer [AC3_MAX_COEFS * (blk * channels + ch)];
		2379	block->band_psd[ch] = &s->band_psd_buffer [64 * (blk * channels + ch)];
		2380	block->mask[ch] = &s->mask_buffer [64 * (blk * channels + ch)];
		2381	block->qmant[ch] = &s->qmant_buffer [AC3_MAX_COEFS * (blk * channels + ch)];
		2382	if (s->cpl_enabled) {
		2383	block->cpl_coord_exp[ch] = &s->cpl_coord_exp_buffer [16 * (blk * channels + ch)];
		2384	block->cpl_coord_mant[ch] = &s->cpl_coord_mant_buffer[16 * (blk * channels + ch)];
		2385	}
		2386
		2387	/* arrangement: channel, block, coeff */
		2388	block->exp[ch] = &s->exp_buffer [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
		2389	block->mdct_coef[ch] = &s->mdct_coef_buffer [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
		2390	}
		2391	}
		2392
		2393	if (!s->fixed_point) {
		2394	FF_ALLOCZ_OR_GOTO(avctx, s->fixed_coef_buffer, total_coefs *
		2395	sizeof(*s->fixed_coef_buffer), alloc_fail);
		2396	for (blk = 0; blk < s->num_blocks; blk++) {
		2397	AC3Block *block = &s->blocks[blk];
		2398	FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, channels *
		2399	sizeof(*block->fixed_coef), alloc_fail);
		2400	for (ch = 0; ch < channels; ch++)
		2401	block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
		2402	}
		2403	} else {
		2404	for (blk = 0; blk < s->num_blocks; blk++) {
		2405	AC3Block *block = &s->blocks[blk];
		2406	FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, channels *
		2407	sizeof(*block->fixed_coef), alloc_fail);
		2408	for (ch = 0; ch < channels; ch++)
		2409	block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch];
		2410	}
		2411	}
		2412
		2413	return 0;
		2414	alloc_fail:
		2415	return AVERROR(ENOMEM);
		2416	}
		2417
		2418
		2419	av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
		2420	{
		2421	AC3EncodeContext *s = avctx->priv_data;
		2422	int ret, frame_size_58;
		2423
		2424	s->avctx = avctx;
		2425
		2426	s->eac3 = avctx->codec_id == AV_CODEC_ID_EAC3;
		2427
		2428	ff_ac3_common_init();
		2429
		2430	ret = validate_options(s);
		2431	if (ret)
		2432	return ret;
		2433
		2434	avctx->frame_size = AC3_BLOCK_SIZE * s->num_blocks;
		2435	avctx->delay = AC3_BLOCK_SIZE;
		2436
		2437	s->bitstream_mode = avctx->audio_service_type;
		2438	if (s->bitstream_mode == AV_AUDIO_SERVICE_TYPE_KARAOKE)
		2439	s->bitstream_mode = 0x7;
		2440
		2441	s->bits_written = 0;
		2442	s->samples_written = 0;
		2443
		2444	/* calculate crc_inv for both possible frame sizes */
		2445	frame_size_58 = (( s->frame_size >> 2) + ( s->frame_size >> 4)) << 1;
		2446	s->crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
		2447	if (s->bit_alloc.sr_code == 1) {
		2448	frame_size_58 = (((s->frame_size+2) >> 2) + ((s->frame_size+2) >> 4)) << 1;
		2449	s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
		2450	}
		2451
		2452	/* set function pointers */
		2453	if (CONFIG_AC3_FIXED_ENCODER && s->fixed_point) {
		2454	s->mdct_end = ff_ac3_fixed_mdct_end;
		2455	s->mdct_init = ff_ac3_fixed_mdct_init;
		2456	s->allocate_sample_buffers = ff_ac3_fixed_allocate_sample_buffers;
		2457	} else if (CONFIG_AC3_ENCODER \|\| CONFIG_EAC3_ENCODER) {
		2458	s->mdct_end = ff_ac3_float_mdct_end;
		2459	s->mdct_init = ff_ac3_float_mdct_init;
		2460	s->allocate_sample_buffers = ff_ac3_float_allocate_sample_buffers;
		2461	}
		2462	if (CONFIG_EAC3_ENCODER && s->eac3)
		2463	s->output_frame_header = ff_eac3_output_frame_header;
		2464	else
		2465	s->output_frame_header = ac3_output_frame_header;
		2466
		2467	set_bandwidth(s);
		2468
		2469	exponent_init(s);
		2470
		2471	bit_alloc_init(s);
		2472
		2473	ret = s->mdct_init(s);
		2474	if (ret)
		2475	goto init_fail;
		2476
		2477	ret = allocate_buffers(s);
		2478	if (ret)
		2479	goto init_fail;
		2480
		2481	ff_dsputil_init(&s->dsp, avctx);
		2482	avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
		2483	ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
		2484
		2485	dprint_options(s);
		2486
		2487	return 0;
		2488	init_fail:
		2489	ff_ac3_encode_close(avctx);
		2490	return ret;
		2491	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavcodec/ac3enc.c @ 4349 – Rev