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

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* IMC compatible decoder
		3	* Copyright (c) 2002-2004 Maxim Poliakovski
		4	* Copyright (c) 2006 Benjamin Larsson
		5	* Copyright (c) 2006 Konstantin Shishkov
		6	*
		7	* This file is part of FFmpeg.
		8	*
		9	* FFmpeg is free software; you can redistribute it and/or
		10	* modify it under the terms of the GNU Lesser General Public
		11	* License as published by the Free Software Foundation; either
		12	* version 2.1 of the License, or (at your option) any later version.
		13	*
		14	* FFmpeg is distributed in the hope that it will be useful,
		15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		17	* Lesser General Public License for more details.
		18	*
		19	* You should have received a copy of the GNU Lesser General Public
		20	* License along with FFmpeg; if not, write to the Free Software
		21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		22	*/
		23
		24	/**
		25	* @file
		26	* IMC - Intel Music Coder
		27	* A mdct based codec using a 256 points large transform
		28	* divided into 32 bands with some mix of scale factors.
		29	* Only mono is supported.
		30	*
		31	*/
		32
		33
		34	#include
		35	#include
		36	#include
		37
		38	#include "libavutil/channel_layout.h"
		39	#include "libavutil/float_dsp.h"
		40	#include "libavutil/internal.h"
		41	#include "libavutil/libm.h"
		42	#include "avcodec.h"
		43	#include "get_bits.h"
		44	#include "dsputil.h"
		45	#include "fft.h"
		46	#include "internal.h"
		47	#include "sinewin.h"
		48
		49	#include "imcdata.h"
		50
		51	#define IMC_BLOCK_SIZE 64
		52	#define IMC_FRAME_ID 0x21
		53	#define BANDS 32
		54	#define COEFFS 256
		55
		56	typedef struct IMCChannel {
		57	float old_floor[BANDS];
		58	float flcoeffs1[BANDS];
		59	float flcoeffs2[BANDS];
		60	float flcoeffs3[BANDS];
		61	float flcoeffs4[BANDS];
		62	float flcoeffs5[BANDS];
		63	float flcoeffs6[BANDS];
		64	float CWdecoded[COEFFS];
		65
		66	int bandWidthT[BANDS]; ///< codewords per band
		67	int bitsBandT[BANDS]; ///< how many bits per codeword in band
		68	int CWlengthT[COEFFS]; ///< how many bits in each codeword
		69	int levlCoeffBuf[BANDS];
		70	int bandFlagsBuf[BANDS]; ///< flags for each band
		71	int sumLenArr[BANDS]; ///< bits for all coeffs in band
		72	int skipFlagRaw[BANDS]; ///< skip flags are stored in raw form or not
		73	int skipFlagBits[BANDS]; ///< bits used to code skip flags
		74	int skipFlagCount[BANDS]; ///< skipped coeffients per band
		75	int skipFlags[COEFFS]; ///< skip coefficient decoding or not
		76	int codewords[COEFFS]; ///< raw codewords read from bitstream
		77
		78	float last_fft_im[COEFFS];
		79
		80	int decoder_reset;
		81	} IMCChannel;
		82
		83	typedef struct {
		84	IMCChannel chctx[2];
		85
		86	/** MDCT tables */
		87	//@{
		88	float mdct_sine_window[COEFFS];
		89	float post_cos[COEFFS];
		90	float post_sin[COEFFS];
		91	float pre_coef1[COEFFS];
		92	float pre_coef2[COEFFS];
		93	//@}
		94
		95	float sqrt_tab[30];
		96	GetBitContext gb;
		97
		98	DSPContext dsp;
		99	AVFloatDSPContext fdsp;
		100	FFTContext fft;
		101	DECLARE_ALIGNED(32, FFTComplex, samples)[COEFFS / 2];
		102	float *out_samples;
		103
		104	int coef0_pos;
		105
		106	int8_t cyclTab[32], cyclTab2[32];
		107	float weights1[31], weights2[31];
		108	} IMCContext;
		109
		110	static VLC huffman_vlc[4][4];
		111
		112	#define VLC_TABLES_SIZE 9512
		113
		114	static const int vlc_offsets[17] = {
		115	0, 640, 1156, 1732, 2308, 2852, 3396, 3924,
		116	4452, 5220, 5860, 6628, 7268, 7908, 8424, 8936, VLC_TABLES_SIZE
		117	};
		118
		119	static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2];
		120
		121	static inline double freq2bark(double freq)
		122	{
		123	return 3.5 * atan((freq / 7500.0) * (freq / 7500.0)) + 13.0 * atan(freq * 0.00076);
		124	}
		125
		126	static av_cold void iac_generate_tabs(IMCContext *q, int sampling_rate)
		127	{
		128	double freqmin[32], freqmid[32], freqmax[32];
		129	double scale = sampling_rate / (256.0 * 2.0 * 2.0);
		130	double nyquist_freq = sampling_rate * 0.5;
		131	double freq, bark, prev_bark = 0, tf, tb;
		132	int i, j;
		133
		134	for (i = 0; i < 32; i++) {
		135	freq = (band_tab[i] + band_tab[i + 1] - 1) * scale;
		136	bark = freq2bark(freq);
		137
		138	if (i > 0) {
		139	tb = bark - prev_bark;
		140	q->weights1[i - 1] = pow(10.0, -1.0 * tb);
		141	q->weights2[i - 1] = pow(10.0, -2.7 * tb);
		142	}
		143	prev_bark = bark;
		144
		145	freqmid[i] = freq;
		146
		147	tf = freq;
		148	while (tf < nyquist_freq) {
		149	tf += 0.5;
		150	tb = freq2bark(tf);
		151	if (tb > bark + 0.5)
		152	break;
		153	}
		154	freqmax[i] = tf;
		155
		156	tf = freq;
		157	while (tf > 0.0) {
		158	tf -= 0.5;
		159	tb = freq2bark(tf);
		160	if (tb <= bark - 0.5)
		161	break;
		162	}
		163	freqmin[i] = tf;
		164	}
		165
		166	for (i = 0; i < 32; i++) {
		167	freq = freqmax[i];
		168	for (j = 31; j > 0 && freq <= freqmid[j]; j--);
		169	q->cyclTab[i] = j + 1;
		170
		171	freq = freqmin[i];
		172	for (j = 0; j < 32 && freq >= freqmid[j]; j++);
		173	q->cyclTab2[i] = j - 1;
		174	}
		175	}
		176
		177	static av_cold int imc_decode_init(AVCodecContext *avctx)
		178	{
		179	int i, j, ret;
		180	IMCContext *q = avctx->priv_data;
		181	double r1, r2;
		182
		183	if (avctx->codec_id == AV_CODEC_ID_IMC)
		184	avctx->channels = 1;
		185
		186	if (avctx->channels > 2) {
		187	avpriv_request_sample(avctx, "Number of channels > 2");
		188	return AVERROR_PATCHWELCOME;
		189	}
		190
		191	for (j = 0; j < avctx->channels; j++) {
		192	q->chctx[j].decoder_reset = 1;
		193
		194	for (i = 0; i < BANDS; i++)
		195	q->chctx[j].old_floor[i] = 1.0;
		196
		197	for (i = 0; i < COEFFS / 2; i++)
		198	q->chctx[j].last_fft_im[i] = 0;
		199	}
		200
		201	/* Build mdct window, a simple sine window normalized with sqrt(2) */
		202	ff_sine_window_init(q->mdct_sine_window, COEFFS);
		203	for (i = 0; i < COEFFS; i++)
		204	q->mdct_sine_window[i] *= sqrt(2.0);
		205	for (i = 0; i < COEFFS / 2; i++) {
		206	q->post_cos[i] = (1.0f / 32768) * cos(i / 256.0 * M_PI);
		207	q->post_sin[i] = (1.0f / 32768) * sin(i / 256.0 * M_PI);
		208
		209	r1 = sin((i * 4.0 + 1.0) / 1024.0 * M_PI);
		210	r2 = cos((i * 4.0 + 1.0) / 1024.0 * M_PI);
		211
		212	if (i & 0x1) {
		213	q->pre_coef1[i] = (r1 + r2) * sqrt(2.0);
		214	q->pre_coef2[i] = -(r1 - r2) * sqrt(2.0);
		215	} else {
		216	q->pre_coef1[i] = -(r1 + r2) * sqrt(2.0);
		217	q->pre_coef2[i] = (r1 - r2) * sqrt(2.0);
		218	}
		219	}
		220
		221	/* Generate a square root table */
		222
		223	for (i = 0; i < 30; i++)
		224	q->sqrt_tab[i] = sqrt(i);
		225
		226	/* initialize the VLC tables */
		227	for (i = 0; i < 4 ; i++) {
		228	for (j = 0; j < 4; j++) {
		229	huffman_vlc[i][j].table = &vlc_tables[vlc_offsets[i * 4 + j]];
		230	huffman_vlc[i][j].table_allocated = vlc_offsets[i * 4 + j + 1] - vlc_offsets[i * 4 + j];
		231	init_vlc(&huffman_vlc[i][j], 9, imc_huffman_sizes[i],
		232	imc_huffman_lens[i][j], 1, 1,
		233	imc_huffman_bits[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
		234	}
		235	}
		236
		237	if (avctx->codec_id == AV_CODEC_ID_IAC) {
		238	iac_generate_tabs(q, avctx->sample_rate);
		239	} else {
		240	memcpy(q->cyclTab, cyclTab, sizeof(cyclTab));
		241	memcpy(q->cyclTab2, cyclTab2, sizeof(cyclTab2));
		242	memcpy(q->weights1, imc_weights1, sizeof(imc_weights1));
		243	memcpy(q->weights2, imc_weights2, sizeof(imc_weights2));
		244	}
		245
		246	if ((ret = ff_fft_init(&q->fft, 7, 1))) {
		247	av_log(avctx, AV_LOG_INFO, "FFT init failed\n");
		248	return ret;
		249	}
		250	ff_dsputil_init(&q->dsp, avctx);
		251	avpriv_float_dsp_init(&q->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
		252	avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
		253	avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO
		254	: AV_CH_LAYOUT_STEREO;
		255
		256	return 0;
		257	}
		258
		259	static void imc_calculate_coeffs(IMCContext q, float flcoeffs1,
		260	float flcoeffs2, int bandWidthT,
		261	float flcoeffs3, float flcoeffs5)
		262	{
		263	float workT1[BANDS];
		264	float workT2[BANDS];
		265	float workT3[BANDS];
		266	float snr_limit = 1.e-30;
		267	float accum = 0.0;
		268	int i, cnt2;
		269
		270	for (i = 0; i < BANDS; i++) {
		271	flcoeffs5[i] = workT2[i] = 0.0;
		272	if (bandWidthT[i]) {
		273	workT1[i] = flcoeffs1[i] * flcoeffs1[i];
		274	flcoeffs3[i] = 2.0 * flcoeffs2[i];
		275	} else {
		276	workT1[i] = 0.0;
		277	flcoeffs3[i] = -30000.0;
		278	}
		279	workT3[i] = bandWidthT[i] * workT1[i] * 0.01;
		280	if (workT3[i] <= snr_limit)
		281	workT3[i] = 0.0;
		282	}
		283
		284	for (i = 0; i < BANDS; i++) {
		285	for (cnt2 = i; cnt2 < q->cyclTab[i]; cnt2++)
		286	flcoeffs5[cnt2] = flcoeffs5[cnt2] + workT3[i];
		287	workT2[cnt2 - 1] = workT2[cnt2 - 1] + workT3[i];
		288	}
		289
		290	for (i = 1; i < BANDS; i++) {
		291	accum = (workT2[i - 1] + accum) * q->weights1[i - 1];
		292	flcoeffs5[i] += accum;
		293	}
		294
		295	for (i = 0; i < BANDS; i++)
		296	workT2[i] = 0.0;
		297
		298	for (i = 0; i < BANDS; i++) {
		299	for (cnt2 = i - 1; cnt2 > q->cyclTab2[i]; cnt2--)
		300	flcoeffs5[cnt2] += workT3[i];
		301	workT2[cnt2+1] += workT3[i];
		302	}
		303
		304	accum = 0.0;
		305
		306	for (i = BANDS-2; i >= 0; i--) {
		307	accum = (workT2[i+1] + accum) * q->weights2[i];
		308	flcoeffs5[i] += accum;
		309	// there is missing code here, but it seems to never be triggered
		310	}
		311	}
		312
		313
		314	static void imc_read_level_coeffs(IMCContext *q, int stream_format_code,
		315	int *levlCoeffs)
		316	{
		317	int i;
		318	VLC *hufftab[4];
		319	int start = 0;
		320	const uint8_t *cb_sel;
		321	int s;
		322
		323	s = stream_format_code >> 1;
		324	hufftab[0] = &huffman_vlc[s][0];
		325	hufftab[1] = &huffman_vlc[s][1];
		326	hufftab[2] = &huffman_vlc[s][2];
		327	hufftab[3] = &huffman_vlc[s][3];
		328	cb_sel = imc_cb_select[s];
		329
		330	if (stream_format_code & 4)
		331	start = 1;
		332	if (start)
		333	levlCoeffs[0] = get_bits(&q->gb, 7);
		334	for (i = start; i < BANDS; i++) {
		335	levlCoeffs[i] = get_vlc2(&q->gb, hufftab[cb_sel[i]]->table,
		336	hufftab[cb_sel[i]]->bits, 2);
		337	if (levlCoeffs[i] == 17)
		338	levlCoeffs[i] += get_bits(&q->gb, 4);
		339	}
		340	}
		341
		342	static void imc_read_level_coeffs_raw(IMCContext *q, int stream_format_code,
		343	int *levlCoeffs)
		344	{
		345	int i;
		346
		347	q->coef0_pos = get_bits(&q->gb, 5);
		348	levlCoeffs[0] = get_bits(&q->gb, 7);
		349	for (i = 1; i < BANDS; i++)
		350	levlCoeffs[i] = get_bits(&q->gb, 4);
		351	}
		352
		353	static void imc_decode_level_coefficients(IMCContext q, int levlCoeffBuf,
		354	float flcoeffs1, float flcoeffs2)
		355	{
		356	int i, level;
		357	float tmp, tmp2;
		358	// maybe some frequency division thingy
		359
		360	flcoeffs1[0] = 20000.0 / exp2 (levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
		361	flcoeffs2[0] = log2f(flcoeffs1[0]);
		362	tmp = flcoeffs1[0];
		363	tmp2 = flcoeffs2[0];
		364
		365	for (i = 1; i < BANDS; i++) {
		366	level = levlCoeffBuf[i];
		367	if (level == 16) {
		368	flcoeffs1[i] = 1.0;
		369	flcoeffs2[i] = 0.0;
		370	} else {
		371	if (level < 17)
		372	level -= 7;
		373	else if (level <= 24)
		374	level -= 32;
		375	else
		376	level -= 16;
		377
		378	tmp *= imc_exp_tab[15 + level];
		379	tmp2 += 0.83048 * level; // 0.83048 = log2(10) * 0.25
		380	flcoeffs1[i] = tmp;
		381	flcoeffs2[i] = tmp2;
		382	}
		383	}
		384	}
		385
		386
		387	static void imc_decode_level_coefficients2(IMCContext q, int levlCoeffBuf,
		388	float old_floor, float flcoeffs1,
		389	float *flcoeffs2)
		390	{
		391	int i;
		392	/* FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
		393	* and flcoeffs2 old scale factors
		394	* might be incomplete due to a missing table that is in the binary code
		395	*/
		396	for (i = 0; i < BANDS; i++) {
		397	flcoeffs1[i] = 0;
		398	if (levlCoeffBuf[i] < 16) {
		399	flcoeffs1[i] = imc_exp_tab2[levlCoeffBuf[i]] * old_floor[i];
		400	flcoeffs2[i] = (levlCoeffBuf[i] - 7) * 0.83048 + flcoeffs2[i]; // 0.83048 = log2(10) * 0.25
		401	} else {
		402	flcoeffs1[i] = old_floor[i];
		403	}
		404	}
		405	}
		406
		407	static void imc_decode_level_coefficients_raw(IMCContext q, int levlCoeffBuf,
		408	float flcoeffs1, float flcoeffs2)
		409	{
		410	int i, level, pos;
		411	float tmp, tmp2;
		412
		413	pos = q->coef0_pos;
		414	flcoeffs1[pos] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
		415	flcoeffs2[pos] = log2f(flcoeffs1[0]);
		416	tmp = flcoeffs1[pos];
		417	tmp2 = flcoeffs2[pos];
		418
		419	levlCoeffBuf++;
		420	for (i = 0; i < BANDS; i++) {
		421	if (i == pos)
		422	continue;
		423	level = *levlCoeffBuf++;
		424	flcoeffs1[i] = tmp * powf(10.0, -level * 0.4375); //todo tab
		425	flcoeffs2[i] = tmp2 - 1.4533435415 * level; // 1.4533435415 = log2(10) * 0.4375
		426	}
		427	}
		428
		429	/**
		430	* Perform bit allocation depending on bits available
		431	*/
		432	static int bit_allocation(IMCContext q, IMCChannel chctx,
		433	int stream_format_code, int freebits, int flag)
		434	{
		435	int i, j;
		436	const float limit = -1.e20;
		437	float highest = 0.0;
		438	int indx;
		439	int t1 = 0;
		440	int t2 = 1;
		441	float summa = 0.0;
		442	int iacc = 0;
		443	int summer = 0;
		444	int rres, cwlen;
		445	float lowest = 1.e10;
		446	int low_indx = 0;
		447	float workT[32];
		448	int flg;
		449	int found_indx = 0;
		450
		451	for (i = 0; i < BANDS; i++)
		452	highest = FFMAX(highest, chctx->flcoeffs1[i]);
		453
		454	for (i = 0; i < BANDS - 1; i++) {
		455	if (chctx->flcoeffs5[i] <= 0) {
		456	av_log(NULL, AV_LOG_ERROR, "flcoeffs5 %f invalid\n", chctx->flcoeffs5[i]);
		457	return AVERROR_INVALIDDATA;
		458	}
		459	chctx->flcoeffs4[i] = chctx->flcoeffs3[i] - log2f(chctx->flcoeffs5[i]);
		460	}
		461	chctx->flcoeffs4[BANDS - 1] = limit;
		462
		463	highest = highest * 0.25;
		464
		465	for (i = 0; i < BANDS; i++) {
		466	indx = -1;
		467	if ((band_tab[i + 1] - band_tab[i]) == chctx->bandWidthT[i])
		468	indx = 0;
		469
		470	if ((band_tab[i + 1] - band_tab[i]) > chctx->bandWidthT[i])
		471	indx = 1;
		472
		473	if (((band_tab[i + 1] - band_tab[i]) / 2) >= chctx->bandWidthT[i])
		474	indx = 2;
		475
		476	if (indx == -1)
		477	return AVERROR_INVALIDDATA;
		478
		479	chctx->flcoeffs4[i] += xTab[(indx * 2 + (chctx->flcoeffs1[i] < highest)) * 2 + flag];
		480	}
		481
		482	if (stream_format_code & 0x2) {
		483	chctx->flcoeffs4[0] = limit;
		484	chctx->flcoeffs4[1] = limit;
		485	chctx->flcoeffs4[2] = limit;
		486	chctx->flcoeffs4[3] = limit;
		487	}
		488
		489	for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS - 1; i++) {
		490	iacc += chctx->bandWidthT[i];
		491	summa += chctx->bandWidthT[i] * chctx->flcoeffs4[i];
		492	}
		493
		494	if (!iacc)
		495	return AVERROR_INVALIDDATA;
		496
		497	chctx->bandWidthT[BANDS - 1] = 0;
		498	summa = (summa * 0.5 - freebits) / iacc;
		499
		500
		501	for (i = 0; i < BANDS / 2; i++) {
		502	rres = summer - freebits;
		503	if ((rres >= -8) && (rres <= 8))
		504	break;
		505
		506	summer = 0;
		507	iacc = 0;
		508
		509	for (j = (stream_format_code & 0x2) ? 4 : 0; j < BANDS; j++) {
		510	cwlen = av_clipf(((chctx->flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);
		511
		512	chctx->bitsBandT[j] = cwlen;
		513	summer += chctx->bandWidthT[j] * cwlen;
		514
		515	if (cwlen > 0)
		516	iacc += chctx->bandWidthT[j];
		517	}
		518
		519	flg = t2;
		520	t2 = 1;
		521	if (freebits < summer)
		522	t2 = -1;
		523	if (i == 0)
		524	flg = t2;
		525	if (flg != t2)
		526	t1++;
		527
		528	summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
		529	}
		530
		531	for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS; i++) {
		532	for (j = band_tab[i]; j < band_tab[i + 1]; j++)
		533	chctx->CWlengthT[j] = chctx->bitsBandT[i];
		534	}
		535
		536	if (freebits > summer) {
		537	for (i = 0; i < BANDS; i++) {
		538	workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
		539	: (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
		540	}
		541
		542	highest = 0.0;
		543
		544	do {
		545	if (highest <= -1.e20)
		546	break;
		547
		548	found_indx = 0;
		549	highest = -1.e20;
		550
		551	for (i = 0; i < BANDS; i++) {
		552	if (workT[i] > highest) {
		553	highest = workT[i];
		554	found_indx = i;
		555	}
		556	}
		557
		558	if (highest > -1.e20) {
		559	workT[found_indx] -= 2.0;
		560	if (++chctx->bitsBandT[found_indx] == 6)
		561	workT[found_indx] = -1.e20;
		562
		563	for (j = band_tab[found_indx]; j < band_tab[found_indx + 1] && (freebits > summer); j++) {
		564	chctx->CWlengthT[j]++;
		565	summer++;
		566	}
		567	}
		568	} while (freebits > summer);
		569	}
		570	if (freebits < summer) {
		571	for (i = 0; i < BANDS; i++) {
		572	workT[i] = chctx->bitsBandT[i] ? (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] + 1.585)
		573	: 1.e20;
		574	}
		575	if (stream_format_code & 0x2) {
		576	workT[0] = 1.e20;
		577	workT[1] = 1.e20;
		578	workT[2] = 1.e20;
		579	workT[3] = 1.e20;
		580	}
		581	while (freebits < summer) {
		582	lowest = 1.e10;
		583	low_indx = 0;
		584	for (i = 0; i < BANDS; i++) {
		585	if (workT[i] < lowest) {
		586	lowest = workT[i];
		587	low_indx = i;
		588	}
		589	}
		590	// if (lowest >= 1.e10)
		591	// break;
		592	workT[low_indx] = lowest + 2.0;
		593
		594	if (!--chctx->bitsBandT[low_indx])
		595	workT[low_indx] = 1.e20;
		596
		597	for (j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++) {
		598	if (chctx->CWlengthT[j] > 0) {
		599	chctx->CWlengthT[j]--;
		600	summer--;
		601	}
		602	}
		603	}
		604	}
		605	return 0;
		606	}
		607
		608	static void imc_get_skip_coeff(IMCContext q, IMCChannel chctx)
		609	{
		610	int i, j;
		611
		612	memset(chctx->skipFlagBits, 0, sizeof(chctx->skipFlagBits));
		613	memset(chctx->skipFlagCount, 0, sizeof(chctx->skipFlagCount));
		614	for (i = 0; i < BANDS; i++) {
		615	if (!chctx->bandFlagsBuf[i] \|\| !chctx->bandWidthT[i])
		616	continue;
		617
		618	if (!chctx->skipFlagRaw[i]) {
		619	chctx->skipFlagBits[i] = band_tab[i + 1] - band_tab[i];
		620
		621	for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
		622	chctx->skipFlags[j] = get_bits1(&q->gb);
		623	if (chctx->skipFlags[j])
		624	chctx->skipFlagCount[i]++;
		625	}
		626	} else {
		627	for (j = band_tab[i]; j < band_tab[i + 1] - 1; j += 2) {
		628	if (!get_bits1(&q->gb)) { // 0
		629	chctx->skipFlagBits[i]++;
		630	chctx->skipFlags[j] = 1;
		631	chctx->skipFlags[j + 1] = 1;
		632	chctx->skipFlagCount[i] += 2;
		633	} else {
		634	if (get_bits1(&q->gb)) { // 11
		635	chctx->skipFlagBits[i] += 2;
		636	chctx->skipFlags[j] = 0;
		637	chctx->skipFlags[j + 1] = 1;
		638	chctx->skipFlagCount[i]++;
		639	} else {
		640	chctx->skipFlagBits[i] += 3;
		641	chctx->skipFlags[j + 1] = 0;
		642	if (!get_bits1(&q->gb)) { // 100
		643	chctx->skipFlags[j] = 1;
		644	chctx->skipFlagCount[i]++;
		645	} else { // 101
		646	chctx->skipFlags[j] = 0;
		647	}
		648	}
		649	}
		650	}
		651
		652	if (j < band_tab[i + 1]) {
		653	chctx->skipFlagBits[i]++;
		654	if ((chctx->skipFlags[j] = get_bits1(&q->gb)))
		655	chctx->skipFlagCount[i]++;
		656	}
		657	}
		658	}
		659	}
		660
		661	/**
		662	* Increase highest' band coefficient sizes as some bits won't be used
		663	*/
		664	static void imc_adjust_bit_allocation(IMCContext q, IMCChannel chctx,
		665	int summer)
		666	{
		667	float workT[32];
		668	int corrected = 0;
		669	int i, j;
		670	float highest = 0;
		671	int found_indx = 0;
		672
		673	for (i = 0; i < BANDS; i++) {
		674	workT[i] = (chctx->bitsBandT[i] == 6) ? -1.e20
		675	: (chctx->bitsBandT[i] * -2 + chctx->flcoeffs4[i] - 0.415);
		676	}
		677
		678	while (corrected < summer) {
		679	if (highest <= -1.e20)
		680	break;
		681
		682	highest = -1.e20;
		683
		684	for (i = 0; i < BANDS; i++) {
		685	if (workT[i] > highest) {
		686	highest = workT[i];
		687	found_indx = i;
		688	}
		689	}
		690
		691	if (highest > -1.e20) {
		692	workT[found_indx] -= 2.0;
		693	if (++(chctx->bitsBandT[found_indx]) == 6)
		694	workT[found_indx] = -1.e20;
		695
		696	for (j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
		697	if (!chctx->skipFlags[j] && (chctx->CWlengthT[j] < 6)) {
		698	chctx->CWlengthT[j]++;
		699	corrected++;
		700	}
		701	}
		702	}
		703	}
		704	}
		705
		706	static void imc_imdct256(IMCContext q, IMCChannel chctx, int channels)
		707	{
		708	int i;
		709	float re, im;
		710	float *dst1 = q->out_samples;
		711	float *dst2 = q->out_samples + (COEFFS - 1);
		712
		713	/* prerotation */
		714	for (i = 0; i < COEFFS / 2; i++) {
		715	q->samples[i].re = -(q->pre_coef1[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
		716	(q->pre_coef2[i] * chctx->CWdecoded[i * 2]);
		717	q->samples[i].im = (q->pre_coef2[i] * chctx->CWdecoded[COEFFS - 1 - i * 2]) -
		718	(q->pre_coef1[i] * chctx->CWdecoded[i * 2]);
		719	}
		720
		721	/* FFT */
		722	q->fft.fft_permute(&q->fft, q->samples);
		723	q->fft.fft_calc(&q->fft, q->samples);
		724
		725	/* postrotation, window and reorder */
		726	for (i = 0; i < COEFFS / 2; i++) {
		727	re = ( q->samples[i].re * q->post_cos[i]) + (-q->samples[i].im * q->post_sin[i]);
		728	im = (-q->samples[i].im * q->post_cos[i]) - ( q->samples[i].re * q->post_sin[i]);
		729	dst1 = (q->mdct_sine_window[COEFFS - 1 - i 2] * chctx->last_fft_im[i])
		730	+ (q->mdct_sine_window[i * 2] * re);
		731	dst2 = (q->mdct_sine_window[i 2] * chctx->last_fft_im[i])
		732	- (q->mdct_sine_window[COEFFS - 1 - i * 2] * re);
		733	dst1 += 2;
		734	dst2 -= 2;
		735	chctx->last_fft_im[i] = im;
		736	}
		737	}
		738
		739	static int inverse_quant_coeff(IMCContext q, IMCChannel chctx,
		740	int stream_format_code)
		741	{
		742	int i, j;
		743	int middle_value, cw_len, max_size;
		744	const float *quantizer;
		745
		746	for (i = 0; i < BANDS; i++) {
		747	for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
		748	chctx->CWdecoded[j] = 0;
		749	cw_len = chctx->CWlengthT[j];
		750
		751	if (cw_len <= 0 \|\| chctx->skipFlags[j])
		752	continue;
		753
		754	max_size = 1 << cw_len;
		755	middle_value = max_size >> 1;
		756
		757	if (chctx->codewords[j] >= max_size \|\| chctx->codewords[j] < 0)
		758	return AVERROR_INVALIDDATA;
		759
		760	if (cw_len >= 4) {
		761	quantizer = imc_quantizer2[(stream_format_code & 2) >> 1];
		762	if (chctx->codewords[j] >= middle_value)
		763	chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 8] * chctx->flcoeffs6[i];
		764	else
		765	chctx->CWdecoded[j] = -quantizer[max_size - chctx->codewords[j] - 8 - 1] * chctx->flcoeffs6[i];
		766	}else{
		767	quantizer = imc_quantizer1[((stream_format_code & 2) >> 1) \| (chctx->bandFlagsBuf[i] << 1)];
		768	if (chctx->codewords[j] >= middle_value)
		769	chctx->CWdecoded[j] = quantizer[chctx->codewords[j] - 1] * chctx->flcoeffs6[i];
		770	else
		771	chctx->CWdecoded[j] = -quantizer[max_size - 2 - chctx->codewords[j]] * chctx->flcoeffs6[i];
		772	}
		773	}
		774	}
		775	return 0;
		776	}
		777
		778
		779	static int imc_get_coeffs(IMCContext q, IMCChannel chctx)
		780	{
		781	int i, j, cw_len, cw;
		782
		783	for (i = 0; i < BANDS; i++) {
		784	if (!chctx->sumLenArr[i])
		785	continue;
		786	if (chctx->bandFlagsBuf[i] \|\| chctx->bandWidthT[i]) {
		787	for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
		788	cw_len = chctx->CWlengthT[j];
		789	cw = 0;
		790
		791	if (get_bits_count(&q->gb) + cw_len > 512) {
		792	av_dlog(NULL, "Band %i coeff %i cw_len %i\n", i, j, cw_len);
		793	return AVERROR_INVALIDDATA;
		794	}
		795
		796	if (cw_len && (!chctx->bandFlagsBuf[i] \|\| !chctx->skipFlags[j]))
		797	cw = get_bits(&q->gb, cw_len);
		798
		799	chctx->codewords[j] = cw;
		800	}
		801	}
		802	}
		803	return 0;
		804	}
		805
		806	static void imc_refine_bit_allocation(IMCContext q, IMCChannel chctx)
		807	{
		808	int i, j;
		809	int bits, summer;
		810
		811	for (i = 0; i < BANDS; i++) {
		812	chctx->sumLenArr[i] = 0;
		813	chctx->skipFlagRaw[i] = 0;
		814	for (j = band_tab[i]; j < band_tab[i + 1]; j++)
		815	chctx->sumLenArr[i] += chctx->CWlengthT[j];
		816	if (chctx->bandFlagsBuf[i])
		817	if ((((band_tab[i + 1] - band_tab[i]) * 1.5) > chctx->sumLenArr[i]) && (chctx->sumLenArr[i] > 0))
		818	chctx->skipFlagRaw[i] = 1;
		819	}
		820
		821	imc_get_skip_coeff(q, chctx);
		822
		823	for (i = 0; i < BANDS; i++) {
		824	chctx->flcoeffs6[i] = chctx->flcoeffs1[i];
		825	/* band has flag set and at least one coded coefficient */
		826	if (chctx->bandFlagsBuf[i] && (band_tab[i + 1] - band_tab[i]) != chctx->skipFlagCount[i]) {
		827	chctx->flcoeffs6[i] *= q->sqrt_tab[ band_tab[i + 1] - band_tab[i]] /
		828	q->sqrt_tab[(band_tab[i + 1] - band_tab[i] - chctx->skipFlagCount[i])];
		829	}
		830	}
		831
		832	/* calculate bits left, bits needed and adjust bit allocation */
		833	bits = summer = 0;
		834
		835	for (i = 0; i < BANDS; i++) {
		836	if (chctx->bandFlagsBuf[i]) {
		837	for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
		838	if (chctx->skipFlags[j]) {
		839	summer += chctx->CWlengthT[j];
		840	chctx->CWlengthT[j] = 0;
		841	}
		842	}
		843	bits += chctx->skipFlagBits[i];
		844	summer -= chctx->skipFlagBits[i];
		845	}
		846	}
		847	imc_adjust_bit_allocation(q, chctx, summer);
		848	}
		849
		850	static int imc_decode_block(AVCodecContext avctx, IMCContext q, int ch)
		851	{
		852	int stream_format_code;
		853	int imc_hdr, i, j, ret;
		854	int flag;
		855	int bits;
		856	int counter, bitscount;
		857	IMCChannel *chctx = q->chctx + ch;
		858
		859
		860	/* Check the frame header */
		861	imc_hdr = get_bits(&q->gb, 9);
		862	if (imc_hdr & 0x18) {
		863	av_log(avctx, AV_LOG_ERROR, "frame header check failed!\n");
		864	av_log(avctx, AV_LOG_ERROR, "got %X.\n", imc_hdr);
		865	return AVERROR_INVALIDDATA;
		866	}
		867	stream_format_code = get_bits(&q->gb, 3);
		868
		869	if (stream_format_code & 0x04)
		870	chctx->decoder_reset = 1;
		871
		872	if (chctx->decoder_reset) {
		873	for (i = 0; i < BANDS; i++)
		874	chctx->old_floor[i] = 1.0;
		875	for (i = 0; i < COEFFS; i++)
		876	chctx->CWdecoded[i] = 0;
		877	chctx->decoder_reset = 0;
		878	}
		879
		880	flag = get_bits1(&q->gb);
		881	if (stream_format_code & 0x1)
		882	imc_decode_level_coefficients_raw(q, chctx->levlCoeffBuf,
		883	chctx->flcoeffs1, chctx->flcoeffs2);
		884	else if (stream_format_code & 0x1)
		885	imc_read_level_coeffs_raw(q, stream_format_code, chctx->levlCoeffBuf);
		886	else
		887	imc_read_level_coeffs(q, stream_format_code, chctx->levlCoeffBuf);
		888
		889	if (stream_format_code & 0x4)
		890	imc_decode_level_coefficients(q, chctx->levlCoeffBuf,
		891	chctx->flcoeffs1, chctx->flcoeffs2);
		892	else
		893	imc_decode_level_coefficients2(q, chctx->levlCoeffBuf, chctx->old_floor,
		894	chctx->flcoeffs1, chctx->flcoeffs2);
		895
		896	for(i=0; i
		897	if(chctx->flcoeffs1[i] > INT_MAX) {
		898	av_log(avctx, AV_LOG_ERROR, "scalefactor out of range\n");
		899	return AVERROR_INVALIDDATA;
		900	}
		901	}
		902
		903	memcpy(chctx->old_floor, chctx->flcoeffs1, 32 * sizeof(float));
		904
		905	counter = 0;
		906	if (stream_format_code & 0x1) {
		907	for (i = 0; i < BANDS; i++) {
		908	chctx->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
		909	chctx->bandFlagsBuf[i] = 0;
		910	chctx->flcoeffs3[i] = chctx->flcoeffs2[i] * 2;
		911	chctx->flcoeffs5[i] = 1.0;
		912	}
		913	} else {
		914	for (i = 0; i < BANDS; i++) {
		915	if (chctx->levlCoeffBuf[i] == 16) {
		916	chctx->bandWidthT[i] = 0;
		917	counter++;
		918	} else
		919	chctx->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
		920	}
		921
		922	memset(chctx->bandFlagsBuf, 0, BANDS * sizeof(int));
		923	for (i = 0; i < BANDS - 1; i++)
		924	if (chctx->bandWidthT[i])
		925	chctx->bandFlagsBuf[i] = get_bits1(&q->gb);
		926
		927	imc_calculate_coeffs(q, chctx->flcoeffs1, chctx->flcoeffs2,
		928	chctx->bandWidthT, chctx->flcoeffs3,
		929	chctx->flcoeffs5);
		930	}
		931
		932	bitscount = 0;
		933	/* first 4 bands will be assigned 5 bits per coefficient */
		934	if (stream_format_code & 0x2) {
		935	bitscount += 15;
		936
		937	chctx->bitsBandT[0] = 5;
		938	chctx->CWlengthT[0] = 5;
		939	chctx->CWlengthT[1] = 5;
		940	chctx->CWlengthT[2] = 5;
		941	for (i = 1; i < 4; i++) {
		942	if (stream_format_code & 0x1)
		943	bits = 5;
		944	else
		945	bits = (chctx->levlCoeffBuf[i] == 16) ? 0 : 5;
		946	chctx->bitsBandT[i] = bits;
		947	for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
		948	chctx->CWlengthT[j] = bits;
		949	bitscount += bits;
		950	}
		951	}
		952	}
		953	if (avctx->codec_id == AV_CODEC_ID_IAC) {
		954	bitscount += !!chctx->bandWidthT[BANDS - 1];
		955	if (!(stream_format_code & 0x2))
		956	bitscount += 16;
		957	}
		958
		959	if ((ret = bit_allocation(q, chctx, stream_format_code,
		960	512 - bitscount - get_bits_count(&q->gb),
		961	flag)) < 0) {
		962	av_log(avctx, AV_LOG_ERROR, "Bit allocations failed\n");
		963	chctx->decoder_reset = 1;
		964	return ret;
		965	}
		966
		967	if (stream_format_code & 0x1) {
		968	for (i = 0; i < BANDS; i++)
		969	chctx->skipFlags[i] = 0;
		970	} else {
		971	imc_refine_bit_allocation(q, chctx);
		972	}
		973
		974	for (i = 0; i < BANDS; i++) {
		975	chctx->sumLenArr[i] = 0;
		976
		977	for (j = band_tab[i]; j < band_tab[i + 1]; j++)
		978	if (!chctx->skipFlags[j])
		979	chctx->sumLenArr[i] += chctx->CWlengthT[j];
		980	}
		981
		982	memset(chctx->codewords, 0, sizeof(chctx->codewords));
		983
		984	if (imc_get_coeffs(q, chctx) < 0) {
		985	av_log(avctx, AV_LOG_ERROR, "Read coefficients failed\n");
		986	chctx->decoder_reset = 1;
		987	return AVERROR_INVALIDDATA;
		988	}
		989
		990	if (inverse_quant_coeff(q, chctx, stream_format_code) < 0) {
		991	av_log(avctx, AV_LOG_ERROR, "Inverse quantization of coefficients failed\n");
		992	chctx->decoder_reset = 1;
		993	return AVERROR_INVALIDDATA;
		994	}
		995
		996	memset(chctx->skipFlags, 0, sizeof(chctx->skipFlags));
		997
		998	imc_imdct256(q, chctx, avctx->channels);
		999
		1000	return 0;
		1001	}
		1002
		1003	static int imc_decode_frame(AVCodecContext avctx, void data,
		1004	int got_frame_ptr, AVPacket avpkt)
		1005	{
		1006	AVFrame *frame = data;
		1007	const uint8_t *buf = avpkt->data;
		1008	int buf_size = avpkt->size;
		1009	int ret, i;
		1010
		1011	IMCContext *q = avctx->priv_data;
		1012
		1013	LOCAL_ALIGNED_16(uint16_t, buf16, [IMC_BLOCK_SIZE / 2]);
		1014
		1015	if (buf_size < IMC_BLOCK_SIZE * avctx->channels) {
		1016	av_log(avctx, AV_LOG_ERROR, "frame too small!\n");
		1017	return AVERROR_INVALIDDATA;
		1018	}
		1019
		1020	/* get output buffer */
		1021	frame->nb_samples = COEFFS;
		1022	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
		1023	return ret;
		1024
		1025	for (i = 0; i < avctx->channels; i++) {
		1026	q->out_samples = (float *)frame->extended_data[i];
		1027
		1028	q->dsp.bswap16_buf(buf16, (const uint16_t*)buf, IMC_BLOCK_SIZE / 2);
		1029
		1030	init_get_bits(&q->gb, (const uint8_t)buf16, IMC_BLOCK_SIZE 8);
		1031
		1032	buf += IMC_BLOCK_SIZE;
		1033
		1034	if ((ret = imc_decode_block(avctx, q, i)) < 0)
		1035	return ret;
		1036	}
		1037
		1038	if (avctx->channels == 2) {
		1039	q->fdsp.butterflies_float((float *)frame->extended_data[0],
		1040	(float *)frame->extended_data[1], COEFFS);
		1041	}
		1042
		1043	*got_frame_ptr = 1;
		1044
		1045	return IMC_BLOCK_SIZE * avctx->channels;
		1046	}
		1047
		1048
		1049	static av_cold int imc_decode_close(AVCodecContext * avctx)
		1050	{
		1051	IMCContext *q = avctx->priv_data;
		1052
		1053	ff_fft_end(&q->fft);
		1054
		1055	return 0;
		1056	}
		1057
		1058	static av_cold void flush(AVCodecContext *avctx)
		1059	{
		1060	IMCContext *q = avctx->priv_data;
		1061
		1062	q->chctx[0].decoder_reset =
		1063	q->chctx[1].decoder_reset = 1;
		1064	}
		1065
		1066	#if CONFIG_IMC_DECODER
		1067	AVCodec ff_imc_decoder = {
		1068	.name = "imc",
		1069	.long_name = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
		1070	.type = AVMEDIA_TYPE_AUDIO,
		1071	.id = AV_CODEC_ID_IMC,
		1072	.priv_data_size = sizeof(IMCContext),
		1073	.init = imc_decode_init,
		1074	.close = imc_decode_close,
		1075	.decode = imc_decode_frame,
		1076	.flush = flush,
		1077	.capabilities = CODEC_CAP_DR1,
		1078	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
		1079	AV_SAMPLE_FMT_NONE },
		1080	};
		1081	#endif
		1082	#if CONFIG_IAC_DECODER
		1083	AVCodec ff_iac_decoder = {
		1084	.name = "iac",
		1085	.long_name = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
		1086	.type = AVMEDIA_TYPE_AUDIO,
		1087	.id = AV_CODEC_ID_IAC,
		1088	.priv_data_size = sizeof(IMCContext),
		1089	.init = imc_decode_init,
		1090	.close = imc_decode_close,
		1091	.decode = imc_decode_frame,
		1092	.flush = flush,
		1093	.capabilities = CODEC_CAP_DR1,
		1094	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
		1095	AV_SAMPLE_FMT_NONE },
		1096	};
		1097	#endif

Subversion Repositories Kolibri OS

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