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

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* DCA compatible decoder
		3	* Copyright (C) 2004 Gildas Bazin
		4	* Copyright (C) 2004 Benjamin Zores
		5	* Copyright (C) 2006 Benjamin Larsson
		6	* Copyright (C) 2007 Konstantin Shishkov
		7	*
		8	* This file is part of FFmpeg.
		9	*
		10	* FFmpeg is free software; you can redistribute it and/or
		11	* modify it under the terms of the GNU Lesser General Public
		12	* License as published by the Free Software Foundation; either
		13	* version 2.1 of the License, or (at your option) any later version.
		14	*
		15	* FFmpeg is distributed in the hope that it will be useful,
		16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		18	* Lesser General Public License for more details.
		19	*
		20	* You should have received a copy of the GNU Lesser General Public
		21	* License along with FFmpeg; if not, write to the Free Software
		22	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		23	*/
		24
		25	#include
		26	#include
		27	#include
		28
		29	#include "libavutil/channel_layout.h"
		30	#include "libavutil/common.h"
		31	#include "libavutil/float_dsp.h"
		32	#include "libavutil/internal.h"
		33	#include "libavutil/intreadwrite.h"
		34	#include "libavutil/mathematics.h"
		35	#include "libavutil/samplefmt.h"
		36	#include "avcodec.h"
		37	#include "fft.h"
		38	#include "get_bits.h"
		39	#include "dcadata.h"
		40	#include "dcahuff.h"
		41	#include "dca.h"
		42	#include "mathops.h"
		43	#include "synth_filter.h"
		44	#include "dcadsp.h"
		45	#include "fmtconvert.h"
		46	#include "internal.h"
		47
		48	#if ARCH_ARM
		49	# include "arm/dca.h"
		50	#endif
		51
		52	//#define TRACE
		53
		54	#define DCA_PRIM_CHANNELS_MAX (7)
		55	#define DCA_SUBBANDS (64)
		56	#define DCA_ABITS_MAX (32) /* Should be 28 */
		57	#define DCA_SUBSUBFRAMES_MAX (4)
		58	#define DCA_SUBFRAMES_MAX (16)
		59	#define DCA_BLOCKS_MAX (16)
		60	#define DCA_LFE_MAX (3)
		61	#define DCA_CHSETS_MAX (4)
		62	#define DCA_CHSET_CHANS_MAX (8)
		63
		64	enum DCAMode {
		65	DCA_MONO = 0,
		66	DCA_CHANNEL,
		67	DCA_STEREO,
		68	DCA_STEREO_SUMDIFF,
		69	DCA_STEREO_TOTAL,
		70	DCA_3F,
		71	DCA_2F1R,
		72	DCA_3F1R,
		73	DCA_2F2R,
		74	DCA_3F2R,
		75	DCA_4F2R
		76	};
		77
		78	/* these are unconfirmed but should be mostly correct */
		79	enum DCAExSSSpeakerMask {
		80	DCA_EXSS_FRONT_CENTER = 0x0001,
		81	DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
		82	DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
		83	DCA_EXSS_LFE = 0x0008,
		84	DCA_EXSS_REAR_CENTER = 0x0010,
		85	DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
		86	DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
		87	DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
		88	DCA_EXSS_OVERHEAD = 0x0100,
		89	DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
		90	DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
		91	DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
		92	DCA_EXSS_LFE2 = 0x1000,
		93	DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
		94	DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
		95	DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
		96	};
		97
		98	enum DCAXxchSpeakerMask {
		99	DCA_XXCH_FRONT_CENTER = 0x0000001,
		100	DCA_XXCH_FRONT_LEFT = 0x0000002,
		101	DCA_XXCH_FRONT_RIGHT = 0x0000004,
		102	DCA_XXCH_SIDE_REAR_LEFT = 0x0000008,
		103	DCA_XXCH_SIDE_REAR_RIGHT = 0x0000010,
		104	DCA_XXCH_LFE1 = 0x0000020,
		105	DCA_XXCH_REAR_CENTER = 0x0000040,
		106	DCA_XXCH_SURROUND_REAR_LEFT = 0x0000080,
		107	DCA_XXCH_SURROUND_REAR_RIGHT = 0x0000100,
		108	DCA_XXCH_SIDE_SURROUND_LEFT = 0x0000200,
		109	DCA_XXCH_SIDE_SURROUND_RIGHT = 0x0000400,
		110	DCA_XXCH_FRONT_CENTER_LEFT = 0x0000800,
		111	DCA_XXCH_FRONT_CENTER_RIGHT = 0x0001000,
		112	DCA_XXCH_FRONT_HIGH_LEFT = 0x0002000,
		113	DCA_XXCH_FRONT_HIGH_CENTER = 0x0004000,
		114	DCA_XXCH_FRONT_HIGH_RIGHT = 0x0008000,
		115	DCA_XXCH_LFE2 = 0x0010000,
		116	DCA_XXCH_SIDE_FRONT_LEFT = 0x0020000,
		117	DCA_XXCH_SIDE_FRONT_RIGHT = 0x0040000,
		118	DCA_XXCH_OVERHEAD = 0x0080000,
		119	DCA_XXCH_SIDE_HIGH_LEFT = 0x0100000,
		120	DCA_XXCH_SIDE_HIGH_RIGHT = 0x0200000,
		121	DCA_XXCH_REAR_HIGH_CENTER = 0x0400000,
		122	DCA_XXCH_REAR_HIGH_LEFT = 0x0800000,
		123	DCA_XXCH_REAR_HIGH_RIGHT = 0x1000000,
		124	DCA_XXCH_REAR_LOW_CENTER = 0x2000000,
		125	DCA_XXCH_REAR_LOW_LEFT = 0x4000000,
		126	DCA_XXCH_REAR_LOW_RIGHT = 0x8000000,
		127	};
		128
		129	static const uint32_t map_xxch_to_native[28] = {
		130	AV_CH_FRONT_CENTER,
		131	AV_CH_FRONT_LEFT,
		132	AV_CH_FRONT_RIGHT,
		133	AV_CH_SIDE_LEFT,
		134	AV_CH_SIDE_RIGHT,
		135	AV_CH_LOW_FREQUENCY,
		136	AV_CH_BACK_CENTER,
		137	AV_CH_BACK_LEFT,
		138	AV_CH_BACK_RIGHT,
		139	AV_CH_SIDE_LEFT, /* side surround left -- dup sur side L */
		140	AV_CH_SIDE_RIGHT, /* side surround right -- dup sur side R */
		141	AV_CH_FRONT_LEFT_OF_CENTER,
		142	AV_CH_FRONT_RIGHT_OF_CENTER,
		143	AV_CH_TOP_FRONT_LEFT,
		144	AV_CH_TOP_FRONT_CENTER,
		145	AV_CH_TOP_FRONT_RIGHT,
		146	AV_CH_LOW_FREQUENCY, /* lfe2 -- duplicate lfe1 position */
		147	AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */
		148	AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */
		149	AV_CH_TOP_CENTER, /* overhead */
		150	AV_CH_TOP_FRONT_LEFT, /* side high left -- dup */
		151	AV_CH_TOP_FRONT_RIGHT, /* side high right -- dup */
		152	AV_CH_TOP_BACK_CENTER,
		153	AV_CH_TOP_BACK_LEFT,
		154	AV_CH_TOP_BACK_RIGHT,
		155	AV_CH_BACK_CENTER, /* rear low center -- dup */
		156	AV_CH_BACK_LEFT, /* rear low left -- dup */
		157	AV_CH_BACK_RIGHT /* read low right -- dup */
		158	};
		159
		160	enum DCAExtensionMask {
		161	DCA_EXT_CORE = 0x001, ///< core in core substream
		162	DCA_EXT_XXCH = 0x002, ///< XXCh channels extension in core substream
		163	DCA_EXT_X96 = 0x004, ///< 96/24 extension in core substream
		164	DCA_EXT_XCH = 0x008, ///< XCh channel extension in core substream
		165	DCA_EXT_EXSS_CORE = 0x010, ///< core in ExSS (extension substream)
		166	DCA_EXT_EXSS_XBR = 0x020, ///< extended bitrate extension in ExSS
		167	DCA_EXT_EXSS_XXCH = 0x040, ///< XXCh channels extension in ExSS
		168	DCA_EXT_EXSS_X96 = 0x080, ///< 96/24 extension in ExSS
		169	DCA_EXT_EXSS_LBR = 0x100, ///< low bitrate component in ExSS
		170	DCA_EXT_EXSS_XLL = 0x200, ///< lossless extension in ExSS
		171	};
		172
		173	/* -1 are reserved or unknown */
		174	static const int dca_ext_audio_descr_mask[] = {
		175	DCA_EXT_XCH,
		176	-1,
		177	DCA_EXT_X96,
		178	DCA_EXT_XCH \| DCA_EXT_X96,
		179	-1,
		180	-1,
		181	DCA_EXT_XXCH,
		182	-1,
		183	};
		184
		185	/* extensions that reside in core substream */
		186	#define DCA_CORE_EXTS (DCA_EXT_XCH \| DCA_EXT_XXCH \| DCA_EXT_X96)
		187
		188	/* Tables for mapping dts channel configurations to libavcodec multichannel api.
		189	* Some compromises have been made for special configurations. Most configurations
		190	* are never used so complete accuracy is not needed.
		191	*
		192	* L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
		193	* S -> side, when both rear and back are configured move one of them to the side channel
		194	* OV -> center back
		195	* All 2 channel configurations -> AV_CH_LAYOUT_STEREO
		196	*/
		197	static const uint64_t dca_core_channel_layout[] = {
		198	AV_CH_FRONT_CENTER, ///< 1, A
		199	AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
		200	AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
		201	AV_CH_LAYOUT_STEREO, ///< 2, (L + R) + (L - R) (sum-difference)
		202	AV_CH_LAYOUT_STEREO, ///< 2, LT + RT (left and right total)
		203	AV_CH_LAYOUT_STEREO \| AV_CH_FRONT_CENTER, ///< 3, C + L + R
		204	AV_CH_LAYOUT_STEREO \| AV_CH_BACK_CENTER, ///< 3, L + R + S
		205	AV_CH_LAYOUT_STEREO \| AV_CH_FRONT_CENTER \| AV_CH_BACK_CENTER, ///< 4, C + L + R + S
		206	AV_CH_LAYOUT_STEREO \| AV_CH_SIDE_LEFT \| AV_CH_SIDE_RIGHT, ///< 4, L + R + SL + SR
		207
		208	AV_CH_LAYOUT_STEREO \| AV_CH_FRONT_CENTER \| AV_CH_SIDE_LEFT \|
		209	AV_CH_SIDE_RIGHT, ///< 5, C + L + R + SL + SR
		210
		211	AV_CH_LAYOUT_STEREO \| AV_CH_SIDE_LEFT \| AV_CH_SIDE_RIGHT \|
		212	AV_CH_FRONT_LEFT_OF_CENTER \| AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
		213
		214	AV_CH_LAYOUT_STEREO \| AV_CH_BACK_LEFT \| AV_CH_BACK_RIGHT \|
		215	AV_CH_FRONT_CENTER \| AV_CH_BACK_CENTER, ///< 6, C + L + R + LR + RR + OV
		216
		217	AV_CH_FRONT_CENTER \| AV_CH_FRONT_RIGHT_OF_CENTER \|
		218	AV_CH_FRONT_LEFT_OF_CENTER \| AV_CH_BACK_CENTER \|
		219	AV_CH_BACK_LEFT \| AV_CH_BACK_RIGHT, ///< 6, CF + CR + LF + RF + LR + RR
		220
		221	AV_CH_FRONT_LEFT_OF_CENTER \| AV_CH_FRONT_CENTER \|
		222	AV_CH_FRONT_RIGHT_OF_CENTER \| AV_CH_LAYOUT_STEREO \|
		223	AV_CH_SIDE_LEFT \| AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
		224
		225	AV_CH_FRONT_LEFT_OF_CENTER \| AV_CH_FRONT_RIGHT_OF_CENTER \|
		226	AV_CH_LAYOUT_STEREO \| AV_CH_SIDE_LEFT \| AV_CH_SIDE_RIGHT \|
		227	AV_CH_BACK_LEFT \| AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
		228
		229	AV_CH_FRONT_LEFT_OF_CENTER \| AV_CH_FRONT_CENTER \|
		230	AV_CH_FRONT_RIGHT_OF_CENTER \| AV_CH_LAYOUT_STEREO \|
		231	AV_CH_SIDE_LEFT \| AV_CH_BACK_CENTER \| AV_CH_SIDE_RIGHT, ///< 8, CL + C + CR + L + R + SL + S + SR
		232	};
		233
		234	static const int8_t dca_lfe_index[] = {
		235	1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
		236	};
		237
		238	static const int8_t dca_channel_reorder_lfe[][9] = {
		239	{ 0, -1, -1, -1, -1, -1, -1, -1, -1},
		240	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		241	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		242	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		243	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		244	{ 2, 0, 1, -1, -1, -1, -1, -1, -1},
		245	{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
		246	{ 2, 0, 1, 4, -1, -1, -1, -1, -1},
		247	{ 0, 1, 3, 4, -1, -1, -1, -1, -1},
		248	{ 2, 0, 1, 4, 5, -1, -1, -1, -1},
		249	{ 3, 4, 0, 1, 5, 6, -1, -1, -1},
		250	{ 2, 0, 1, 4, 5, 6, -1, -1, -1},
		251	{ 0, 6, 4, 5, 2, 3, -1, -1, -1},
		252	{ 4, 2, 5, 0, 1, 6, 7, -1, -1},
		253	{ 5, 6, 0, 1, 7, 3, 8, 4, -1},
		254	{ 4, 2, 5, 0, 1, 6, 8, 7, -1},
		255	};
		256
		257	static const int8_t dca_channel_reorder_lfe_xch[][9] = {
		258	{ 0, 2, -1, -1, -1, -1, -1, -1, -1},
		259	{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
		260	{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
		261	{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
		262	{ 0, 1, 3, -1, -1, -1, -1, -1, -1},
		263	{ 2, 0, 1, 4, -1, -1, -1, -1, -1},
		264	{ 0, 1, 3, 4, -1, -1, -1, -1, -1},
		265	{ 2, 0, 1, 4, 5, -1, -1, -1, -1},
		266	{ 0, 1, 4, 5, 3, -1, -1, -1, -1},
		267	{ 2, 0, 1, 5, 6, 4, -1, -1, -1},
		268	{ 3, 4, 0, 1, 6, 7, 5, -1, -1},
		269	{ 2, 0, 1, 4, 5, 6, 7, -1, -1},
		270	{ 0, 6, 4, 5, 2, 3, 7, -1, -1},
		271	{ 4, 2, 5, 0, 1, 7, 8, 6, -1},
		272	{ 5, 6, 0, 1, 8, 3, 9, 4, 7},
		273	{ 4, 2, 5, 0, 1, 6, 9, 8, 7},
		274	};
		275
		276	static const int8_t dca_channel_reorder_nolfe[][9] = {
		277	{ 0, -1, -1, -1, -1, -1, -1, -1, -1},
		278	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		279	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		280	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		281	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		282	{ 2, 0, 1, -1, -1, -1, -1, -1, -1},
		283	{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
		284	{ 2, 0, 1, 3, -1, -1, -1, -1, -1},
		285	{ 0, 1, 2, 3, -1, -1, -1, -1, -1},
		286	{ 2, 0, 1, 3, 4, -1, -1, -1, -1},
		287	{ 2, 3, 0, 1, 4, 5, -1, -1, -1},
		288	{ 2, 0, 1, 3, 4, 5, -1, -1, -1},
		289	{ 0, 5, 3, 4, 1, 2, -1, -1, -1},
		290	{ 3, 2, 4, 0, 1, 5, 6, -1, -1},
		291	{ 4, 5, 0, 1, 6, 2, 7, 3, -1},
		292	{ 3, 2, 4, 0, 1, 5, 7, 6, -1},
		293	};
		294
		295	static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
		296	{ 0, 1, -1, -1, -1, -1, -1, -1, -1},
		297	{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
		298	{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
		299	{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
		300	{ 0, 1, 2, -1, -1, -1, -1, -1, -1},
		301	{ 2, 0, 1, 3, -1, -1, -1, -1, -1},
		302	{ 0, 1, 2, 3, -1, -1, -1, -1, -1},
		303	{ 2, 0, 1, 3, 4, -1, -1, -1, -1},
		304	{ 0, 1, 3, 4, 2, -1, -1, -1, -1},
		305	{ 2, 0, 1, 4, 5, 3, -1, -1, -1},
		306	{ 2, 3, 0, 1, 5, 6, 4, -1, -1},
		307	{ 2, 0, 1, 3, 4, 5, 6, -1, -1},
		308	{ 0, 5, 3, 4, 1, 2, 6, -1, -1},
		309	{ 3, 2, 4, 0, 1, 6, 7, 5, -1},
		310	{ 4, 5, 0, 1, 7, 2, 8, 3, 6},
		311	{ 3, 2, 4, 0, 1, 5, 8, 7, 6},
		312	};
		313
		314	#define DCA_DOLBY 101 /* FIXME */
		315
		316	#define DCA_CHANNEL_BITS 6
		317	#define DCA_CHANNEL_MASK 0x3F
		318
		319	#define DCA_LFE 0x80
		320
		321	#define HEADER_SIZE 14
		322
		323	#define DCA_MAX_FRAME_SIZE 16384
		324	#define DCA_MAX_EXSS_HEADER_SIZE 4096
		325
		326	#define DCA_BUFFER_PADDING_SIZE 1024
		327
		328	/** Bit allocation */
		329	typedef struct {
		330	int offset; ///< code values offset
		331	int maxbits[8]; ///< max bits in VLC
		332	int wrap; ///< wrap for get_vlc2()
		333	VLC vlc[8]; ///< actual codes
		334	} BitAlloc;
		335
		336	static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
		337	static BitAlloc dca_tmode; ///< transition mode VLCs
		338	static BitAlloc dca_scalefactor; ///< scalefactor VLCs
		339	static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
		340
		341	static av_always_inline int get_bitalloc(GetBitContext gb, BitAlloc ba,
		342	int idx)
		343	{
		344	return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
		345	ba->offset;
		346	}
		347
		348	typedef struct {
		349	AVCodecContext *avctx;
		350	/* Frame header */
		351	int frame_type; ///< type of the current frame
		352	int samples_deficit; ///< deficit sample count
		353	int crc_present; ///< crc is present in the bitstream
		354	int sample_blocks; ///< number of PCM sample blocks
		355	int frame_size; ///< primary frame byte size
		356	int amode; ///< audio channels arrangement
		357	int sample_rate; ///< audio sampling rate
		358	int bit_rate; ///< transmission bit rate
		359	int bit_rate_index; ///< transmission bit rate index
		360
		361	int downmix; ///< embedded downmix enabled
		362	int dynrange; ///< embedded dynamic range flag
		363	int timestamp; ///< embedded time stamp flag
		364	int aux_data; ///< auxiliary data flag
		365	int hdcd; ///< source material is mastered in HDCD
		366	int ext_descr; ///< extension audio descriptor flag
		367	int ext_coding; ///< extended coding flag
		368	int aspf; ///< audio sync word insertion flag
		369	int lfe; ///< low frequency effects flag
		370	int predictor_history; ///< predictor history flag
		371	int header_crc; ///< header crc check bytes
		372	int multirate_inter; ///< multirate interpolator switch
		373	int version; ///< encoder software revision
		374	int copy_history; ///< copy history
		375	int source_pcm_res; ///< source pcm resolution
		376	int front_sum; ///< front sum/difference flag
		377	int surround_sum; ///< surround sum/difference flag
		378	int dialog_norm; ///< dialog normalisation parameter
		379
		380	/* Primary audio coding header */
		381	int subframes; ///< number of subframes
		382	int total_channels; ///< number of channels including extensions
		383	int prim_channels; ///< number of primary audio channels
		384	int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
		385	int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
		386	int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
		387	int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
		388	int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
		389	int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
		390	int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
		391	float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
		392
		393	/* Primary audio coding side information */
		394	int subsubframes[DCA_SUBFRAMES_MAX]; ///< number of subsubframes
		395	int partial_samples[DCA_SUBFRAMES_MAX]; ///< partial subsubframe samples count
		396	int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
		397	int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
		398	int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
		399	int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
		400	int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
		401	int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
		402	int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
		403	int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
		404	int dynrange_coef; ///< dynamic range coefficient
		405
		406	int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
		407
		408	float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)]; ///< Low frequency effect data
		409	int lfe_scale_factor;
		410
		411	/* Subband samples history (for ADPCM) */
		412	DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
		413	DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
		414	DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
		415	int hist_index[DCA_PRIM_CHANNELS_MAX];
		416	DECLARE_ALIGNED(32, float, raXin)[32];
		417
		418	int output; ///< type of output
		419
		420	DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
		421	float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
		422	float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
		423	uint8_t *extra_channels_buffer;
		424	unsigned int extra_channels_buffer_size;
		425
		426	uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
		427	int dca_buffer_size; ///< how much data is in the dca_buffer
		428
		429	const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
		430	GetBitContext gb;
		431	/* Current position in DCA frame */
		432	int current_subframe;
		433	int current_subsubframe;
		434
		435	int core_ext_mask; ///< present extensions in the core substream
		436
		437	/* XCh extension information */
		438	int xch_present; ///< XCh extension present and valid
		439	int xch_base_channel; ///< index of first (only) channel containing XCH data
		440
		441	/* XXCH extension information */
		442	int xxch_chset;
		443	int xxch_nbits_spk_mask;
		444	uint32_t xxch_core_spkmask;
		445	uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
		446	int xxch_chset_nch[4];
		447	float xxch_dmix_sf[DCA_CHSETS_MAX];
		448
		449	uint32_t xxch_dmix_embedded; /* lower layer has mix pre-embedded, per chset */
		450	float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
		451
		452	int8_t xxch_order_tab[32];
		453	int8_t lfe_index;
		454
		455	/* ExSS header parser */
		456	int static_fields; ///< static fields present
		457	int mix_metadata; ///< mixing metadata present
		458	int num_mix_configs; ///< number of mix out configurations
		459	int mix_config_num_ch[4]; ///< number of channels in each mix out configuration
		460
		461	int profile;
		462
		463	int debug_flag; ///< used for suppressing repeated error messages output
		464	AVFloatDSPContext fdsp;
		465	FFTContext imdct;
		466	SynthFilterContext synth;
		467	DCADSPContext dcadsp;
		468	FmtConvertContext fmt_conv;
		469	} DCAContext;
		470
		471	static const uint16_t dca_vlc_offs[] = {
		472	0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
		473	5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
		474	5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
		475	7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
		476	12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
		477	18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
		478	};
		479
		480	static av_cold void dca_init_vlcs(void)
		481	{
		482	static int vlcs_initialized = 0;
		483	int i, j, c = 14;
		484	static VLC_TYPE dca_table[23622][2];
		485
		486	if (vlcs_initialized)
		487	return;
		488
		489	dca_bitalloc_index.offset = 1;
		490	dca_bitalloc_index.wrap = 2;
		491	for (i = 0; i < 5; i++) {
		492	dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
		493	dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
		494	init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
		495	bitalloc_12_bits[i], 1, 1,
		496	bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
		497	}
		498	dca_scalefactor.offset = -64;
		499	dca_scalefactor.wrap = 2;
		500	for (i = 0; i < 5; i++) {
		501	dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
		502	dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
		503	init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
		504	scales_bits[i], 1, 1,
		505	scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
		506	}
		507	dca_tmode.offset = 0;
		508	dca_tmode.wrap = 1;
		509	for (i = 0; i < 4; i++) {
		510	dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
		511	dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
		512	init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
		513	tmode_bits[i], 1, 1,
		514	tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
		515	}
		516
		517	for (i = 0; i < 10; i++)
		518	for (j = 0; j < 7; j++) {
		519	if (!bitalloc_codes[i][j])
		520	break;
		521	dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
		522	dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
		523	dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
		524	dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
		525
		526	init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
		527	bitalloc_sizes[i],
		528	bitalloc_bits[i][j], 1, 1,
		529	bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
		530	c++;
		531	}
		532	vlcs_initialized = 1;
		533	}
		534
		535	static inline void get_array(GetBitContext gb, int dst, int len, int bits)
		536	{
		537	while (len--)
		538	*dst++ = get_bits(gb, bits);
		539	}
		540
		541	static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
		542	{
		543	int i, base, mask;
		544
		545	/* locate channel set containing the channel */
		546	for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
		547	i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
		548	base += av_popcount(mask);
		549
		550	return base + av_popcount(mask & (xxch_ch - 1));
		551	}
		552
		553	static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
		554	int xxch)
		555	{
		556	int i, j;
		557	static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
		558	static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
		559	static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
		560	int hdr_pos = 0, hdr_size = 0;
		561	float sign, mag, scale_factor;
		562	int this_chans, acc_mask;
		563	int embedded_downmix;
		564	int nchans, mask[8];
		565	int coeff, ichan;
		566
		567	/* xxch has arbitrary sized audio coding headers */
		568	if (xxch) {
		569	hdr_pos = get_bits_count(&s->gb);
		570	hdr_size = get_bits(&s->gb, 7) + 1;
		571	}
		572
		573	nchans = get_bits(&s->gb, 3) + 1;
		574	s->total_channels = nchans + base_channel;
		575	s->prim_channels = s->total_channels;
		576
		577	/* obtain speaker layout mask & downmix coefficients for XXCH */
		578	if (xxch) {
		579	acc_mask = s->xxch_core_spkmask;
		580
		581	this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
		582	s->xxch_spk_masks[s->xxch_chset] = this_chans;
		583	s->xxch_chset_nch[s->xxch_chset] = nchans;
		584
		585	for (i = 0; i <= s->xxch_chset; i++)
		586	acc_mask \|= s->xxch_spk_masks[i];
		587
		588	/* check for downmixing information */
		589	if (get_bits1(&s->gb)) {
		590	embedded_downmix = get_bits1(&s->gb);
		591	scale_factor =
		592	1.0f / dca_downmix_scale_factors[(get_bits(&s->gb, 6) - 1) << 2];
		593
		594	s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
		595
		596	for (i = base_channel; i < s->prim_channels; i++) {
		597	mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
		598	}
		599
		600	for (j = base_channel; j < s->prim_channels; j++) {
		601	memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
		602	s->xxch_dmix_embedded \|= (embedded_downmix << j);
		603	for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
		604	if (mask[j] & (1 << i)) {
		605	if ((1 << i) == DCA_XXCH_LFE1) {
		606	av_log(s->avctx, AV_LOG_WARNING,
		607	"DCA-XXCH: dmix to LFE1 not supported.\n");
		608	continue;
		609	}
		610
		611	coeff = get_bits(&s->gb, 7);
		612	sign = (coeff & 64) ? 1.0 : -1.0;
		613	mag = dca_downmix_scale_factors[((coeff & 63) - 1) << 2];
		614	ichan = dca_xxch2index(s, 1 << i);
		615	s->xxch_dmix_coeff[j][ichan] = sign * mag;
		616	}
		617	}
		618	}
		619	}
		620	}
		621
		622	if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
		623	s->prim_channels = DCA_PRIM_CHANNELS_MAX;
		624
		625
		626	for (i = base_channel; i < s->prim_channels; i++) {
		627	s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
		628	if (s->subband_activity[i] > DCA_SUBBANDS)
		629	s->subband_activity[i] = DCA_SUBBANDS;
		630	}
		631	for (i = base_channel; i < s->prim_channels; i++) {
		632	s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
		633	if (s->vq_start_subband[i] > DCA_SUBBANDS)
		634	s->vq_start_subband[i] = DCA_SUBBANDS;
		635	}
		636	get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
		637	get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
		638	get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
		639	get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
		640
		641	/* Get codebooks quantization indexes */
		642	if (!base_channel)
		643	memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
		644	for (j = 1; j < 11; j++)
		645	for (i = base_channel; i < s->prim_channels; i++)
		646	s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
		647
		648	/* Get scale factor adjustment */
		649	for (j = 0; j < 11; j++)
		650	for (i = base_channel; i < s->prim_channels; i++)
		651	s->scalefactor_adj[i][j] = 1;
		652
		653	for (j = 1; j < 11; j++)
		654	for (i = base_channel; i < s->prim_channels; i++)
		655	if (s->quant_index_huffman[i][j] < thr[j])
		656	s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
		657
		658	if (!xxch) {
		659	if (s->crc_present) {
		660	/* Audio header CRC check */
		661	get_bits(&s->gb, 16);
		662	}
		663	} else {
		664	/* Skip to the end of the header, also ignore CRC if present */
		665	i = get_bits_count(&s->gb);
		666	if (hdr_pos + 8 * hdr_size > i)
		667	skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
		668	}
		669
		670	s->current_subframe = 0;
		671	s->current_subsubframe = 0;
		672
		673	#ifdef TRACE
		674	av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
		675	av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
		676	for (i = base_channel; i < s->prim_channels; i++) {
		677	av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
		678	s->subband_activity[i]);
		679	av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
		680	s->vq_start_subband[i]);
		681	av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
		682	s->joint_intensity[i]);
		683	av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
		684	s->transient_huffman[i]);
		685	av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
		686	s->scalefactor_huffman[i]);
		687	av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
		688	s->bitalloc_huffman[i]);
		689	av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
		690	for (j = 0; j < 11; j++)
		691	av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
		692	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		693	av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
		694	for (j = 0; j < 11; j++)
		695	av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
		696	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		697	}
		698	#endif
		699
		700	return 0;
		701	}
		702
		703	static int dca_parse_frame_header(DCAContext *s)
		704	{
		705	init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
		706
		707	/* Sync code */
		708	skip_bits_long(&s->gb, 32);
		709
		710	/* Frame header */
		711	s->frame_type = get_bits(&s->gb, 1);
		712	s->samples_deficit = get_bits(&s->gb, 5) + 1;
		713	s->crc_present = get_bits(&s->gb, 1);
		714	s->sample_blocks = get_bits(&s->gb, 7) + 1;
		715	s->frame_size = get_bits(&s->gb, 14) + 1;
		716	if (s->frame_size < 95)
		717	return AVERROR_INVALIDDATA;
		718	s->amode = get_bits(&s->gb, 6);
		719	s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
		720	if (!s->sample_rate)
		721	return AVERROR_INVALIDDATA;
		722	s->bit_rate_index = get_bits(&s->gb, 5);
		723	s->bit_rate = dca_bit_rates[s->bit_rate_index];
		724	if (!s->bit_rate)
		725	return AVERROR_INVALIDDATA;
		726
		727	s->downmix = get_bits(&s->gb, 1); /* note: this is FixedBit == 0 */
		728	s->dynrange = get_bits(&s->gb, 1);
		729	s->timestamp = get_bits(&s->gb, 1);
		730	s->aux_data = get_bits(&s->gb, 1);
		731	s->hdcd = get_bits(&s->gb, 1);
		732	s->ext_descr = get_bits(&s->gb, 3);
		733	s->ext_coding = get_bits(&s->gb, 1);
		734	s->aspf = get_bits(&s->gb, 1);
		735	s->lfe = get_bits(&s->gb, 2);
		736	s->predictor_history = get_bits(&s->gb, 1);
		737
		738	if (s->lfe > 2) {
		739	s->lfe = 0;
		740	av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
		741	return AVERROR_INVALIDDATA;
		742	}
		743
		744	/* TODO: check CRC */
		745	if (s->crc_present)
		746	s->header_crc = get_bits(&s->gb, 16);
		747
		748	s->multirate_inter = get_bits(&s->gb, 1);
		749	s->version = get_bits(&s->gb, 4);
		750	s->copy_history = get_bits(&s->gb, 2);
		751	s->source_pcm_res = get_bits(&s->gb, 3);
		752	s->front_sum = get_bits(&s->gb, 1);
		753	s->surround_sum = get_bits(&s->gb, 1);
		754	s->dialog_norm = get_bits(&s->gb, 4);
		755
		756	/* FIXME: channels mixing levels */
		757	s->output = s->amode;
		758	if (s->lfe)
		759	s->output \|= DCA_LFE;
		760
		761	#ifdef TRACE
		762	av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
		763	av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
		764	av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
		765	av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
		766	s->sample_blocks, s->sample_blocks * 32);
		767	av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
		768	av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
		769	s->amode, dca_channels[s->amode]);
		770	av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
		771	s->sample_rate);
		772	av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
		773	s->bit_rate);
		774	av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
		775	av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
		776	av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
		777	av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
		778	av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
		779	av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
		780	av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
		781	av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
		782	av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
		783	av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
		784	s->predictor_history);
		785	av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
		786	av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
		787	s->multirate_inter);
		788	av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
		789	av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
		790	av_log(s->avctx, AV_LOG_DEBUG,
		791	"source pcm resolution: %i (%i bits/sample)\n",
		792	s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
		793	av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
		794	av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
		795	av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
		796	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		797	#endif
		798
		799	/* Primary audio coding header */
		800	s->subframes = get_bits(&s->gb, 4) + 1;
		801
		802	return dca_parse_audio_coding_header(s, 0, 0);
		803	}
		804
		805
		806	static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
		807	{
		808	if (level < 5) {
		809	/* huffman encoded */
		810	value += get_bitalloc(gb, &dca_scalefactor, level);
		811	value = av_clip(value, 0, (1 << log2range) - 1);
		812	} else if (level < 8) {
		813	if (level + 1 > log2range) {
		814	skip_bits(gb, level + 1 - log2range);
		815	value = get_bits(gb, log2range);
		816	} else {
		817	value = get_bits(gb, level + 1);
		818	}
		819	}
		820	return value;
		821	}
		822
		823	static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
		824	{
		825	/* Primary audio coding side information */
		826	int j, k;
		827
		828	if (get_bits_left(&s->gb) < 0)
		829	return AVERROR_INVALIDDATA;
		830
		831	if (!base_channel) {
		832	s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
		833	s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
		834	}
		835
		836	for (j = base_channel; j < s->prim_channels; j++) {
		837	for (k = 0; k < s->subband_activity[j]; k++)
		838	s->prediction_mode[j][k] = get_bits(&s->gb, 1);
		839	}
		840
		841	/* Get prediction codebook */
		842	for (j = base_channel; j < s->prim_channels; j++) {
		843	for (k = 0; k < s->subband_activity[j]; k++) {
		844	if (s->prediction_mode[j][k] > 0) {
		845	/* (Prediction coefficient VQ address) */
		846	s->prediction_vq[j][k] = get_bits(&s->gb, 12);
		847	}
		848	}
		849	}
		850
		851	/* Bit allocation index */
		852	for (j = base_channel; j < s->prim_channels; j++) {
		853	for (k = 0; k < s->vq_start_subband[j]; k++) {
		854	if (s->bitalloc_huffman[j] == 6)
		855	s->bitalloc[j][k] = get_bits(&s->gb, 5);
		856	else if (s->bitalloc_huffman[j] == 5)
		857	s->bitalloc[j][k] = get_bits(&s->gb, 4);
		858	else if (s->bitalloc_huffman[j] == 7) {
		859	av_log(s->avctx, AV_LOG_ERROR,
		860	"Invalid bit allocation index\n");
		861	return AVERROR_INVALIDDATA;
		862	} else {
		863	s->bitalloc[j][k] =
		864	get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
		865	}
		866
		867	if (s->bitalloc[j][k] > 26) {
		868	av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
		869	j, k, s->bitalloc[j][k]);
		870	return AVERROR_INVALIDDATA;
		871	}
		872	}
		873	}
		874
		875	/* Transition mode */
		876	for (j = base_channel; j < s->prim_channels; j++) {
		877	for (k = 0; k < s->subband_activity[j]; k++) {
		878	s->transition_mode[j][k] = 0;
		879	if (s->subsubframes[s->current_subframe] > 1 &&
		880	k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
		881	s->transition_mode[j][k] =
		882	get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
		883	}
		884	}
		885	}
		886
		887	if (get_bits_left(&s->gb) < 0)
		888	return AVERROR_INVALIDDATA;
		889
		890	for (j = base_channel; j < s->prim_channels; j++) {
		891	const uint32_t *scale_table;
		892	int scale_sum, log_size;
		893
		894	memset(s->scale_factor[j], 0,
		895	s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
		896
		897	if (s->scalefactor_huffman[j] == 6) {
		898	scale_table = scale_factor_quant7;
		899	log_size = 7;
		900	} else {
		901	scale_table = scale_factor_quant6;
		902	log_size = 6;
		903	}
		904
		905	/* When huffman coded, only the difference is encoded */
		906	scale_sum = 0;
		907
		908	for (k = 0; k < s->subband_activity[j]; k++) {
		909	if (k >= s->vq_start_subband[j] \|\| s->bitalloc[j][k] > 0) {
		910	scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
		911	s->scale_factor[j][k][0] = scale_table[scale_sum];
		912	}
		913
		914	if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
		915	/* Get second scale factor */
		916	scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
		917	s->scale_factor[j][k][1] = scale_table[scale_sum];
		918	}
		919	}
		920	}
		921
		922	/* Joint subband scale factor codebook select */
		923	for (j = base_channel; j < s->prim_channels; j++) {
		924	/* Transmitted only if joint subband coding enabled */
		925	if (s->joint_intensity[j] > 0)
		926	s->joint_huff[j] = get_bits(&s->gb, 3);
		927	}
		928
		929	if (get_bits_left(&s->gb) < 0)
		930	return AVERROR_INVALIDDATA;
		931
		932	/* Scale factors for joint subband coding */
		933	for (j = base_channel; j < s->prim_channels; j++) {
		934	int source_channel;
		935
		936	/* Transmitted only if joint subband coding enabled */
		937	if (s->joint_intensity[j] > 0) {
		938	int scale = 0;
		939	source_channel = s->joint_intensity[j] - 1;
		940
		941	/* When huffman coded, only the difference is encoded
		942	* (is this valid as well for joint scales ???) */
		943
		944	for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
		945	scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
		946	s->joint_scale_factor[j][k] = scale; /joint_scale_table[scale]; /
		947	}
		948
		949	if (!(s->debug_flag & 0x02)) {
		950	av_log(s->avctx, AV_LOG_DEBUG,
		951	"Joint stereo coding not supported\n");
		952	s->debug_flag \|= 0x02;
		953	}
		954	}
		955	}
		956
		957	/* Stereo downmix coefficients */
		958	if (!base_channel && s->prim_channels > 2) {
		959	if (s->downmix) {
		960	for (j = base_channel; j < s->prim_channels; j++) {
		961	s->downmix_coef[j][0] = get_bits(&s->gb, 7);
		962	s->downmix_coef[j][1] = get_bits(&s->gb, 7);
		963	}
		964	} else {
		965	int am = s->amode & DCA_CHANNEL_MASK;
		966	if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
		967	av_log(s->avctx, AV_LOG_ERROR,
		968	"Invalid channel mode %d\n", am);
		969	return AVERROR_INVALIDDATA;
		970	}
		971	if (s->prim_channels > FF_ARRAY_ELEMS(dca_default_coeffs[0])) {
		972	avpriv_request_sample(s->avctx, "Downmixing %d channels",
		973	s->prim_channels);
		974	return AVERROR_PATCHWELCOME;
		975	}
		976
		977	for (j = base_channel; j < s->prim_channels; j++) {
		978	s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
		979	s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
		980	}
		981	}
		982	}
		983
		984	/* Dynamic range coefficient */
		985	if (!base_channel && s->dynrange)
		986	s->dynrange_coef = get_bits(&s->gb, 8);
		987
		988	/* Side information CRC check word */
		989	if (s->crc_present) {
		990	get_bits(&s->gb, 16);
		991	}
		992
		993	/*
		994	* Primary audio data arrays
		995	*/
		996
		997	/* VQ encoded high frequency subbands */
		998	for (j = base_channel; j < s->prim_channels; j++)
		999	for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
		1000	/* 1 vector -> 32 samples */
		1001	s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
		1002
		1003	/* Low frequency effect data */
		1004	if (!base_channel && s->lfe) {
		1005	int quant7;
		1006	/* LFE samples */
		1007	int lfe_samples = 2 * s->lfe * (4 + block_index);
		1008	int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
		1009	float lfe_scale;
		1010
		1011	for (j = lfe_samples; j < lfe_end_sample; j++) {
		1012	/* Signed 8 bits int */
		1013	s->lfe_data[j] = get_sbits(&s->gb, 8);
		1014	}
		1015
		1016	/* Scale factor index */
		1017	quant7 = get_bits(&s->gb, 8);
		1018	if (quant7 > 127) {
		1019	avpriv_request_sample(s->avctx, "LFEScaleIndex larger than 127");
		1020	return AVERROR_INVALIDDATA;
		1021	}
		1022	s->lfe_scale_factor = scale_factor_quant7[quant7];
		1023
		1024	/* Quantization step size * scale factor */
		1025	lfe_scale = 0.035 * s->lfe_scale_factor;
		1026
		1027	for (j = lfe_samples; j < lfe_end_sample; j++)
		1028	s->lfe_data[j] *= lfe_scale;
		1029	}
		1030
		1031	#ifdef TRACE
		1032	av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
		1033	s->subsubframes[s->current_subframe]);
		1034	av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
		1035	s->partial_samples[s->current_subframe]);
		1036
		1037	for (j = base_channel; j < s->prim_channels; j++) {
		1038	av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
		1039	for (k = 0; k < s->subband_activity[j]; k++)
		1040	av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
		1041	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		1042	}
		1043	for (j = base_channel; j < s->prim_channels; j++) {
		1044	for (k = 0; k < s->subband_activity[j]; k++)
		1045	av_log(s->avctx, AV_LOG_DEBUG,
		1046	"prediction coefs: %f, %f, %f, %f\n",
		1047	(float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
		1048	(float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
		1049	(float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
		1050	(float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
		1051	}
		1052	for (j = base_channel; j < s->prim_channels; j++) {
		1053	av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
		1054	for (k = 0; k < s->vq_start_subband[j]; k++)
		1055	av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
		1056	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		1057	}
		1058	for (j = base_channel; j < s->prim_channels; j++) {
		1059	av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
		1060	for (k = 0; k < s->subband_activity[j]; k++)
		1061	av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
		1062	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		1063	}
		1064	for (j = base_channel; j < s->prim_channels; j++) {
		1065	av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
		1066	for (k = 0; k < s->subband_activity[j]; k++) {
		1067	if (k >= s->vq_start_subband[j] \|\| s->bitalloc[j][k] > 0)
		1068	av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
		1069	if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
		1070	av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
		1071	}
		1072	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		1073	}
		1074	for (j = base_channel; j < s->prim_channels; j++) {
		1075	if (s->joint_intensity[j] > 0) {
		1076	int source_channel = s->joint_intensity[j] - 1;
		1077	av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
		1078	for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
		1079	av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
		1080	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		1081	}
		1082	}
		1083	if (!base_channel && s->prim_channels > 2 && s->downmix) {
		1084	av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
		1085	for (j = 0; j < s->prim_channels; j++) {
		1086	av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
		1087	dca_downmix_coeffs[s->downmix_coef[j][0]]);
		1088	av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
		1089	dca_downmix_coeffs[s->downmix_coef[j][1]]);
		1090	}
		1091	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		1092	}
		1093	for (j = base_channel; j < s->prim_channels; j++)
		1094	for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
		1095	av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
		1096	if (!base_channel && s->lfe) {
		1097	int lfe_samples = 2 * s->lfe * (4 + block_index);
		1098	int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
		1099
		1100	av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
		1101	for (j = lfe_samples; j < lfe_end_sample; j++)
		1102	av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
		1103	av_log(s->avctx, AV_LOG_DEBUG, "\n");
		1104	}
		1105	#endif
		1106
		1107	return 0;
		1108	}
		1109
		1110	static void qmf_32_subbands(DCAContext *s, int chans,
		1111	float samples_in[32][8], float *samples_out,
		1112	float scale)
		1113	{
		1114	const float *prCoeff;
		1115
		1116	int sb_act = s->subband_activity[chans];
		1117
		1118	scale *= sqrt(1 / 8.0);
		1119
		1120	/* Select filter */
		1121	if (!s->multirate_inter) /* Non-perfect reconstruction */
		1122	prCoeff = fir_32bands_nonperfect;
		1123	else /* Perfect reconstruction */
		1124	prCoeff = fir_32bands_perfect;
		1125
		1126	s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
		1127	s->subband_fir_hist[chans],
		1128	&s->hist_index[chans],
		1129	s->subband_fir_noidea[chans], prCoeff,
		1130	samples_out, s->raXin, scale);
		1131	}
		1132
		1133	static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
		1134	int num_deci_sample, float *samples_in,
		1135	float *samples_out, float scale)
		1136	{
		1137	/* samples_in: An array holding decimated samples.
		1138	* Samples in current subframe starts from samples_in[0],
		1139	* while samples_in[-1], samples_in[-2], ..., stores samples
		1140	* from last subframe as history.
		1141	*
		1142	* samples_out: An array holding interpolated samples
		1143	*/
		1144
		1145	int decifactor;
		1146	const float *prCoeff;
		1147	int deciindex;
		1148
		1149	/* Select decimation filter */
		1150	if (decimation_select == 1) {
		1151	decifactor = 64;
		1152	prCoeff = lfe_fir_128;
		1153	} else {
		1154	decifactor = 32;
		1155	prCoeff = lfe_fir_64;
		1156	}
		1157	/* Interpolation */
		1158	for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
		1159	s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
		1160	samples_in++;
		1161	samples_out += 2 * decifactor;
		1162	}
		1163	}
		1164
		1165	/* downmixing routines */
		1166	#define MIX_REAR1(samples, s1, rs, coef) \
		1167	samples[0][i] += samples[s1][i] * coef[rs][0]; \
		1168	samples[1][i] += samples[s1][i] * coef[rs][1];
		1169
		1170	#define MIX_REAR2(samples, s1, s2, rs, coef) \
		1171	samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
		1172	samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
		1173
		1174	#define MIX_FRONT3(samples, coef) \
		1175	t = samples[c][i]; \
		1176	u = samples[l][i]; \
		1177	v = samples[r][i]; \
		1178	samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
		1179	samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
		1180
		1181	#define DOWNMIX_TO_STEREO(op1, op2) \
		1182	for (i = 0; i < 256; i++) { \
		1183	op1 \
		1184	op2 \
		1185	}
		1186
		1187	static void dca_downmix(float **samples, int srcfmt,
		1188	int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
		1189	const int8_t *channel_mapping)
		1190	{
		1191	int c, l, r, sl, sr, s;
		1192	int i;
		1193	float t, u, v;
		1194	float coef[DCA_PRIM_CHANNELS_MAX][2];
		1195
		1196	for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
		1197	coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
		1198	coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
		1199	}
		1200
		1201	switch (srcfmt) {
		1202	case DCA_MONO:
		1203	case DCA_CHANNEL:
		1204	case DCA_STEREO_TOTAL:
		1205	case DCA_STEREO_SUMDIFF:
		1206	case DCA_4F2R:
		1207	av_log(NULL, AV_LOG_ERROR, "Not implemented!\n");
		1208	break;
		1209	case DCA_STEREO:
		1210	break;
		1211	case DCA_3F:
		1212	c = channel_mapping[0];
		1213	l = channel_mapping[1];
		1214	r = channel_mapping[2];
		1215	DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
		1216	break;
		1217	case DCA_2F1R:
		1218	s = channel_mapping[2];
		1219	DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
		1220	break;
		1221	case DCA_3F1R:
		1222	c = channel_mapping[0];
		1223	l = channel_mapping[1];
		1224	r = channel_mapping[2];
		1225	s = channel_mapping[3];
		1226	DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
		1227	MIX_REAR1(samples, s, 3, coef));
		1228	break;
		1229	case DCA_2F2R:
		1230	sl = channel_mapping[2];
		1231	sr = channel_mapping[3];
		1232	DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
		1233	break;
		1234	case DCA_3F2R:
		1235	c = channel_mapping[0];
		1236	l = channel_mapping[1];
		1237	r = channel_mapping[2];
		1238	sl = channel_mapping[3];
		1239	sr = channel_mapping[4];
		1240	DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
		1241	MIX_REAR2(samples, sl, sr, 3, coef));
		1242	break;
		1243	}
		1244	}
		1245
		1246
		1247	#ifndef decode_blockcodes
		1248	/* Very compact version of the block code decoder that does not use table
		1249	* look-up but is slightly slower */
		1250	static int decode_blockcode(int code, int levels, int32_t *values)
		1251	{
		1252	int i;
		1253	int offset = (levels - 1) >> 1;
		1254
		1255	for (i = 0; i < 4; i++) {
		1256	int div = FASTDIV(code, levels);
		1257	values[i] = code - offset - div * levels;
		1258	code = div;
		1259	}
		1260
		1261	return code;
		1262	}
		1263
		1264	static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
		1265	{
		1266	return decode_blockcode(code1, levels, values) \|
		1267	decode_blockcode(code2, levels, values + 4);
		1268	}
		1269	#endif
		1270
		1271	static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
		1272	static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
		1273
		1274	#ifndef int8x8_fmul_int32
		1275	static inline void int8x8_fmul_int32(float dst, const int8_t src, int scale)
		1276	{
		1277	float fscale = scale / 16.0;
		1278	int i;
		1279	for (i = 0; i < 8; i++)
		1280	dst[i] = src[i] * fscale;
		1281	}
		1282	#endif
		1283
		1284	static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
		1285	{
		1286	int k, l;
		1287	int subsubframe = s->current_subsubframe;
		1288
		1289	const float *quant_step_table;
		1290
		1291	/* FIXME */
		1292	float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
		1293	LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);
		1294
		1295	/*
		1296	* Audio data
		1297	*/
		1298
		1299	/* Select quantization step size table */
		1300	if (s->bit_rate_index == 0x1f)
		1301	quant_step_table = lossless_quant_d;
		1302	else
		1303	quant_step_table = lossy_quant_d;
		1304
		1305	for (k = base_channel; k < s->prim_channels; k++) {
		1306	float rscale[DCA_SUBBANDS];
		1307
		1308	if (get_bits_left(&s->gb) < 0)
		1309	return AVERROR_INVALIDDATA;
		1310
		1311	for (l = 0; l < s->vq_start_subband[k]; l++) {
		1312	int m;
		1313
		1314	/* Select the mid-tread linear quantizer */
		1315	int abits = s->bitalloc[k][l];
		1316
		1317	float quant_step_size = quant_step_table[abits];
		1318
		1319	/*
		1320	* Determine quantization index code book and its type
		1321	*/
		1322
		1323	/* Select quantization index code book */
		1324	int sel = s->quant_index_huffman[k][abits];
		1325
		1326	/*
		1327	* Extract bits from the bit stream
		1328	*/
		1329	if (!abits) {
		1330	rscale[l] = 0;
		1331	memset(block + 8 * l, 0, 8 * sizeof(block[0]));
		1332	} else {
		1333	/* Deal with transients */
		1334	int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
		1335	rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *
		1336	s->scalefactor_adj[k][sel];
		1337
		1338	if (abits >= 11 \|\| !dca_smpl_bitalloc[abits].vlc[sel].table) {
		1339	if (abits <= 7) {
		1340	/* Block code */
		1341	int block_code1, block_code2, size, levels, err;
		1342
		1343	size = abits_sizes[abits - 1];
		1344	levels = abits_levels[abits - 1];
		1345
		1346	block_code1 = get_bits(&s->gb, size);
		1347	block_code2 = get_bits(&s->gb, size);
		1348	err = decode_blockcodes(block_code1, block_code2,
		1349	levels, block + 8 * l);
		1350	if (err) {
		1351	av_log(s->avctx, AV_LOG_ERROR,
		1352	"ERROR: block code look-up failed\n");
		1353	return AVERROR_INVALIDDATA;
		1354	}
		1355	} else {
		1356	/* no coding */
		1357	for (m = 0; m < 8; m++)
		1358	block[8 * l + m] = get_sbits(&s->gb, abits - 3);
		1359	}
		1360	} else {
		1361	/* Huffman coded */
		1362	for (m = 0; m < 8; m++)
		1363	block[8 * l + m] = get_bitalloc(&s->gb,
		1364	&dca_smpl_bitalloc[abits], sel);
		1365	}
		1366
		1367	}
		1368	}
		1369
		1370	s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],
		1371	block, rscale, 8 * s->vq_start_subband[k]);
		1372
		1373	for (l = 0; l < s->vq_start_subband[k]; l++) {
		1374	int m;
		1375	/*
		1376	* Inverse ADPCM if in prediction mode
		1377	*/
		1378	if (s->prediction_mode[k][l]) {
		1379	int n;
		1380	for (m = 0; m < 8; m++) {
		1381	for (n = 1; n <= 4; n++)
		1382	if (m >= n)
		1383	subband_samples[k][l][m] +=
		1384	(adpcm_vb[s->prediction_vq[k][l]][n - 1] *
		1385	subband_samples[k][l][m - n] / 8192);
		1386	else if (s->predictor_history)
		1387	subband_samples[k][l][m] +=
		1388	(adpcm_vb[s->prediction_vq[k][l]][n - 1] *
		1389	s->subband_samples_hist[k][l][m - n + 4] / 8192);
		1390	}
		1391	}
		1392	}
		1393
		1394	/*
		1395	* Decode VQ encoded high frequencies
		1396	*/
		1397	for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
		1398	/* 1 vector -> 32 samples but we only need the 8 samples
		1399	* for this subsubframe. */
		1400	int hfvq = s->high_freq_vq[k][l];
		1401
		1402	if (!s->debug_flag & 0x01) {
		1403	av_log(s->avctx, AV_LOG_DEBUG,
		1404	"Stream with high frequencies VQ coding\n");
		1405	s->debug_flag \|= 0x01;
		1406	}
		1407
		1408	int8x8_fmul_int32(subband_samples[k][l],
		1409	&high_freq_vq[hfvq][subsubframe * 8],
		1410	s->scale_factor[k][l][0]);
		1411	}
		1412	}
		1413
		1414	/* Check for DSYNC after subsubframe */
		1415	if (s->aspf \|\| subsubframe == s->subsubframes[s->current_subframe] - 1) {
		1416	if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
		1417	#ifdef TRACE
		1418	av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
		1419	#endif
		1420	} else {
		1421	av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
		1422	return AVERROR_INVALIDDATA;
		1423	}
		1424	}
		1425
		1426	/* Backup predictor history for adpcm */
		1427	for (k = base_channel; k < s->prim_channels; k++)
		1428	for (l = 0; l < s->vq_start_subband[k]; l++)
		1429	memcpy(s->subband_samples_hist[k][l],
		1430	&subband_samples[k][l][4],
		1431	4 * sizeof(subband_samples[0][0][0]));
		1432
		1433	return 0;
		1434	}
		1435
		1436	static int dca_filter_channels(DCAContext *s, int block_index)
		1437	{
		1438	float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
		1439	int k;
		1440
		1441	/* 32 subbands QMF */
		1442	for (k = 0; k < s->prim_channels; k++) {
		1443	/* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
		1444	0, 8388608.0, 8388608.0 };*/
		1445	if (s->channel_order_tab[k] >= 0)
		1446	qmf_32_subbands(s, k, subband_samples[k],
		1447	s->samples_chanptr[s->channel_order_tab[k]],
		1448	M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
		1449	}
		1450
		1451	/* Down mixing */
		1452	if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
		1453	dca_downmix(s->samples_chanptr, s->amode, s->downmix_coef, s->channel_order_tab);
		1454	}
		1455
		1456	/* Generate LFE samples for this subsubframe FIXME!!! */
		1457	if (s->output & DCA_LFE) {
		1458	lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
		1459	s->lfe_data + 2 * s->lfe * (block_index + 4),
		1460	s->samples_chanptr[s->lfe_index],
		1461	1.0 / (256.0 * 32768.0));
		1462	/* Outputs 20bits pcm samples */
		1463	}
		1464
		1465	return 0;
		1466	}
		1467
		1468
		1469	static int dca_subframe_footer(DCAContext *s, int base_channel)
		1470	{
		1471	int aux_data_count = 0, i;
		1472
		1473	/*
		1474	* Unpack optional information
		1475	*/
		1476
		1477	/* presumably optional information only appears in the core? */
		1478	if (!base_channel) {
		1479	if (s->timestamp)
		1480	skip_bits_long(&s->gb, 32);
		1481
		1482	if (s->aux_data)
		1483	aux_data_count = get_bits(&s->gb, 6);
		1484
		1485	for (i = 0; i < aux_data_count; i++)
		1486	get_bits(&s->gb, 8);
		1487
		1488	if (s->crc_present && (s->downmix \|\| s->dynrange))
		1489	get_bits(&s->gb, 16);
		1490	}
		1491
		1492	return 0;
		1493	}
		1494
		1495	/**
		1496	* Decode a dca frame block
		1497	*
		1498	* @param s pointer to the DCAContext
		1499	*/
		1500
		1501	static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
		1502	{
		1503	int ret;
		1504
		1505	/* Sanity check */
		1506	if (s->current_subframe >= s->subframes) {
		1507	av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
		1508	s->current_subframe, s->subframes);
		1509	return AVERROR_INVALIDDATA;
		1510	}
		1511
		1512	if (!s->current_subsubframe) {
		1513	#ifdef TRACE
		1514	av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
		1515	#endif
		1516	/* Read subframe header */
		1517	if ((ret = dca_subframe_header(s, base_channel, block_index)))
		1518	return ret;
		1519	}
		1520
		1521	/* Read subsubframe */
		1522	#ifdef TRACE
		1523	av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
		1524	#endif
		1525	if ((ret = dca_subsubframe(s, base_channel, block_index)))
		1526	return ret;
		1527
		1528	/* Update state */
		1529	s->current_subsubframe++;
		1530	if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
		1531	s->current_subsubframe = 0;
		1532	s->current_subframe++;
		1533	}
		1534	if (s->current_subframe >= s->subframes) {
		1535	#ifdef TRACE
		1536	av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
		1537	#endif
		1538	/* Read subframe footer */
		1539	if ((ret = dca_subframe_footer(s, base_channel)))
		1540	return ret;
		1541	}
		1542
		1543	return 0;
		1544	}
		1545
		1546	/**
		1547	* Return the number of channels in an ExSS speaker mask (HD)
		1548	*/
		1549	static int dca_exss_mask2count(int mask)
		1550	{
		1551	/* count bits that mean speaker pairs twice */
		1552	return av_popcount(mask) +
		1553	av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT \|
		1554	DCA_EXSS_FRONT_LEFT_RIGHT \|
		1555	DCA_EXSS_FRONT_HIGH_LEFT_RIGHT \|
		1556	DCA_EXSS_WIDE_LEFT_RIGHT \|
		1557	DCA_EXSS_SIDE_LEFT_RIGHT \|
		1558	DCA_EXSS_SIDE_HIGH_LEFT_RIGHT \|
		1559	DCA_EXSS_SIDE_REAR_LEFT_RIGHT \|
		1560	DCA_EXSS_REAR_LEFT_RIGHT \|
		1561	DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
		1562	}
		1563
		1564	/**
		1565	* Skip mixing coefficients of a single mix out configuration (HD)
		1566	*/
		1567	static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
		1568	{
		1569	int i;
		1570
		1571	for (i = 0; i < channels; i++) {
		1572	int mix_map_mask = get_bits(gb, out_ch);
		1573	int num_coeffs = av_popcount(mix_map_mask);
		1574	skip_bits_long(gb, num_coeffs * 6);
		1575	}
		1576	}
		1577
		1578	/**
		1579	* Parse extension substream asset header (HD)
		1580	*/
		1581	static int dca_exss_parse_asset_header(DCAContext *s)
		1582	{
		1583	int header_pos = get_bits_count(&s->gb);
		1584	int header_size;
		1585	int channels = 0;
		1586	int embedded_stereo = 0;
		1587	int embedded_6ch = 0;
		1588	int drc_code_present;
		1589	int av_uninit(extensions_mask);
		1590	int i, j;
		1591
		1592	if (get_bits_left(&s->gb) < 16)
		1593	return -1;
		1594
		1595	/* We will parse just enough to get to the extensions bitmask with which
		1596	* we can set the profile value. */
		1597
		1598	header_size = get_bits(&s->gb, 9) + 1;
		1599	skip_bits(&s->gb, 3); // asset index
		1600
		1601	if (s->static_fields) {
		1602	if (get_bits1(&s->gb))
		1603	skip_bits(&s->gb, 4); // asset type descriptor
		1604	if (get_bits1(&s->gb))
		1605	skip_bits_long(&s->gb, 24); // language descriptor
		1606
		1607	if (get_bits1(&s->gb)) {
		1608	/* How can one fit 1024 bytes of text here if the maximum value
		1609	* for the asset header size field above was 512 bytes? */
		1610	int text_length = get_bits(&s->gb, 10) + 1;
		1611	if (get_bits_left(&s->gb) < text_length * 8)
		1612	return -1;
		1613	skip_bits_long(&s->gb, text_length * 8); // info text
		1614	}
		1615
		1616	skip_bits(&s->gb, 5); // bit resolution - 1
		1617	skip_bits(&s->gb, 4); // max sample rate code
		1618	channels = get_bits(&s->gb, 8) + 1;
		1619
		1620	if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
		1621	int spkr_remap_sets;
		1622	int spkr_mask_size = 16;
		1623	int num_spkrs[7];
		1624
		1625	if (channels > 2)
		1626	embedded_stereo = get_bits1(&s->gb);
		1627	if (channels > 6)
		1628	embedded_6ch = get_bits1(&s->gb);
		1629
		1630	if (get_bits1(&s->gb)) {
		1631	spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
		1632	skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
		1633	}
		1634
		1635	spkr_remap_sets = get_bits(&s->gb, 3);
		1636
		1637	for (i = 0; i < spkr_remap_sets; i++) {
		1638	/* std layout mask for each remap set */
		1639	num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
		1640	}
		1641
		1642	for (i = 0; i < spkr_remap_sets; i++) {
		1643	int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
		1644	if (get_bits_left(&s->gb) < 0)
		1645	return -1;
		1646
		1647	for (j = 0; j < num_spkrs[i]; j++) {
		1648	int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
		1649	int num_dec_ch = av_popcount(remap_dec_ch_mask);
		1650	skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
		1651	}
		1652	}
		1653
		1654	} else {
		1655	skip_bits(&s->gb, 3); // representation type
		1656	}
		1657	}
		1658
		1659	drc_code_present = get_bits1(&s->gb);
		1660	if (drc_code_present)
		1661	get_bits(&s->gb, 8); // drc code
		1662
		1663	if (get_bits1(&s->gb))
		1664	skip_bits(&s->gb, 5); // dialog normalization code
		1665
		1666	if (drc_code_present && embedded_stereo)
		1667	get_bits(&s->gb, 8); // drc stereo code
		1668
		1669	if (s->mix_metadata && get_bits1(&s->gb)) {
		1670	skip_bits(&s->gb, 1); // external mix
		1671	skip_bits(&s->gb, 6); // post mix gain code
		1672
		1673	if (get_bits(&s->gb, 2) != 3) // mixer drc code
		1674	skip_bits(&s->gb, 3); // drc limit
		1675	else
		1676	skip_bits(&s->gb, 8); // custom drc code
		1677
		1678	if (get_bits1(&s->gb)) // channel specific scaling
		1679	for (i = 0; i < s->num_mix_configs; i++)
		1680	skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
		1681	else
		1682	skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
		1683
		1684	for (i = 0; i < s->num_mix_configs; i++) {
		1685	if (get_bits_left(&s->gb) < 0)
		1686	return -1;
		1687	dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
		1688	if (embedded_6ch)
		1689	dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
		1690	if (embedded_stereo)
		1691	dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
		1692	}
		1693	}
		1694
		1695	switch (get_bits(&s->gb, 2)) {
		1696	case 0: extensions_mask = get_bits(&s->gb, 12); break;
		1697	case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
		1698	case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
		1699	case 3: extensions_mask = 0; /* aux coding */ break;
		1700	}
		1701
		1702	/* not parsed further, we were only interested in the extensions mask */
		1703
		1704	if (get_bits_left(&s->gb) < 0)
		1705	return -1;
		1706
		1707	if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
		1708	av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
		1709	return -1;
		1710	}
		1711	skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
		1712
		1713	if (extensions_mask & DCA_EXT_EXSS_XLL)
		1714	s->profile = FF_PROFILE_DTS_HD_MA;
		1715	else if (extensions_mask & (DCA_EXT_EXSS_XBR \| DCA_EXT_EXSS_X96 \|
		1716	DCA_EXT_EXSS_XXCH))
		1717	s->profile = FF_PROFILE_DTS_HD_HRA;
		1718
		1719	if (!(extensions_mask & DCA_EXT_CORE))
		1720	av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
		1721	if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
		1722	av_log(s->avctx, AV_LOG_WARNING,
		1723	"DTS extensions detection mismatch (%d, %d)\n",
		1724	extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
		1725
		1726	return 0;
		1727	}
		1728
		1729	static int dca_xbr_parse_frame(DCAContext *s)
		1730	{
		1731	int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
		1732	int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
		1733	int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
		1734	int anctemp[DCA_CHSET_CHANS_MAX];
		1735	int chset_fsize[DCA_CHSETS_MAX];
		1736	int n_xbr_ch[DCA_CHSETS_MAX];
		1737	int hdr_size, num_chsets, xbr_tmode, hdr_pos;
		1738	int i, j, k, l, chset, chan_base;
		1739
		1740	av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
		1741
		1742	/* get bit position of sync header */
		1743	hdr_pos = get_bits_count(&s->gb) - 32;
		1744
		1745	hdr_size = get_bits(&s->gb, 6) + 1;
		1746	num_chsets = get_bits(&s->gb, 2) + 1;
		1747
		1748	for(i = 0; i < num_chsets; i++)
		1749	chset_fsize[i] = get_bits(&s->gb, 14) + 1;
		1750
		1751	xbr_tmode = get_bits1(&s->gb);
		1752
		1753	for(i = 0; i < num_chsets; i++) {
		1754	n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
		1755	k = get_bits(&s->gb, 2) + 5;
		1756	for(j = 0; j < n_xbr_ch[i]; j++)
		1757	active_bands[i][j] = get_bits(&s->gb, k) + 1;
		1758	}
		1759
		1760	/* skip to the end of the header */
		1761	i = get_bits_count(&s->gb);
		1762	if(hdr_pos + hdr_size * 8 > i)
		1763	skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
		1764
		1765	/* loop over the channel data sets */
		1766	/* only decode as many channels as we've decoded base data for */
		1767	for(chset = 0, chan_base = 0;
		1768	chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
		1769	chan_base += n_xbr_ch[chset++]) {
		1770	int start_posn = get_bits_count(&s->gb);
		1771	int subsubframe = 0;
		1772	int subframe = 0;
		1773
		1774	/* loop over subframes */
		1775	for (k = 0; k < (s->sample_blocks / 8); k++) {
		1776	/* parse header if we're on first subsubframe of a block */
		1777	if(subsubframe == 0) {
		1778	/* Parse subframe header */
		1779	for(i = 0; i < n_xbr_ch[chset]; i++) {
		1780	anctemp[i] = get_bits(&s->gb, 2) + 2;
		1781	}
		1782
		1783	for(i = 0; i < n_xbr_ch[chset]; i++) {
		1784	get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
		1785	}
		1786
		1787	for(i = 0; i < n_xbr_ch[chset]; i++) {
		1788	anctemp[i] = get_bits(&s->gb, 3);
		1789	if(anctemp[i] < 1) {
		1790	av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
		1791	return AVERROR_INVALIDDATA;
		1792	}
		1793	}
		1794
		1795	/* generate scale factors */
		1796	for(i = 0; i < n_xbr_ch[chset]; i++) {
		1797	const uint32_t *scale_table;
		1798	int nbits;
		1799
		1800	if (s->scalefactor_huffman[chan_base+i] == 6) {
		1801	scale_table = scale_factor_quant7;
		1802	} else {
		1803	scale_table = scale_factor_quant6;
		1804	}
		1805
		1806	nbits = anctemp[i];
		1807
		1808	for(j = 0; j < active_bands[chset][i]; j++) {
		1809	if(abits_high[i][j] > 0) {
		1810	scale_table_high[i][j][0] =
		1811	scale_table[get_bits(&s->gb, nbits)];
		1812
		1813	if(xbr_tmode && s->transition_mode[i][j]) {
		1814	scale_table_high[i][j][1] =
		1815	scale_table[get_bits(&s->gb, nbits)];
		1816	}
		1817	}
		1818	}
		1819	}
		1820	}
		1821
		1822	/* decode audio array for this block */
		1823	for(i = 0; i < n_xbr_ch[chset]; i++) {
		1824	for(j = 0; j < active_bands[chset][i]; j++) {
		1825	const int xbr_abits = abits_high[i][j];
		1826	const float quant_step_size = lossless_quant_d[xbr_abits];
		1827	const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
		1828	const float rscale = quant_step_size * scale_table_high[i][j][sfi];
		1829	float *subband_samples = s->subband_samples[k][chan_base+i][j];
		1830	int block[8];
		1831
		1832	if(xbr_abits <= 0)
		1833	continue;
		1834
		1835	if(xbr_abits > 7) {
		1836	get_array(&s->gb, block, 8, xbr_abits - 3);
		1837	} else {
		1838	int block_code1, block_code2, size, levels, err;
		1839
		1840	size = abits_sizes[xbr_abits - 1];
		1841	levels = abits_levels[xbr_abits - 1];
		1842
		1843	block_code1 = get_bits(&s->gb, size);
		1844	block_code2 = get_bits(&s->gb, size);
		1845	err = decode_blockcodes(block_code1, block_code2,
		1846	levels, block);
		1847	if (err) {
		1848	av_log(s->avctx, AV_LOG_ERROR,
		1849	"ERROR: DTS-XBR: block code look-up failed\n");
		1850	return AVERROR_INVALIDDATA;
		1851	}
		1852	}
		1853
		1854	/* scale & sum into subband */
		1855	for(l = 0; l < 8; l++)
		1856	subband_samples[l] += (float)block[l] * rscale;
		1857	}
		1858	}
		1859
		1860	/* check DSYNC marker */
		1861	if(s->aspf \|\| subsubframe == s->subsubframes[subframe] - 1) {
		1862	if(get_bits(&s->gb, 16) != 0xffff) {
		1863	av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
		1864	return AVERROR_INVALIDDATA;
		1865	}
		1866	}
		1867
		1868	/* advance sub-sub-frame index */
		1869	if(++subsubframe >= s->subsubframes[subframe]) {
		1870	subsubframe = 0;
		1871	subframe++;
		1872	}
		1873	}
		1874
		1875	/* skip to next channel set */
		1876	i = get_bits_count(&s->gb);
		1877	if(start_posn + chset_fsize[chset] * 8 != i) {
		1878	j = start_posn + chset_fsize[chset] * 8 - i;
		1879	if(j < 0 \|\| j >= 8)
		1880	av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
		1881	" skipping further than expected (%d bits)\n", j);
		1882	skip_bits_long(&s->gb, j);
		1883	}
		1884	}
		1885
		1886	return 0;
		1887	}
		1888
		1889	/* parse initial header for XXCH and dump details */
		1890	static int dca_xxch_decode_frame(DCAContext *s)
		1891	{
		1892	int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
		1893	int i, chset, base_channel, chstart, fsize[8];
		1894
		1895	/* assume header word has already been parsed */
		1896	hdr_pos = get_bits_count(&s->gb) - 32;
		1897	hdr_size = get_bits(&s->gb, 6) + 1;
		1898	/chhdr_crc =/ skip_bits1(&s->gb);
		1899	spkmsk_bits = get_bits(&s->gb, 5) + 1;
		1900	num_chsets = get_bits(&s->gb, 2) + 1;
		1901
		1902	for (i = 0; i < num_chsets; i++)
		1903	fsize[i] = get_bits(&s->gb, 14) + 1;
		1904
		1905	core_spk = get_bits(&s->gb, spkmsk_bits);
		1906	s->xxch_core_spkmask = core_spk;
		1907	s->xxch_nbits_spk_mask = spkmsk_bits;
		1908	s->xxch_dmix_embedded = 0;
		1909
		1910	/* skip to the end of the header */
		1911	i = get_bits_count(&s->gb);
		1912	if (hdr_pos + hdr_size * 8 > i)
		1913	skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
		1914
		1915	for (chset = 0; chset < num_chsets; chset++) {
		1916	chstart = get_bits_count(&s->gb);
		1917	base_channel = s->prim_channels;
		1918	s->xxch_chset = chset;
		1919
		1920	/* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
		1921	5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
		1922	dca_parse_audio_coding_header(s, base_channel, 1);
		1923
		1924	/* decode channel data */
		1925	for (i = 0; i < (s->sample_blocks / 8); i++) {
		1926	if (dca_decode_block(s, base_channel, i)) {
		1927	av_log(s->avctx, AV_LOG_ERROR,
		1928	"Error decoding DTS-XXCH extension\n");
		1929	continue;
		1930	}
		1931	}
		1932
		1933	/* skip to end of this section */
		1934	i = get_bits_count(&s->gb);
		1935	if (chstart + fsize[chset] * 8 > i)
		1936	skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
		1937	}
		1938	s->xxch_chset = num_chsets;
		1939
		1940	return 0;
		1941	}
		1942
		1943	/**
		1944	* Parse extension substream header (HD)
		1945	*/
		1946	static void dca_exss_parse_header(DCAContext *s)
		1947	{
		1948	int asset_size[8];
		1949	int ss_index;
		1950	int blownup;
		1951	int num_audiop = 1;
		1952	int num_assets = 1;
		1953	int active_ss_mask[8];
		1954	int i, j;
		1955	int start_posn;
		1956	int hdrsize;
		1957	uint32_t mkr;
		1958
		1959	if (get_bits_left(&s->gb) < 52)
		1960	return;
		1961
		1962	start_posn = get_bits_count(&s->gb) - 32;
		1963
		1964	skip_bits(&s->gb, 8); // user data
		1965	ss_index = get_bits(&s->gb, 2);
		1966
		1967	blownup = get_bits1(&s->gb);
		1968	hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
		1969	skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
		1970
		1971	s->static_fields = get_bits1(&s->gb);
		1972	if (s->static_fields) {
		1973	skip_bits(&s->gb, 2); // reference clock code
		1974	skip_bits(&s->gb, 3); // frame duration code
		1975
		1976	if (get_bits1(&s->gb))
		1977	skip_bits_long(&s->gb, 36); // timestamp
		1978
		1979	/* a single stream can contain multiple audio assets that can be
		1980	* combined to form multiple audio presentations */
		1981
		1982	num_audiop = get_bits(&s->gb, 3) + 1;
		1983	if (num_audiop > 1) {
		1984	avpriv_request_sample(s->avctx,
		1985	"Multiple DTS-HD audio presentations");
		1986	/* ignore such streams for now */
		1987	return;
		1988	}
		1989
		1990	num_assets = get_bits(&s->gb, 3) + 1;
		1991	if (num_assets > 1) {
		1992	avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
		1993	/* ignore such streams for now */
		1994	return;
		1995	}
		1996
		1997	for (i = 0; i < num_audiop; i++)
		1998	active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
		1999
		2000	for (i = 0; i < num_audiop; i++)
		2001	for (j = 0; j <= ss_index; j++)
		2002	if (active_ss_mask[i] & (1 << j))
		2003	skip_bits(&s->gb, 8); // active asset mask
		2004
		2005	s->mix_metadata = get_bits1(&s->gb);
		2006	if (s->mix_metadata) {
		2007	int mix_out_mask_size;
		2008
		2009	skip_bits(&s->gb, 2); // adjustment level
		2010	mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
		2011	s->num_mix_configs = get_bits(&s->gb, 2) + 1;
		2012
		2013	for (i = 0; i < s->num_mix_configs; i++) {
		2014	int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
		2015	s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
		2016	}
		2017	}
		2018	}
		2019
		2020	for (i = 0; i < num_assets; i++)
		2021	asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
		2022
		2023	for (i = 0; i < num_assets; i++) {
		2024	if (dca_exss_parse_asset_header(s))
		2025	return;
		2026	}
		2027
		2028	/* not parsed further, we were only interested in the extensions mask
		2029	* from the asset header */
		2030
		2031	if (num_assets > 0) {
		2032	j = get_bits_count(&s->gb);
		2033	if (start_posn + hdrsize * 8 > j)
		2034	skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
		2035
		2036	for (i = 0; i < num_assets; i++) {
		2037	start_posn = get_bits_count(&s->gb);
		2038	mkr = get_bits_long(&s->gb, 32);
		2039
		2040	/* parse extensions that we know about */
		2041	if (mkr == 0x655e315e) {
		2042	dca_xbr_parse_frame(s);
		2043	} else if (mkr == 0x47004a03) {
		2044	dca_xxch_decode_frame(s);
		2045	s->core_ext_mask \|= DCA_EXT_XXCH; /* xxx use for chan reordering */
		2046	} else {
		2047	av_log(s->avctx, AV_LOG_DEBUG,
		2048	"DTS-ExSS: unknown marker = 0x%08x\n", mkr);
		2049	}
		2050
		2051	/* skip to end of block */
		2052	j = get_bits_count(&s->gb);
		2053	if (start_posn + asset_size[i] * 8 > j)
		2054	skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
		2055	}
		2056	}
		2057	}
		2058
		2059	/**
		2060	* Main frame decoding function
		2061	* FIXME add arguments
		2062	*/
		2063	static int dca_decode_frame(AVCodecContext avctx, void data,
		2064	int got_frame_ptr, AVPacket avpkt)
		2065	{
		2066	AVFrame *frame = data;
		2067	const uint8_t *buf = avpkt->data;
		2068	int buf_size = avpkt->size;
		2069	int channel_mask;
		2070	int channel_layout;
		2071	int lfe_samples;
		2072	int num_core_channels = 0;
		2073	int i, ret;
		2074	float **samples_flt;
		2075	float *src_chan;
		2076	float *dst_chan;
		2077	DCAContext *s = avctx->priv_data;
		2078	int core_ss_end;
		2079	int channels, full_channels;
		2080	float scale;
		2081	int achan;
		2082	int chset;
		2083	int mask;
		2084	int lavc;
		2085	int posn;
		2086	int j, k;
		2087	int endch;
		2088
		2089	s->xch_present = 0;
		2090
		2091	s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
		2092	DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
		2093	if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
		2094	av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
		2095	return AVERROR_INVALIDDATA;
		2096	}
		2097
		2098	init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
		2099	if ((ret = dca_parse_frame_header(s)) < 0) {
		2100	//seems like the frame is corrupt, try with the next one
		2101	return ret;
		2102	}
		2103	//set AVCodec values with parsed data
		2104	avctx->sample_rate = s->sample_rate;
		2105	avctx->bit_rate = s->bit_rate;
		2106
		2107	s->profile = FF_PROFILE_DTS;
		2108
		2109	for (i = 0; i < (s->sample_blocks / 8); i++) {
		2110	if ((ret = dca_decode_block(s, 0, i))) {
		2111	av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
		2112	return ret;
		2113	}
		2114	}
		2115
		2116	/* record number of core channels incase less than max channels are requested */
		2117	num_core_channels = s->prim_channels;
		2118
		2119	if (s->ext_coding)
		2120	s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
		2121	else
		2122	s->core_ext_mask = 0;
		2123
		2124	core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
		2125
		2126	/* only scan for extensions if ext_descr was unknown or indicated a
		2127	* supported XCh extension */
		2128	if (s->core_ext_mask < 0 \|\| s->core_ext_mask & (DCA_EXT_XCH \| DCA_EXT_XXCH)) {
		2129
		2130	/* if ext_descr was unknown, clear s->core_ext_mask so that the
		2131	* extensions scan can fill it up */
		2132	s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
		2133
		2134	/* extensions start at 32-bit boundaries into bitstream */
		2135	skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
		2136
		2137	while (core_ss_end - get_bits_count(&s->gb) >= 32) {
		2138	uint32_t bits = get_bits_long(&s->gb, 32);
		2139
		2140	switch (bits) {
		2141	case 0x5a5a5a5a: {
		2142	int ext_amode, xch_fsize;
		2143
		2144	s->xch_base_channel = s->prim_channels;
		2145
		2146	/* validate sync word using XCHFSIZE field */
		2147	xch_fsize = show_bits(&s->gb, 10);
		2148	if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
		2149	(s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
		2150	continue;
		2151
		2152	/* skip length-to-end-of-frame field for the moment */
		2153	skip_bits(&s->gb, 10);
		2154
		2155	s->core_ext_mask \|= DCA_EXT_XCH;
		2156
		2157	/* extension amode(number of channels in extension) should be 1 */
		2158	/* AFAIK XCh is not used for more channels */
		2159	if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
		2160	av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
		2161	" supported!\n", ext_amode);
		2162	continue;
		2163	}
		2164
		2165	if (s->xch_base_channel < 2) {
		2166	avpriv_request_sample(avctx, "XCh with fewer than 2 base channels");
		2167	continue;
		2168	}
		2169
		2170	/* much like core primary audio coding header */
		2171	dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
		2172
		2173	for (i = 0; i < (s->sample_blocks / 8); i++)
		2174	if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
		2175	av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
		2176	continue;
		2177	}
		2178
		2179	s->xch_present = 1;
		2180	break;
		2181	}
		2182	case 0x47004a03:
		2183	/* XXCh: extended channels */
		2184	/* usually found either in core or HD part in DTS-HD HRA streams,
		2185	* but not in DTS-ES which contains XCh extensions instead */
		2186	s->core_ext_mask \|= DCA_EXT_XXCH;
		2187	dca_xxch_decode_frame(s);
		2188	break;
		2189
		2190	case 0x1d95f262: {
		2191	int fsize96 = show_bits(&s->gb, 12) + 1;
		2192	if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
		2193	continue;
		2194
		2195	av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
		2196	get_bits_count(&s->gb));
		2197	skip_bits(&s->gb, 12);
		2198	av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
		2199	av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
		2200
		2201	s->core_ext_mask \|= DCA_EXT_X96;
		2202	break;
		2203	}
		2204	}
		2205
		2206	skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
		2207	}
		2208	} else {
		2209	/* no supported extensions, skip the rest of the core substream */
		2210	skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
		2211	}
		2212
		2213	if (s->core_ext_mask & DCA_EXT_X96)
		2214	s->profile = FF_PROFILE_DTS_96_24;
		2215	else if (s->core_ext_mask & (DCA_EXT_XCH \| DCA_EXT_XXCH))
		2216	s->profile = FF_PROFILE_DTS_ES;
		2217
		2218	/* check for ExSS (HD part) */
		2219	if (s->dca_buffer_size - s->frame_size > 32 &&
		2220	get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
		2221	dca_exss_parse_header(s);
		2222
		2223	avctx->profile = s->profile;
		2224
		2225	full_channels = channels = s->prim_channels + !!s->lfe;
		2226
		2227	/* If we have XXCH then the channel layout is managed differently */
		2228	/* note that XLL will also have another way to do things */
		2229	if (!(s->core_ext_mask & DCA_EXT_XXCH)
		2230	\|\| (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
		2231	&& avctx->request_channels
		2232	< num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
		2233	{ /* xxx should also do MA extensions */
		2234	if (s->amode < 16) {
		2235	avctx->channel_layout = dca_core_channel_layout[s->amode];
		2236
		2237	if (s->xch_present && (!avctx->request_channels \|\|
		2238	avctx->request_channels
		2239	> num_core_channels + !!s->lfe)) {
		2240	avctx->channel_layout \|= AV_CH_BACK_CENTER;
		2241	if (s->lfe) {
		2242	avctx->channel_layout \|= AV_CH_LOW_FREQUENCY;
		2243	s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
		2244	} else {
		2245	s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
		2246	}
		2247	if (s->channel_order_tab[s->xch_base_channel] < 0)
		2248	return AVERROR_INVALIDDATA;
		2249	} else {
		2250	channels = num_core_channels + !!s->lfe;
		2251	s->xch_present = 0; /* disable further xch processing */
		2252	if (s->lfe) {
		2253	avctx->channel_layout \|= AV_CH_LOW_FREQUENCY;
		2254	s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
		2255	} else
		2256	s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
		2257	}
		2258
		2259	if (channels > !!s->lfe &&
		2260	s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
		2261	return AVERROR_INVALIDDATA;
		2262
		2263	if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) {
		2264	av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout));
		2265	return AVERROR_INVALIDDATA;
		2266	}
		2267
		2268	if (avctx->request_channels == 2 && s->prim_channels > 2) {
		2269	channels = 2;
		2270	s->output = DCA_STEREO;
		2271	avctx->channel_layout = AV_CH_LAYOUT_STEREO;
		2272	}
		2273	else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
		2274	static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
		2275	s->channel_order_tab = dca_channel_order_native;
		2276	}
		2277	s->lfe_index = dca_lfe_index[s->amode];
		2278	} else {
		2279	av_log(avctx, AV_LOG_ERROR,
		2280	"Non standard configuration %d !\n", s->amode);
		2281	return AVERROR_INVALIDDATA;
		2282	}
		2283
		2284	s->xxch_dmix_embedded = 0;
		2285	} else {
		2286	/* we only get here if an XXCH channel set can be added to the mix */
		2287	channel_mask = s->xxch_core_spkmask;
		2288
		2289	if (avctx->request_channels > 0
		2290	&& avctx->request_channels < s->prim_channels) {
		2291	channels = num_core_channels + !!s->lfe;
		2292	for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
		2293	<= avctx->request_channels; i++) {
		2294	channels += s->xxch_chset_nch[i];
		2295	channel_mask \|= s->xxch_spk_masks[i];
		2296	}
		2297	} else {
		2298	channels = s->prim_channels + !!s->lfe;
		2299	for (i = 0; i < s->xxch_chset; i++) {
		2300	channel_mask \|= s->xxch_spk_masks[i];
		2301	}
		2302	}
		2303
		2304	/* Given the DTS spec'ed channel mask, generate an avcodec version */
		2305	channel_layout = 0;
		2306	for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
		2307	if (channel_mask & (1 << i)) {
		2308	channel_layout \|= map_xxch_to_native[i];
		2309	}
		2310	}
		2311
		2312	/* make sure that we have managed to get equivelant dts/avcodec channel
		2313	* masks in some sense -- unfortunately some channels could overlap */
		2314	if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
		2315	av_log(avctx, AV_LOG_DEBUG,
		2316	"DTS-XXCH: Inconsistant avcodec/dts channel layouts\n");
		2317	return AVERROR_INVALIDDATA;
		2318	}
		2319
		2320	avctx->channel_layout = channel_layout;
		2321
		2322	if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
		2323	/* Estimate DTS --> avcodec ordering table */
		2324	for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
		2325	mask = chset >= 0 ? s->xxch_spk_masks[chset]
		2326	: s->xxch_core_spkmask;
		2327	for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
		2328	if (mask & ~(DCA_XXCH_LFE1 \| DCA_XXCH_LFE2) & (1 << i)) {
		2329	lavc = map_xxch_to_native[i];
		2330	posn = av_popcount(channel_layout & (lavc - 1));
		2331	s->xxch_order_tab[j++] = posn;
		2332	}
		2333	}
		2334	}
		2335
		2336	s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
		2337	} else { /* native ordering */
		2338	for (i = 0; i < channels; i++)
		2339	s->xxch_order_tab[i] = i;
		2340
		2341	s->lfe_index = channels - 1;
		2342	}
		2343
		2344	s->channel_order_tab = s->xxch_order_tab;
		2345	}
		2346
		2347	if (avctx->channels != channels) {
		2348	if (avctx->channels)
		2349	av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
		2350	avctx->channels = channels;
		2351	}
		2352
		2353	/* get output buffer */
		2354	frame->nb_samples = 256 * (s->sample_blocks / 8);
		2355	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
		2356	return ret;
		2357	samples_flt = (float **)frame->extended_data;
		2358
		2359	/* allocate buffer for extra channels if downmixing */
		2360	if (avctx->channels < full_channels) {
		2361	ret = av_samples_get_buffer_size(NULL, full_channels - channels,
		2362	frame->nb_samples,
		2363	avctx->sample_fmt, 0);
		2364	if (ret < 0)
		2365	return ret;
		2366
		2367	av_fast_malloc(&s->extra_channels_buffer,
		2368	&s->extra_channels_buffer_size, ret);
		2369	if (!s->extra_channels_buffer)
		2370	return AVERROR(ENOMEM);
		2371
		2372	ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
		2373	s->extra_channels_buffer,
		2374	full_channels - channels,
		2375	frame->nb_samples, avctx->sample_fmt, 0);
		2376	if (ret < 0)
		2377	return ret;
		2378	}
		2379
		2380	/* filter to get final output */
		2381	for (i = 0; i < (s->sample_blocks / 8); i++) {
		2382	int ch;
		2383
		2384	for (ch = 0; ch < channels; ch++)
		2385	s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
		2386	for (; ch < full_channels; ch++)
		2387	s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
		2388
		2389	dca_filter_channels(s, i);
		2390
		2391	/* If this was marked as a DTS-ES stream we need to subtract back- */
		2392	/* channel from SL & SR to remove matrixed back-channel signal */
		2393	if ((s->source_pcm_res & 1) && s->xch_present) {
		2394	float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
		2395	float *lt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
		2396	float *rt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
		2397	s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
		2398	s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
		2399	}
		2400
		2401	/* If stream contains XXCH, we might need to undo an embedded downmix */
		2402	if (s->xxch_dmix_embedded) {
		2403	/* Loop over channel sets in turn */
		2404	ch = num_core_channels;
		2405	for (chset = 0; chset < s->xxch_chset; chset++) {
		2406	endch = ch + s->xxch_chset_nch[chset];
		2407	mask = s->xxch_dmix_embedded;
		2408
		2409	/* undo downmix */
		2410	for (j = ch; j < endch; j++) {
		2411	if (mask & (1 << j)) { /* this channel has been mixed-out */
		2412	src_chan = s->samples_chanptr[s->channel_order_tab[j]];
		2413	for (k = 0; k < endch; k++) {
		2414	achan = s->channel_order_tab[k];
		2415	scale = s->xxch_dmix_coeff[j][k];
		2416	if (scale != 0.0) {
		2417	dst_chan = s->samples_chanptr[achan];
		2418	s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
		2419	-scale, 256);
		2420	}
		2421	}
		2422	}
		2423	}
		2424
		2425	/* if a downmix has been embedded then undo the pre-scaling */
		2426	if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
		2427	scale = s->xxch_dmix_sf[chset];
		2428
		2429	for (j = 0; j < ch; j++) {
		2430	src_chan = s->samples_chanptr[s->channel_order_tab[j]];
		2431	for (k = 0; k < 256; k++)
		2432	src_chan[k] *= scale;
		2433	}
		2434
		2435	/* LFE channel is always part of core, scale if it exists */
		2436	if (s->lfe) {
		2437	src_chan = s->samples_chanptr[s->lfe_index];
		2438	for (k = 0; k < 256; k++)
		2439	src_chan[k] *= scale;
		2440	}
		2441	}
		2442
		2443	ch = endch;
		2444	}
		2445
		2446	}
		2447	}
		2448
		2449	/* update lfe history */
		2450	lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
		2451	for (i = 0; i < 2 * s->lfe * 4; i++)
		2452	s->lfe_data[i] = s->lfe_data[i + lfe_samples];
		2453
		2454	*got_frame_ptr = 1;
		2455
		2456	return buf_size;
		2457	}
		2458
		2459
		2460
		2461	/**
		2462	* DCA initialization
		2463	*
		2464	* @param avctx pointer to the AVCodecContext
		2465	*/
		2466
		2467	static av_cold int dca_decode_init(AVCodecContext *avctx)
		2468	{
		2469	DCAContext *s = avctx->priv_data;
		2470
		2471	s->avctx = avctx;
		2472	dca_init_vlcs();
		2473
		2474	avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
		2475	ff_mdct_init(&s->imdct, 6, 1, 1.0);
		2476	ff_synth_filter_init(&s->synth);
		2477	ff_dcadsp_init(&s->dcadsp);
		2478	ff_fmt_convert_init(&s->fmt_conv, avctx);
		2479
		2480	avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
		2481
		2482	/* allow downmixing to stereo */
		2483	if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
		2484	avctx->request_channels == 2) {
		2485	avctx->channels = avctx->request_channels;
		2486	}
		2487
		2488	return 0;
		2489	}
		2490
		2491	static av_cold int dca_decode_end(AVCodecContext *avctx)
		2492	{
		2493	DCAContext *s = avctx->priv_data;
		2494	ff_mdct_end(&s->imdct);
		2495	av_freep(&s->extra_channels_buffer);
		2496	return 0;
		2497	}
		2498
		2499	static const AVProfile profiles[] = {
		2500	{ FF_PROFILE_DTS, "DTS" },
		2501	{ FF_PROFILE_DTS_ES, "DTS-ES" },
		2502	{ FF_PROFILE_DTS_96_24, "DTS 96/24" },
		2503	{ FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
		2504	{ FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
		2505	{ FF_PROFILE_UNKNOWN },
		2506	};
		2507
		2508	AVCodec ff_dca_decoder = {
		2509	.name = "dca",
		2510	.long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
		2511	.type = AVMEDIA_TYPE_AUDIO,
		2512	.id = AV_CODEC_ID_DTS,
		2513	.priv_data_size = sizeof(DCAContext),
		2514	.init = dca_decode_init,
		2515	.decode = dca_decode_frame,
		2516	.close = dca_decode_end,
		2517	.capabilities = CODEC_CAP_CHANNEL_CONF \| CODEC_CAP_DR1,
		2518	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
		2519	AV_SAMPLE_FMT_NONE },
		2520	.profiles = NULL_IF_CONFIG_SMALL(profiles),
		2521	};

Subversion Repositories Kolibri OS

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