WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/ffmpeg-2.1/libavcodec/ac3dec.c

Rev	Author	Line No.	Line
6148	serge	1	/*
		2	* AC-3 Audio Decoder
		3	* This code was developed as part of Google Summer of Code 2006.
		4	* E-AC-3 support was added as part of Google Summer of Code 2007.
		5	*
		6	* Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
		7	* Copyright (c) 2007-2008 Bartlomiej Wolowiec
		8	* Copyright (c) 2007 Justin Ruggles
		9	*
		10	* This file is part of FFmpeg.
		11	*
		12	* FFmpeg is free software; you can redistribute it and/or
		13	* modify it under the terms of the GNU Lesser General Public
		14	* License as published by the Free Software Foundation; either
		15	* version 2.1 of the License, or (at your option) any later version.
		16	*
		17	* FFmpeg is distributed in the hope that it will be useful,
		18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		20	* Lesser General Public License for more details.
		21	*
		22	* You should have received a copy of the GNU Lesser General Public
		23	* License along with FFmpeg; if not, write to the Free Software
		24	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		25	*/
		26
		27	#include
		28	#include
		29	#include
		30	#include
		31
		32	#include "libavutil/crc.h"
		33	#include "libavutil/opt.h"
		34	#include "internal.h"
		35	#include "aac_ac3_parser.h"
		36	#include "ac3_parser.h"
		37	#include "ac3dec.h"
		38	#include "ac3dec_data.h"
		39	#include "kbdwin.h"
		40
		41	/**
		42	* table for ungrouping 3 values in 7 bits.
		43	* used for exponents and bap=2 mantissas
		44	*/
		45	static uint8_t ungroup_3_in_7_bits_tab[128][3];
		46
		47	/** tables for ungrouping mantissas */
		48	static int b1_mantissas[32][3];
		49	static int b2_mantissas[128][3];
		50	static int b3_mantissas[8];
		51	static int b4_mantissas[128][2];
		52	static int b5_mantissas[16];
		53
		54	/**
		55	* Quantization table: levels for symmetric. bits for asymmetric.
		56	* reference: Table 7.18 Mapping of bap to Quantizer
		57	*/
		58	static const uint8_t quantization_tab[16] = {
		59	0, 3, 5, 7, 11, 15,
		60	5, 6, 7, 8, 9, 10, 11, 12, 14, 16
		61	};
		62
		63	/** dynamic range table. converts codes to scale factors. */
		64	static float dynamic_range_tab[256];
		65
		66	/** Adjustments in dB gain */
		67	static const float gain_levels[9] = {
		68	LEVEL_PLUS_3DB,
		69	LEVEL_PLUS_1POINT5DB,
		70	LEVEL_ONE,
		71	LEVEL_MINUS_1POINT5DB,
		72	LEVEL_MINUS_3DB,
		73	LEVEL_MINUS_4POINT5DB,
		74	LEVEL_MINUS_6DB,
		75	LEVEL_ZERO,
		76	LEVEL_MINUS_9DB
		77	};
		78
		79	/**
		80	* Table for default stereo downmixing coefficients
		81	* reference: Section 7.8.2 Downmixing Into Two Channels
		82	*/
		83	static const uint8_t ac3_default_coeffs[8][5][2] = {
		84	{ { 2, 7 }, { 7, 2 }, },
		85	{ { 4, 4 }, },
		86	{ { 2, 7 }, { 7, 2 }, },
		87	{ { 2, 7 }, { 5, 5 }, { 7, 2 }, },
		88	{ { 2, 7 }, { 7, 2 }, { 6, 6 }, },
		89	{ { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
		90	{ { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
		91	{ { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
		92	};
		93
		94	/**
		95	* Symmetrical Dequantization
		96	* reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
		97	* Tables 7.19 to 7.23
		98	*/
		99	static inline int
		100	symmetric_dequant(int code, int levels)
		101	{
		102	return ((code - (levels >> 1)) << 24) / levels;
		103	}
		104
		105	/*
		106	* Initialize tables at runtime.
		107	*/
		108	static av_cold void ac3_tables_init(void)
		109	{
		110	int i;
		111
		112	/* generate table for ungrouping 3 values in 7 bits
		113	reference: Section 7.1.3 Exponent Decoding */
		114	for (i = 0; i < 128; i++) {
		115	ungroup_3_in_7_bits_tab[i][0] = i / 25;
		116	ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
		117	ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
		118	}
		119
		120	/* generate grouped mantissa tables
		121	reference: Section 7.3.5 Ungrouping of Mantissas */
		122	for (i = 0; i < 32; i++) {
		123	/* bap=1 mantissas */
		124	b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
		125	b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
		126	b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
		127	}
		128	for (i = 0; i < 128; i++) {
		129	/* bap=2 mantissas */
		130	b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
		131	b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
		132	b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
		133
		134	/* bap=4 mantissas */
		135	b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
		136	b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
		137	}
		138	/* generate ungrouped mantissa tables
		139	reference: Tables 7.21 and 7.23 */
		140	for (i = 0; i < 7; i++) {
		141	/* bap=3 mantissas */
		142	b3_mantissas[i] = symmetric_dequant(i, 7);
		143	}
		144	for (i = 0; i < 15; i++) {
		145	/* bap=5 mantissas */
		146	b5_mantissas[i] = symmetric_dequant(i, 15);
		147	}
		148
		149	/* generate dynamic range table
		150	reference: Section 7.7.1 Dynamic Range Control */
		151	for (i = 0; i < 256; i++) {
		152	int v = (i >> 5) - ((i >> 7) << 3) - 5;
		153	dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) \| 0x20);
		154	}
		155	}
		156
		157	/**
		158	* AVCodec initialization
		159	*/
		160	static av_cold int ac3_decode_init(AVCodecContext *avctx)
		161	{
		162	AC3DecodeContext *s = avctx->priv_data;
		163	int i;
		164
		165	s->avctx = avctx;
		166
		167	ff_ac3_common_init();
		168	ac3_tables_init();
		169	ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
		170	ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
		171	ff_kbd_window_init(s->window, 5.0, 256);
		172	ff_dsputil_init(&s->dsp, avctx);
		173	avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
		174	ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
		175	ff_fmt_convert_init(&s->fmt_conv, avctx);
		176	av_lfg_init(&s->dith_state, 0);
		177
		178	avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
		179
		180	/* allow downmixing to stereo or mono */
		181	if (avctx->channels > 0 && avctx->request_channels > 0 &&
		182	avctx->request_channels < avctx->channels &&
		183	avctx->request_channels <= 2) {
		184	avctx->channels = avctx->request_channels;
		185	}
		186	s->downmixed = 1;
		187
		188	for (i = 0; i < AC3_MAX_CHANNELS; i++) {
		189	s->xcfptr[i] = s->transform_coeffs[i];
		190	s->dlyptr[i] = s->delay[i];
		191	}
		192
		193	return 0;
		194	}
		195
		196	/**
		197	* Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
		198	* GetBitContext within AC3DecodeContext must point to
		199	* the start of the synchronized AC-3 bitstream.
		200	*/
		201	static int ac3_parse_header(AC3DecodeContext *s)
		202	{
		203	GetBitContext *gbc = &s->gbc;
		204	int i;
		205
		206	/* read the rest of the bsi. read twice for dual mono mode. */
		207	i = !s->channel_mode;
		208	do {
		209	skip_bits(gbc, 5); // skip dialog normalization
		210	if (get_bits1(gbc))
		211	skip_bits(gbc, 8); //skip compression
		212	if (get_bits1(gbc))
		213	skip_bits(gbc, 8); //skip language code
		214	if (get_bits1(gbc))
		215	skip_bits(gbc, 7); //skip audio production information
		216	} while (i--);
		217
		218	skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
		219
		220	/* skip the timecodes (or extra bitstream information for Alternate Syntax)
		221	TODO: read & use the xbsi1 downmix levels */
		222	if (get_bits1(gbc))
		223	skip_bits(gbc, 14); //skip timecode1 / xbsi1
		224	if (get_bits1(gbc))
		225	skip_bits(gbc, 14); //skip timecode2 / xbsi2
		226
		227	/* skip additional bitstream info */
		228	if (get_bits1(gbc)) {
		229	i = get_bits(gbc, 6);
		230	do {
		231	skip_bits(gbc, 8);
		232	} while (i--);
		233	}
		234
		235	return 0;
		236	}
		237
		238	/**
		239	* Common function to parse AC-3 or E-AC-3 frame header
		240	*/
		241	static int parse_frame_header(AC3DecodeContext *s)
		242	{
		243	AC3HeaderInfo hdr;
		244	int err;
		245
		246	err = avpriv_ac3_parse_header(&s->gbc, &hdr);
		247	if (err)
		248	return err;
		249
		250	/* get decoding parameters from header info */
		251	s->bit_alloc_params.sr_code = hdr.sr_code;
		252	s->bitstream_mode = hdr.bitstream_mode;
		253	s->channel_mode = hdr.channel_mode;
		254	s->channel_layout = hdr.channel_layout;
		255	s->lfe_on = hdr.lfe_on;
		256	s->bit_alloc_params.sr_shift = hdr.sr_shift;
		257	s->sample_rate = hdr.sample_rate;
		258	s->bit_rate = hdr.bit_rate;
		259	s->channels = hdr.channels;
		260	s->fbw_channels = s->channels - s->lfe_on;
		261	s->lfe_ch = s->fbw_channels + 1;
		262	s->frame_size = hdr.frame_size;
		263	s->center_mix_level = hdr.center_mix_level;
		264	s->surround_mix_level = hdr.surround_mix_level;
		265	s->num_blocks = hdr.num_blocks;
		266	s->frame_type = hdr.frame_type;
		267	s->substreamid = hdr.substreamid;
		268
		269	if (s->lfe_on) {
		270	s->start_freq[s->lfe_ch] = 0;
		271	s->end_freq[s->lfe_ch] = 7;
		272	s->num_exp_groups[s->lfe_ch] = 2;
		273	s->channel_in_cpl[s->lfe_ch] = 0;
		274	}
		275
		276	if (hdr.bitstream_id <= 10) {
		277	s->eac3 = 0;
		278	s->snr_offset_strategy = 2;
		279	s->block_switch_syntax = 1;
		280	s->dither_flag_syntax = 1;
		281	s->bit_allocation_syntax = 1;
		282	s->fast_gain_syntax = 0;
		283	s->first_cpl_leak = 0;
		284	s->dba_syntax = 1;
		285	s->skip_syntax = 1;
		286	memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
		287	return ac3_parse_header(s);
		288	} else if (CONFIG_EAC3_DECODER) {
		289	s->eac3 = 1;
		290	return ff_eac3_parse_header(s);
		291	} else {
		292	av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
		293	return AVERROR(ENOSYS);
		294	}
		295	}
		296
		297	/**
		298	* Set stereo downmixing coefficients based on frame header info.
		299	* reference: Section 7.8.2 Downmixing Into Two Channels
		300	*/
		301	static void set_downmix_coeffs(AC3DecodeContext *s)
		302	{
		303	int i;
		304	float cmix = gain_levels[s-> center_mix_level];
		305	float smix = gain_levels[s->surround_mix_level];
		306	float norm0, norm1;
		307
		308	for (i = 0; i < s->fbw_channels; i++) {
		309	s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
		310	s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
		311	}
		312	if (s->channel_mode > 1 && s->channel_mode & 1) {
		313	s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
		314	}
		315	if (s->channel_mode == AC3_CHMODE_2F1R \|\| s->channel_mode == AC3_CHMODE_3F1R) {
		316	int nf = s->channel_mode - 2;
		317	s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
		318	}
		319	if (s->channel_mode == AC3_CHMODE_2F2R \|\| s->channel_mode == AC3_CHMODE_3F2R) {
		320	int nf = s->channel_mode - 4;
		321	s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
		322	}
		323
		324	/* renormalize */
		325	norm0 = norm1 = 0.0;
		326	for (i = 0; i < s->fbw_channels; i++) {
		327	norm0 += s->downmix_coeffs[i][0];
		328	norm1 += s->downmix_coeffs[i][1];
		329	}
		330	norm0 = 1.0f / norm0;
		331	norm1 = 1.0f / norm1;
		332	for (i = 0; i < s->fbw_channels; i++) {
		333	s->downmix_coeffs[i][0] *= norm0;
		334	s->downmix_coeffs[i][1] *= norm1;
		335	}
		336
		337	if (s->output_mode == AC3_CHMODE_MONO) {
		338	for (i = 0; i < s->fbw_channels; i++)
		339	s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
		340	s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
		341	}
		342	}
		343
		344	/**
		345	* Decode the grouped exponents according to exponent strategy.
		346	* reference: Section 7.1.3 Exponent Decoding
		347	*/
		348	static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
		349	uint8_t absexp, int8_t *dexps)
		350	{
		351	int i, j, grp, group_size;
		352	int dexp[256];
		353	int expacc, prevexp;
		354
		355	/* unpack groups */
		356	group_size = exp_strategy + (exp_strategy == EXP_D45);
		357	for (grp = 0, i = 0; grp < ngrps; grp++) {
		358	expacc = get_bits(gbc, 7);
		359	dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
		360	dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
		361	dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
		362	}
		363
		364	/* convert to absolute exps and expand groups */
		365	prevexp = absexp;
		366	for (i = 0, j = 0; i < ngrps * 3; i++) {
		367	prevexp += dexp[i] - 2;
		368	if (prevexp > 24U)
		369	return -1;
		370	switch (group_size) {
		371	case 4: dexps[j++] = prevexp;
		372	dexps[j++] = prevexp;
		373	case 2: dexps[j++] = prevexp;
		374	case 1: dexps[j++] = prevexp;
		375	}
		376	}
		377	return 0;
		378	}
		379
		380	/**
		381	* Generate transform coefficients for each coupled channel in the coupling
		382	* range using the coupling coefficients and coupling coordinates.
		383	* reference: Section 7.4.3 Coupling Coordinate Format
		384	*/
		385	static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
		386	{
		387	int bin, band, ch;
		388
		389	bin = s->start_freq[CPL_CH];
		390	for (band = 0; band < s->num_cpl_bands; band++) {
		391	int band_start = bin;
		392	int band_end = bin + s->cpl_band_sizes[band];
		393	for (ch = 1; ch <= s->fbw_channels; ch++) {
		394	if (s->channel_in_cpl[ch]) {
		395	int cpl_coord = s->cpl_coords[ch][band] << 5;
		396	for (bin = band_start; bin < band_end; bin++) {
		397	s->fixed_coeffs[ch][bin] =
		398	MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
		399	}
		400	if (ch == 2 && s->phase_flags[band]) {
		401	for (bin = band_start; bin < band_end; bin++)
		402	s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
		403	}
		404	}
		405	}
		406	bin = band_end;
		407	}
		408	}
		409
		410	/**
		411	* Grouped mantissas for 3-level 5-level and 11-level quantization
		412	*/
		413	typedef struct {
		414	int b1_mant[2];
		415	int b2_mant[2];
		416	int b4_mant;
		417	int b1;
		418	int b2;
		419	int b4;
		420	} mant_groups;
		421
		422	/**
		423	* Decode the transform coefficients for a particular channel
		424	* reference: Section 7.3 Quantization and Decoding of Mantissas
		425	*/
		426	static void ac3_decode_transform_coeffs_ch(AC3DecodeContext s, int ch_index, mant_groups m)
		427	{
		428	int start_freq = s->start_freq[ch_index];
		429	int end_freq = s->end_freq[ch_index];
		430	uint8_t *baps = s->bap[ch_index];
		431	int8_t *exps = s->dexps[ch_index];
		432	int32_t *coeffs = s->fixed_coeffs[ch_index];
		433	int dither = (ch_index == CPL_CH) \|\| s->dither_flag[ch_index];
		434	GetBitContext *gbc = &s->gbc;
		435	int freq;
		436
		437	for (freq = start_freq; freq < end_freq; freq++) {
		438	int bap = baps[freq];
		439	int mantissa;
		440	switch (bap) {
		441	case 0:
		442	/* random noise with approximate range of -0.707 to 0.707 */
		443	if (dither)
		444	mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
		445	else
		446	mantissa = 0;
		447	break;
		448	case 1:
		449	if (m->b1) {
		450	m->b1--;
		451	mantissa = m->b1_mant[m->b1];
		452	} else {
		453	int bits = get_bits(gbc, 5);
		454	mantissa = b1_mantissas[bits][0];
		455	m->b1_mant[1] = b1_mantissas[bits][1];
		456	m->b1_mant[0] = b1_mantissas[bits][2];
		457	m->b1 = 2;
		458	}
		459	break;
		460	case 2:
		461	if (m->b2) {
		462	m->b2--;
		463	mantissa = m->b2_mant[m->b2];
		464	} else {
		465	int bits = get_bits(gbc, 7);
		466	mantissa = b2_mantissas[bits][0];
		467	m->b2_mant[1] = b2_mantissas[bits][1];
		468	m->b2_mant[0] = b2_mantissas[bits][2];
		469	m->b2 = 2;
		470	}
		471	break;
		472	case 3:
		473	mantissa = b3_mantissas[get_bits(gbc, 3)];
		474	break;
		475	case 4:
		476	if (m->b4) {
		477	m->b4 = 0;
		478	mantissa = m->b4_mant;
		479	} else {
		480	int bits = get_bits(gbc, 7);
		481	mantissa = b4_mantissas[bits][0];
		482	m->b4_mant = b4_mantissas[bits][1];
		483	m->b4 = 1;
		484	}
		485	break;
		486	case 5:
		487	mantissa = b5_mantissas[get_bits(gbc, 4)];
		488	break;
		489	default: /* 6 to 15 */
		490	/* Shift mantissa and sign-extend it. */
		491	mantissa = get_sbits(gbc, quantization_tab[bap]);
		492	mantissa <<= 24 - quantization_tab[bap];
		493	break;
		494	}
		495	coeffs[freq] = mantissa >> exps[freq];
		496	}
		497	}
		498
		499	/**
		500	* Remove random dithering from coupling range coefficients with zero-bit
		501	* mantissas for coupled channels which do not use dithering.
		502	* reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
		503	*/
		504	static void remove_dithering(AC3DecodeContext *s) {
		505	int ch, i;
		506
		507	for (ch = 1; ch <= s->fbw_channels; ch++) {
		508	if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
		509	for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
		510	if (!s->bap[CPL_CH][i])
		511	s->fixed_coeffs[ch][i] = 0;
		512	}
		513	}
		514	}
		515	}
		516
		517	static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
		518	mant_groups *m)
		519	{
		520	if (!s->channel_uses_aht[ch]) {
		521	ac3_decode_transform_coeffs_ch(s, ch, m);
		522	} else {
		523	/* if AHT is used, mantissas for all blocks are encoded in the first
		524	block of the frame. */
		525	int bin;
		526	if (!blk && CONFIG_EAC3_DECODER)
		527	ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
		528	for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
		529	s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
		530	}
		531	}
		532	}
		533
		534	/**
		535	* Decode the transform coefficients.
		536	*/
		537	static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
		538	{
		539	int ch, end;
		540	int got_cplchan = 0;
		541	mant_groups m;
		542
		543	m.b1 = m.b2 = m.b4 = 0;
		544
		545	for (ch = 1; ch <= s->channels; ch++) {
		546	/* transform coefficients for full-bandwidth channel */
		547	decode_transform_coeffs_ch(s, blk, ch, &m);
		548	/* transform coefficients for coupling channel come right after the
		549	coefficients for the first coupled channel*/
		550	if (s->channel_in_cpl[ch]) {
		551	if (!got_cplchan) {
		552	decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
		553	calc_transform_coeffs_cpl(s);
		554	got_cplchan = 1;
		555	}
		556	end = s->end_freq[CPL_CH];
		557	} else {
		558	end = s->end_freq[ch];
		559	}
		560	do
		561	s->fixed_coeffs[ch][end] = 0;
		562	while (++end < 256);
		563	}
		564
		565	/* zero the dithered coefficients for appropriate channels */
		566	remove_dithering(s);
		567	}
		568
		569	/**
		570	* Stereo rematrixing.
		571	* reference: Section 7.5.4 Rematrixing : Decoding Technique
		572	*/
		573	static void do_rematrixing(AC3DecodeContext *s)
		574	{
		575	int bnd, i;
		576	int end, bndend;
		577
		578	end = FFMIN(s->end_freq[1], s->end_freq[2]);
		579
		580	for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
		581	if (s->rematrixing_flags[bnd]) {
		582	bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
		583	for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
		584	int tmp0 = s->fixed_coeffs[1][i];
		585	s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
		586	s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
		587	}
		588	}
		589	}
		590	}
		591
		592	/**
		593	* Inverse MDCT Transform.
		594	* Convert frequency domain coefficients to time-domain audio samples.
		595	* reference: Section 7.9.4 Transformation Equations
		596	*/
		597	static inline void do_imdct(AC3DecodeContext *s, int channels)
		598	{
		599	int ch;
		600
		601	for (ch = 1; ch <= channels; ch++) {
		602	if (s->block_switch[ch]) {
		603	int i;
		604	float *x = s->tmp_output + 128;
		605	for (i = 0; i < 128; i++)
		606	x[i] = s->transform_coeffs[ch][2 * i];
		607	s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
		608	s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
		609	s->tmp_output, s->window, 128);
		610	for (i = 0; i < 128; i++)
		611	x[i] = s->transform_coeffs[ch][2 * i + 1];
		612	s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
		613	} else {
		614	s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
		615	s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
		616	s->tmp_output, s->window, 128);
		617	memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
		618	}
		619	}
		620	}
		621
		622	/**
		623	* Upmix delay samples from stereo to original channel layout.
		624	*/
		625	static void ac3_upmix_delay(AC3DecodeContext *s)
		626	{
		627	int channel_data_size = sizeof(s->delay[0]);
		628	switch (s->channel_mode) {
		629	case AC3_CHMODE_DUALMONO:
		630	case AC3_CHMODE_STEREO:
		631	/* upmix mono to stereo */
		632	memcpy(s->delay[1], s->delay[0], channel_data_size);
		633	break;
		634	case AC3_CHMODE_2F2R:
		635	memset(s->delay[3], 0, channel_data_size);
		636	case AC3_CHMODE_2F1R:
		637	memset(s->delay[2], 0, channel_data_size);
		638	break;
		639	case AC3_CHMODE_3F2R:
		640	memset(s->delay[4], 0, channel_data_size);
		641	case AC3_CHMODE_3F1R:
		642	memset(s->delay[3], 0, channel_data_size);
		643	case AC3_CHMODE_3F:
		644	memcpy(s->delay[2], s->delay[1], channel_data_size);
		645	memset(s->delay[1], 0, channel_data_size);
		646	break;
		647	}
		648	}
		649
		650	/**
		651	* Decode band structure for coupling, spectral extension, or enhanced coupling.
		652	* The band structure defines how many subbands are in each band. For each
		653	* subband in the range, 1 means it is combined with the previous band, and 0
		654	* means that it starts a new band.
		655	*
		656	* @param[in] gbc bit reader context
		657	* @param[in] blk block number
		658	* @param[in] eac3 flag to indicate E-AC-3
		659	* @param[in] ecpl flag to indicate enhanced coupling
		660	* @param[in] start_subband subband number for start of range
		661	* @param[in] end_subband subband number for end of range
		662	* @param[in] default_band_struct default band structure table
		663	* @param[out] num_bands number of bands (optionally NULL)
		664	* @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
		665	*/
		666	static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
		667	int ecpl, int start_subband, int end_subband,
		668	const uint8_t *default_band_struct,
		669	int num_bands, uint8_t band_sizes)
		670	{
		671	int subbnd, bnd, n_subbands, n_bands=0;
		672	uint8_t bnd_sz[22];
		673	uint8_t coded_band_struct[22];
		674	const uint8_t *band_struct;
		675
		676	n_subbands = end_subband - start_subband;
		677
		678	/* decode band structure from bitstream or use default */
		679	if (!eac3 \|\| get_bits1(gbc)) {
		680	for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
		681	coded_band_struct[subbnd] = get_bits1(gbc);
		682	}
		683	band_struct = coded_band_struct;
		684	} else if (!blk) {
		685	band_struct = &default_band_struct[start_subband+1];
		686	} else {
		687	/* no change in band structure */
		688	return;
		689	}
		690
		691	/* calculate number of bands and band sizes based on band structure.
		692	note that the first 4 subbands in enhanced coupling span only 6 bins
		693	instead of 12. */
		694	if (num_bands \|\| band_sizes ) {
		695	n_bands = n_subbands;
		696	bnd_sz[0] = ecpl ? 6 : 12;
		697	for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
		698	int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
		699	if (band_struct[subbnd - 1]) {
		700	n_bands--;
		701	bnd_sz[bnd] += subbnd_size;
		702	} else {
		703	bnd_sz[++bnd] = subbnd_size;
		704	}
		705	}
		706	}
		707
		708	/* set optional output params */
		709	if (num_bands)
		710	*num_bands = n_bands;
		711	if (band_sizes)
		712	memcpy(band_sizes, bnd_sz, n_bands);
		713	}
		714
		715	/**
		716	* Decode a single audio block from the AC-3 bitstream.
		717	*/
		718	static int decode_audio_block(AC3DecodeContext *s, int blk)
		719	{
		720	int fbw_channels = s->fbw_channels;
		721	int channel_mode = s->channel_mode;
		722	int i, bnd, seg, ch;
		723	int different_transforms;
		724	int downmix_output;
		725	int cpl_in_use;
		726	GetBitContext *gbc = &s->gbc;
		727	uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
		728
		729	/* block switch flags */
		730	different_transforms = 0;
		731	if (s->block_switch_syntax) {
		732	for (ch = 1; ch <= fbw_channels; ch++) {
		733	s->block_switch[ch] = get_bits1(gbc);
		734	if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
		735	different_transforms = 1;
		736	}
		737	}
		738
		739	/* dithering flags */
		740	if (s->dither_flag_syntax) {
		741	for (ch = 1; ch <= fbw_channels; ch++) {
		742	s->dither_flag[ch] = get_bits1(gbc);
		743	}
		744	}
		745
		746	/* dynamic range */
		747	i = !s->channel_mode;
		748	do {
		749	if (get_bits1(gbc)) {
		750	s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
		751	s->drc_scale) + 1.0;
		752	} else if (blk == 0) {
		753	s->dynamic_range[i] = 1.0f;
		754	}
		755	} while (i--);
		756
		757	/* spectral extension strategy */
		758	if (s->eac3 && (!blk \|\| get_bits1(gbc))) {
		759	s->spx_in_use = get_bits1(gbc);
		760	if (s->spx_in_use) {
		761	int dst_start_freq, dst_end_freq, src_start_freq,
		762	start_subband, end_subband;
		763
		764	/* determine which channels use spx */
		765	if (s->channel_mode == AC3_CHMODE_MONO) {
		766	s->channel_uses_spx[1] = 1;
		767	} else {
		768	for (ch = 1; ch <= fbw_channels; ch++)
		769	s->channel_uses_spx[ch] = get_bits1(gbc);
		770	}
		771
		772	/* get the frequency bins of the spx copy region and the spx start
		773	and end subbands */
		774	dst_start_freq = get_bits(gbc, 2);
		775	start_subband = get_bits(gbc, 3) + 2;
		776	if (start_subband > 7)
		777	start_subband += start_subband - 7;
		778	end_subband = get_bits(gbc, 3) + 5;
		779	if (end_subband > 7)
		780	end_subband += end_subband - 7;
		781	dst_start_freq = dst_start_freq * 12 + 25;
		782	src_start_freq = start_subband * 12 + 25;
		783	dst_end_freq = end_subband * 12 + 25;
		784
		785	/* check validity of spx ranges */
		786	if (start_subband >= end_subband) {
		787	av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
		788	"range (%d >= %d)\n", start_subband, end_subband);
		789	return AVERROR_INVALIDDATA;
		790	}
		791	if (dst_start_freq >= src_start_freq) {
		792	av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
		793	"copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
		794	return AVERROR_INVALIDDATA;
		795	}
		796
		797	s->spx_dst_start_freq = dst_start_freq;
		798	s->spx_src_start_freq = src_start_freq;
		799	s->spx_dst_end_freq = dst_end_freq;
		800
		801	decode_band_structure(gbc, blk, s->eac3, 0,
		802	start_subband, end_subband,
		803	ff_eac3_default_spx_band_struct,
		804	&s->num_spx_bands,
		805	s->spx_band_sizes);
		806	} else {
		807	for (ch = 1; ch <= fbw_channels; ch++) {
		808	s->channel_uses_spx[ch] = 0;
		809	s->first_spx_coords[ch] = 1;
		810	}
		811	}
		812	}
		813
		814	/* spectral extension coordinates */
		815	if (s->spx_in_use) {
		816	for (ch = 1; ch <= fbw_channels; ch++) {
		817	if (s->channel_uses_spx[ch]) {
		818	if (s->first_spx_coords[ch] \|\| get_bits1(gbc)) {
		819	float spx_blend;
		820	int bin, master_spx_coord;
		821
		822	s->first_spx_coords[ch] = 0;
		823	spx_blend = get_bits(gbc, 5) * (1.0f/32);
		824	master_spx_coord = get_bits(gbc, 2) * 3;
		825
		826	bin = s->spx_src_start_freq;
		827	for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
		828	int bandsize;
		829	int spx_coord_exp, spx_coord_mant;
		830	float nratio, sblend, nblend, spx_coord;
		831
		832	/* calculate blending factors */
		833	bandsize = s->spx_band_sizes[bnd];
		834	nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
		835	nratio = av_clipf(nratio, 0.0f, 1.0f);
		836	nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
		837	// to give unity variance
		838	sblend = sqrtf(1.0f - nratio);
		839	bin += bandsize;
		840
		841	/* decode spx coordinates */
		842	spx_coord_exp = get_bits(gbc, 4);
		843	spx_coord_mant = get_bits(gbc, 2);
		844	if (spx_coord_exp == 15) spx_coord_mant <<= 1;
		845	else spx_coord_mant += 4;
		846	spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
		847	spx_coord = spx_coord_mant * (1.0f / (1 << 23));
		848
		849	/* multiply noise and signal blending factors by spx coordinate */
		850	s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
		851	s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
		852	}
		853	}
		854	} else {
		855	s->first_spx_coords[ch] = 1;
		856	}
		857	}
		858	}
		859
		860	/* coupling strategy */
		861	if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
		862	memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
		863	if (!s->eac3)
		864	s->cpl_in_use[blk] = get_bits1(gbc);
		865	if (s->cpl_in_use[blk]) {
		866	/* coupling in use */
		867	int cpl_start_subband, cpl_end_subband;
		868
		869	if (channel_mode < AC3_CHMODE_STEREO) {
		870	av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
		871	return AVERROR_INVALIDDATA;
		872	}
		873
		874	/* check for enhanced coupling */
		875	if (s->eac3 && get_bits1(gbc)) {
		876	/* TODO: parse enhanced coupling strategy info */
		877	avpriv_request_sample(s->avctx, "Enhanced coupling");
		878	return AVERROR_PATCHWELCOME;
		879	}
		880
		881	/* determine which channels are coupled */
		882	if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
		883	s->channel_in_cpl[1] = 1;
		884	s->channel_in_cpl[2] = 1;
		885	} else {
		886	for (ch = 1; ch <= fbw_channels; ch++)
		887	s->channel_in_cpl[ch] = get_bits1(gbc);
		888	}
		889
		890	/* phase flags in use */
		891	if (channel_mode == AC3_CHMODE_STEREO)
		892	s->phase_flags_in_use = get_bits1(gbc);
		893
		894	/* coupling frequency range */
		895	cpl_start_subband = get_bits(gbc, 4);
		896	cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
		897	get_bits(gbc, 4) + 3;
		898	if (cpl_start_subband >= cpl_end_subband) {
		899	av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
		900	cpl_start_subband, cpl_end_subband);
		901	return AVERROR_INVALIDDATA;
		902	}
		903	s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
		904	s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
		905
		906	decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
		907	cpl_end_subband,
		908	ff_eac3_default_cpl_band_struct,
		909	&s->num_cpl_bands, s->cpl_band_sizes);
		910	} else {
		911	/* coupling not in use */
		912	for (ch = 1; ch <= fbw_channels; ch++) {
		913	s->channel_in_cpl[ch] = 0;
		914	s->first_cpl_coords[ch] = 1;
		915	}
		916	s->first_cpl_leak = s->eac3;
		917	s->phase_flags_in_use = 0;
		918	}
		919	} else if (!s->eac3) {
		920	if (!blk) {
		921	av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
		922	"be present in block 0\n");
		923	return AVERROR_INVALIDDATA;
		924	} else {
		925	s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
		926	}
		927	}
		928	cpl_in_use = s->cpl_in_use[blk];
		929
		930	/* coupling coordinates */
		931	if (cpl_in_use) {
		932	int cpl_coords_exist = 0;
		933
		934	for (ch = 1; ch <= fbw_channels; ch++) {
		935	if (s->channel_in_cpl[ch]) {
		936	if ((s->eac3 && s->first_cpl_coords[ch]) \|\| get_bits1(gbc)) {
		937	int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
		938	s->first_cpl_coords[ch] = 0;
		939	cpl_coords_exist = 1;
		940	master_cpl_coord = 3 * get_bits(gbc, 2);
		941	for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
		942	cpl_coord_exp = get_bits(gbc, 4);
		943	cpl_coord_mant = get_bits(gbc, 4);
		944	if (cpl_coord_exp == 15)
		945	s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
		946	else
		947	s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
		948	s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
		949	}
		950	} else if (!blk) {
		951	av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
		952	"be present in block 0\n");
		953	return AVERROR_INVALIDDATA;
		954	}
		955	} else {
		956	/* channel not in coupling */
		957	s->first_cpl_coords[ch] = 1;
		958	}
		959	}
		960	/* phase flags */
		961	if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
		962	for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
		963	s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
		964	}
		965	}
		966	}
		967
		968	/* stereo rematrixing strategy and band structure */
		969	if (channel_mode == AC3_CHMODE_STEREO) {
		970	if ((s->eac3 && !blk) \|\| get_bits1(gbc)) {
		971	s->num_rematrixing_bands = 4;
		972	if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
		973	s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
		974	} else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
		975	s->num_rematrixing_bands--;
		976	}
		977	for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
		978	s->rematrixing_flags[bnd] = get_bits1(gbc);
		979	} else if (!blk) {
		980	av_log(s->avctx, AV_LOG_WARNING, "Warning: "
		981	"new rematrixing strategy not present in block 0\n");
		982	s->num_rematrixing_bands = 0;
		983	}
		984	}
		985
		986	/* exponent strategies for each channel */
		987	for (ch = !cpl_in_use; ch <= s->channels; ch++) {
		988	if (!s->eac3)
		989	s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
		990	if (s->exp_strategy[blk][ch] != EXP_REUSE)
		991	bit_alloc_stages[ch] = 3;
		992	}
		993
		994	/* channel bandwidth */
		995	for (ch = 1; ch <= fbw_channels; ch++) {
		996	s->start_freq[ch] = 0;
		997	if (s->exp_strategy[blk][ch] != EXP_REUSE) {
		998	int group_size;
		999	int prev = s->end_freq[ch];
		1000	if (s->channel_in_cpl[ch])
		1001	s->end_freq[ch] = s->start_freq[CPL_CH];
		1002	else if (s->channel_uses_spx[ch])
		1003	s->end_freq[ch] = s->spx_src_start_freq;
		1004	else {
		1005	int bandwidth_code = get_bits(gbc, 6);
		1006	if (bandwidth_code > 60) {
		1007	av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
		1008	return AVERROR_INVALIDDATA;
		1009	}
		1010	s->end_freq[ch] = bandwidth_code * 3 + 73;
		1011	}
		1012	group_size = 3 << (s->exp_strategy[blk][ch] - 1);
		1013	s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
		1014	if (blk > 0 && s->end_freq[ch] != prev)
		1015	memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
		1016	}
		1017	}
		1018	if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
		1019	s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
		1020	(3 << (s->exp_strategy[blk][CPL_CH] - 1));
		1021	}
		1022
		1023	/* decode exponents for each channel */
		1024	for (ch = !cpl_in_use; ch <= s->channels; ch++) {
		1025	if (s->exp_strategy[blk][ch] != EXP_REUSE) {
		1026	s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
		1027	if (decode_exponents(gbc, s->exp_strategy[blk][ch],
		1028	s->num_exp_groups[ch], s->dexps[ch][0],
		1029	&s->dexps[ch][s->start_freq[ch]+!!ch])) {
		1030	av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
		1031	return AVERROR_INVALIDDATA;
		1032	}
		1033	if (ch != CPL_CH && ch != s->lfe_ch)
		1034	skip_bits(gbc, 2); /* skip gainrng */
		1035	}
		1036	}
		1037
		1038	/* bit allocation information */
		1039	if (s->bit_allocation_syntax) {
		1040	if (get_bits1(gbc)) {
		1041	s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
		1042	s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
		1043	s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
		1044	s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
		1045	s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
		1046	for (ch = !cpl_in_use; ch <= s->channels; ch++)
		1047	bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
		1048	} else if (!blk) {
		1049	av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
		1050	"be present in block 0\n");
		1051	return AVERROR_INVALIDDATA;
		1052	}
		1053	}
		1054
		1055	/* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
		1056	if (!s->eac3 \|\| !blk) {
		1057	if (s->snr_offset_strategy && get_bits1(gbc)) {
		1058	int snr = 0;
		1059	int csnr;
		1060	csnr = (get_bits(gbc, 6) - 15) << 4;
		1061	for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
		1062	/* snr offset */
		1063	if (ch == i \|\| s->snr_offset_strategy == 2)
		1064	snr = (csnr + get_bits(gbc, 4)) << 2;
		1065	/* run at least last bit allocation stage if snr offset changes */
		1066	if (blk && s->snr_offset[ch] != snr) {
		1067	bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
		1068	}
		1069	s->snr_offset[ch] = snr;
		1070
		1071	/* fast gain (normal AC-3 only) */
		1072	if (!s->eac3) {
		1073	int prev = s->fast_gain[ch];
		1074	s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
		1075	/* run last 2 bit allocation stages if fast gain changes */
		1076	if (blk && prev != s->fast_gain[ch])
		1077	bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
		1078	}
		1079	}
		1080	} else if (!s->eac3 && !blk) {
		1081	av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
		1082	return AVERROR_INVALIDDATA;
		1083	}
		1084	}
		1085
		1086	/* fast gain (E-AC-3 only) */
		1087	if (s->fast_gain_syntax && get_bits1(gbc)) {
		1088	for (ch = !cpl_in_use; ch <= s->channels; ch++) {
		1089	int prev = s->fast_gain[ch];
		1090	s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
		1091	/* run last 2 bit allocation stages if fast gain changes */
		1092	if (blk && prev != s->fast_gain[ch])
		1093	bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
		1094	}
		1095	} else if (s->eac3 && !blk) {
		1096	for (ch = !cpl_in_use; ch <= s->channels; ch++)
		1097	s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
		1098	}
		1099
		1100	/* E-AC-3 to AC-3 converter SNR offset */
		1101	if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
		1102	skip_bits(gbc, 10); // skip converter snr offset
		1103	}
		1104
		1105	/* coupling leak information */
		1106	if (cpl_in_use) {
		1107	if (s->first_cpl_leak \|\| get_bits1(gbc)) {
		1108	int fl = get_bits(gbc, 3);
		1109	int sl = get_bits(gbc, 3);
		1110	/* run last 2 bit allocation stages for coupling channel if
		1111	coupling leak changes */
		1112	if (blk && (fl != s->bit_alloc_params.cpl_fast_leak \|\|
		1113	sl != s->bit_alloc_params.cpl_slow_leak)) {
		1114	bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
		1115	}
		1116	s->bit_alloc_params.cpl_fast_leak = fl;
		1117	s->bit_alloc_params.cpl_slow_leak = sl;
		1118	} else if (!s->eac3 && !blk) {
		1119	av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
		1120	"be present in block 0\n");
		1121	return AVERROR_INVALIDDATA;
		1122	}
		1123	s->first_cpl_leak = 0;
		1124	}
		1125
		1126	/* delta bit allocation information */
		1127	if (s->dba_syntax && get_bits1(gbc)) {
		1128	/* delta bit allocation exists (strategy) */
		1129	for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
		1130	s->dba_mode[ch] = get_bits(gbc, 2);
		1131	if (s->dba_mode[ch] == DBA_RESERVED) {
		1132	av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
		1133	return AVERROR_INVALIDDATA;
		1134	}
		1135	bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
		1136	}
		1137	/* channel delta offset, len and bit allocation */
		1138	for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
		1139	if (s->dba_mode[ch] == DBA_NEW) {
		1140	s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
		1141	for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
		1142	s->dba_offsets[ch][seg] = get_bits(gbc, 5);
		1143	s->dba_lengths[ch][seg] = get_bits(gbc, 4);
		1144	s->dba_values[ch][seg] = get_bits(gbc, 3);
		1145	}
		1146	/* run last 2 bit allocation stages if new dba values */
		1147	bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
		1148	}
		1149	}
		1150	} else if (blk == 0) {
		1151	for (ch = 0; ch <= s->channels; ch++) {
		1152	s->dba_mode[ch] = DBA_NONE;
		1153	}
		1154	}
		1155
		1156	/* Bit allocation */
		1157	for (ch = !cpl_in_use; ch <= s->channels; ch++) {
		1158	if (bit_alloc_stages[ch] > 2) {
		1159	/* Exponent mapping into PSD and PSD integration */
		1160	ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
		1161	s->start_freq[ch], s->end_freq[ch],
		1162	s->psd[ch], s->band_psd[ch]);
		1163	}
		1164	if (bit_alloc_stages[ch] > 1) {
		1165	/* Compute excitation function, Compute masking curve, and
		1166	Apply delta bit allocation */
		1167	if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
		1168	s->start_freq[ch], s->end_freq[ch],
		1169	s->fast_gain[ch], (ch == s->lfe_ch),
		1170	s->dba_mode[ch], s->dba_nsegs[ch],
		1171	s->dba_offsets[ch], s->dba_lengths[ch],
		1172	s->dba_values[ch], s->mask[ch])) {
		1173	av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
		1174	return AVERROR_INVALIDDATA;
		1175	}
		1176	}
		1177	if (bit_alloc_stages[ch] > 0) {
		1178	/* Compute bit allocation */
		1179	const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
		1180	ff_eac3_hebap_tab : ff_ac3_bap_tab;
		1181	s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
		1182	s->start_freq[ch], s->end_freq[ch],
		1183	s->snr_offset[ch],
		1184	s->bit_alloc_params.floor,
		1185	bap_tab, s->bap[ch]);
		1186	}
		1187	}
		1188
		1189	/* unused dummy data */
		1190	if (s->skip_syntax && get_bits1(gbc)) {
		1191	int skipl = get_bits(gbc, 9);
		1192	while (skipl--)
		1193	skip_bits(gbc, 8);
		1194	}
		1195
		1196	/* unpack the transform coefficients
		1197	this also uncouples channels if coupling is in use. */
		1198	decode_transform_coeffs(s, blk);
		1199
		1200	/* TODO: generate enhanced coupling coordinates and uncouple */
		1201
		1202	/* recover coefficients if rematrixing is in use */
		1203	if (s->channel_mode == AC3_CHMODE_STEREO)
		1204	do_rematrixing(s);
		1205
		1206	/* apply scaling to coefficients (headroom, dynrng) */
		1207	for (ch = 1; ch <= s->channels; ch++) {
		1208	float gain = 1.0 / 4194304.0f;
		1209	if (s->channel_mode == AC3_CHMODE_DUALMONO) {
		1210	gain *= s->dynamic_range[2 - ch];
		1211	} else {
		1212	gain *= s->dynamic_range[0];
		1213	}
		1214	s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
		1215	s->fixed_coeffs[ch], gain, 256);
		1216	}
		1217
		1218	/* apply spectral extension to high frequency bins */
		1219	if (s->spx_in_use && CONFIG_EAC3_DECODER) {
		1220	ff_eac3_apply_spectral_extension(s);
		1221	}
		1222
		1223	/* downmix and MDCT. order depends on whether block switching is used for
		1224	any channel in this block. this is because coefficients for the long
		1225	and short transforms cannot be mixed. */
		1226	downmix_output = s->channels != s->out_channels &&
		1227	!((s->output_mode & AC3_OUTPUT_LFEON) &&
		1228	s->fbw_channels == s->out_channels);
		1229	if (different_transforms) {
		1230	/* the delay samples have already been downmixed, so we upmix the delay
		1231	samples in order to reconstruct all channels before downmixing. */
		1232	if (s->downmixed) {
		1233	s->downmixed = 0;
		1234	ac3_upmix_delay(s);
		1235	}
		1236
		1237	do_imdct(s, s->channels);
		1238
		1239	if (downmix_output) {
		1240	s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
		1241	s->out_channels, s->fbw_channels, 256);
		1242	}
		1243	} else {
		1244	if (downmix_output) {
		1245	s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
		1246	s->out_channels, s->fbw_channels, 256);
		1247	}
		1248
		1249	if (downmix_output && !s->downmixed) {
		1250	s->downmixed = 1;
		1251	s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
		1252	s->fbw_channels, 128);
		1253	}
		1254
		1255	do_imdct(s, s->out_channels);
		1256	}
		1257
		1258	return 0;
		1259	}
		1260
		1261	/**
		1262	* Decode a single AC-3 frame.
		1263	*/
		1264	static int ac3_decode_frame(AVCodecContext * avctx, void *data,
		1265	int got_frame_ptr, AVPacket avpkt)
		1266	{
		1267	AVFrame *frame = data;
		1268	const uint8_t *buf = avpkt->data;
		1269	int buf_size = avpkt->size;
		1270	AC3DecodeContext *s = avctx->priv_data;
		1271	int blk, ch, err, ret;
		1272	const uint8_t *channel_map;
		1273	const float *output[AC3_MAX_CHANNELS];
		1274
		1275	/* copy input buffer to decoder context to avoid reading past the end
		1276	of the buffer, which can be caused by a damaged input stream. */
		1277	if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
		1278	// seems to be byte-swapped AC-3
		1279	int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
		1280	s->dsp.bswap16_buf((uint16_t )s->input_buffer, (const uint16_t )buf, cnt);
		1281	} else
		1282	memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
		1283	buf = s->input_buffer;
		1284	/* initialize the GetBitContext with the start of valid AC-3 Frame */
		1285	init_get_bits(&s->gbc, buf, buf_size * 8);
		1286
		1287	/* parse the syncinfo */
		1288	err = parse_frame_header(s);
		1289
		1290	if (err) {
		1291	switch (err) {
		1292	case AAC_AC3_PARSE_ERROR_SYNC:
		1293	av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
		1294	return AVERROR_INVALIDDATA;
		1295	case AAC_AC3_PARSE_ERROR_BSID:
		1296	av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
		1297	break;
		1298	case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
		1299	av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
		1300	break;
		1301	case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
		1302	av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
		1303	break;
		1304	case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
		1305	/* skip frame if CRC is ok. otherwise use error concealment. */
		1306	/* TODO: add support for substreams and dependent frames */
		1307	if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT \|\| s->substreamid) {
		1308	av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
		1309	"skipping frame\n");
		1310	*got_frame_ptr = 0;
		1311	return buf_size;
		1312	} else {
		1313	av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
		1314	}
		1315	break;
		1316	case AAC_AC3_PARSE_ERROR_CRC:
		1317	case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
		1318	break;
		1319	default: // Normal AVERROR do not try to recover.
		1320	*got_frame_ptr = 0;
		1321	return err;
		1322	}
		1323	} else {
		1324	/* check that reported frame size fits in input buffer */
		1325	if (s->frame_size > buf_size) {
		1326	av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
		1327	err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
		1328	} else if (avctx->err_recognition & (AV_EF_CRCCHECK\|AV_EF_CAREFUL)) {
		1329	/* check for crc mismatch */
		1330	if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
		1331	s->frame_size - 2)) {
		1332	av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
		1333	err = AAC_AC3_PARSE_ERROR_CRC;
		1334	}
		1335	}
		1336	}
		1337
		1338	/* if frame is ok, set audio parameters */
		1339	if (!err) {
		1340	avctx->sample_rate = s->sample_rate;
		1341	avctx->bit_rate = s->bit_rate;
		1342	}
		1343
		1344	/* channel config */
		1345	if (!err \|\| (s->channels && s->out_channels != s->channels)) {
		1346	s->out_channels = s->channels;
		1347	s->output_mode = s->channel_mode;
		1348	if (s->lfe_on)
		1349	s->output_mode \|= AC3_OUTPUT_LFEON;
		1350	if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
		1351	avctx->request_channels < s->channels) {
		1352	s->out_channels = avctx->request_channels;
		1353	s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
		1354	s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];
		1355	}
		1356	avctx->channels = s->out_channels;
		1357	avctx->channel_layout = s->channel_layout;
		1358
		1359	s->loro_center_mix_level = gain_levels[s-> center_mix_level];
		1360	s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
		1361	s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
		1362	s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
		1363	/* set downmixing coefficients if needed */
		1364	if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
		1365	s->fbw_channels == s->out_channels)) {
		1366	set_downmix_coeffs(s);
		1367	}
		1368	} else if (!s->channels) {
		1369	av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
		1370	return AVERROR_INVALIDDATA;
		1371	}
		1372	avctx->channels = s->out_channels;
		1373
		1374	/* set audio service type based on bitstream mode for AC-3 */
		1375	avctx->audio_service_type = s->bitstream_mode;
		1376	if (s->bitstream_mode == 0x7 && s->channels > 1)
		1377	avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
		1378
		1379	/* get output buffer */
		1380	frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
		1381	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
		1382	return ret;
		1383
		1384	/* decode the audio blocks */
		1385	channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
		1386	for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
		1387	output[ch] = s->output[ch];
		1388	s->outptr[ch] = s->output[ch];
		1389	}
		1390	for (ch = 0; ch < s->channels; ch++) {
		1391	if (ch < s->out_channels)
		1392	s->outptr[channel_map[ch]] = (float *)frame->data[ch];
		1393	}
		1394	for (blk = 0; blk < s->num_blocks; blk++) {
		1395	if (!err && decode_audio_block(s, blk)) {
		1396	av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
		1397	err = 1;
		1398	}
		1399	if (err)
		1400	for (ch = 0; ch < s->out_channels; ch++)
		1401	memcpy(((float)frame->data[ch]) + AC3_BLOCK_SIZEblk, output[ch], sizeof(*output) AC3_BLOCK_SIZE);
		1402	for (ch = 0; ch < s->out_channels; ch++)
		1403	output[ch] = s->outptr[channel_map[ch]];
		1404	for (ch = 0; ch < s->out_channels; ch++) {
		1405	if (!ch \|\| channel_map[ch])
		1406	s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
		1407	}
		1408	}
		1409
		1410	av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
		1411
		1412	/* keep last block for error concealment in next frame */
		1413	for (ch = 0; ch < s->out_channels; ch++)
		1414	memcpy(s->output[ch], output[ch], sizeof(*output) AC3_BLOCK_SIZE);
		1415
		1416	*got_frame_ptr = 1;
		1417
		1418	return FFMIN(buf_size, s->frame_size);
		1419	}
		1420
		1421	/**
		1422	* Uninitialize the AC-3 decoder.
		1423	*/
		1424	static av_cold int ac3_decode_end(AVCodecContext *avctx)
		1425	{
		1426	AC3DecodeContext *s = avctx->priv_data;
		1427	ff_mdct_end(&s->imdct_512);
		1428	ff_mdct_end(&s->imdct_256);
		1429
		1430	return 0;
		1431	}
		1432
		1433	#define OFFSET(x) offsetof(AC3DecodeContext, x)
		1434	#define PAR (AV_OPT_FLAG_DECODING_PARAM \| AV_OPT_FLAG_AUDIO_PARAM)
		1435	static const AVOption options[] = {
		1436	{ "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
		1437
		1438	{"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
		1439	{"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
		1440	{"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
		1441	{"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
		1442	{"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
		1443
		1444	{ NULL},
		1445	};
		1446
		1447	static const AVClass ac3_decoder_class = {
		1448	.class_name = "AC3 decoder",
		1449	.item_name = av_default_item_name,
		1450	.option = options,
		1451	.version = LIBAVUTIL_VERSION_INT,
		1452	};
		1453
		1454	AVCodec ff_ac3_decoder = {
		1455	.name = "ac3",
		1456	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
		1457	.type = AVMEDIA_TYPE_AUDIO,
		1458	.id = AV_CODEC_ID_AC3,
		1459	.priv_data_size = sizeof (AC3DecodeContext),
		1460	.init = ac3_decode_init,
		1461	.close = ac3_decode_end,
		1462	.decode = ac3_decode_frame,
		1463	.capabilities = CODEC_CAP_DR1,
		1464	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
		1465	AV_SAMPLE_FMT_NONE },
		1466	.priv_class = &ac3_decoder_class,
		1467	};
		1468
		1469	#if CONFIG_EAC3_DECODER
		1470	static const AVClass eac3_decoder_class = {
		1471	.class_name = "E-AC3 decoder",
		1472	.item_name = av_default_item_name,
		1473	.option = options,
		1474	.version = LIBAVUTIL_VERSION_INT,
		1475	};
		1476
		1477	AVCodec ff_eac3_decoder = {
		1478	.name = "eac3",
		1479	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
		1480	.type = AVMEDIA_TYPE_AUDIO,
		1481	.id = AV_CODEC_ID_EAC3,
		1482	.priv_data_size = sizeof (AC3DecodeContext),
		1483	.init = ac3_decode_init,
		1484	.close = ac3_decode_end,
		1485	.decode = ac3_decode_frame,
		1486	.capabilities = CODEC_CAP_DR1,
		1487	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
		1488	AV_SAMPLE_FMT_NONE },
		1489	.priv_class = &eac3_decoder_class,
		1490	};
		1491	#endif

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/ffmpeg-2.1/libavcodec/ac3dec.c – Rev 6148