mpegimdc.c

arm9开发板上的例子,可以学习一下有简单的c程序

/****************************************************************************/

/*
 *	mpegimdc.c -- MPEG Audio IMDCT hybrid filter
 *
 *	Author  :   St閜hane TAVENARD
 *
 *	(C) Copyright 1997-1999 St閜hane TAVENARD
 *	    All Rights Reserved
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2 of the License, or
 *	(at your option) any later version.
 *	
 *	This program is distributed in the hope that it will be useful,
 *	but WITHOUT ANY WARRANTY; without even the implied warranty of
 *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *	GNU General Public License for more details.
 *	
 *	You should have received a copy of the GNU General Public License
 *	along with this program; if not, write to the Free Software
 *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/****************************************************************************/

#include "defs.h"
#include "mpegaud.h"
#include "mpegimdc.h"
#include <math.h>

#include "imdct.h"
#define IMDCT_INT


/****************************************************************************/
#ifdef IMDCT_INT
#define IMDCT_IO_TYPE	MPEGAUD_FRACT_TYPE
#define IMDCT_TYPE	INT32
#define IMDCT_BITS	14
#define WIN_TYPE	INT16
#define WIN_BITS	14
#define WIN_MULT(t, w)	(((t) * (w))>>WIN_BITS)
#else
#endif

/****************************************************************************/

static int imdct_l(IMDCT_IO_TYPE *x, IMDCT_IO_TYPE *out,
	MPEGIMDCT_BLOCK_TYPE *prev, WIN_TYPE *win)
{
	static const IMDCT_TYPE K0 = 0.9990482216 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K1 = 0.9914448614 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K2 = 0.9762960071 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K3 = 0.9537169507 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K4 = 0.9238795325 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K5 = 0.8870108332 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K6 = 0.8433914458 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K7 = 0.7933533403 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K8 = 0.7372773368 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K9 = 0.6755902076 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K10 = 0.6087614290 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K11 = 0.5372996083 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K12 = 0.4617486132 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K13 = 0.3826834324 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K14 = 0.3007057995 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K15 = 0.2164396139 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K16 = 0.1305261922 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K17 = 0.04361938737 * (1 << IMDCT_BITS);

	IMDCT_TYPE k1, k2;
	IMDCT_TYPE temp;
	INT16 i;
#if 1
	IMDCT_TYPE s[6];
	IMDCT_TYPE t[6];
#else
	DECLARE_BUF_IMDCT(s, 6);
	DECLARE_BUF_IMDCT(t, 6);
	
	SRAM_BUF_IMDCT(s, 6);
	SRAM_BUF_IMDCT(t, 6);
#endif

#ifdef IMDCT_INT
#define S(a)		(INT32)x[a] - (INT32)x[11-a] - (INT32)x[12+a]
#define M(xi, Kx)	(x[xi] * (Kx))
#define MT(ti, Kx)	(t[ti] * (Kx))
#define W(t, wi)	WIN_MULT((t>>IMDCT_BITS), win[wi])
#else
#endif

#define O(i)	out[i*32]

	k1 = M(4, K13) - M(13, K4);
	k2 = M(4, K4) + M(13, K13);

	s[0] = -M(1, K7) + k1 + M(7, K1) + M(10, K16) - M(16, K10);
	s[1] = -M(1, K4) - k1 + M(7, K13) + M(10, K4) + M(16, K13);
	s[2] = -M(1, K1) - k2 - M(7, K7) - M(10, K10) - M(16, K16);

	s[3] = -M(1, K10) + k2 + M(7, K16) - M(10, K1) + M(16, K7);
	s[4] = -M(1, K13) + k2 - M(7, K4) + M(10, K13) - M(16, K4);
	s[5] = -M(1, K16) + k1 - M(7, K10) + M(10, K7) + M(16, K1);

	t[0] = S(0);
	t[1] = S(2);
	t[2] = S(3);
	t[3] = S(5);

	temp = M(0, K9) - M(2, K11) + M(3, K5) - M(5, K3) - M(6, K15) +
		M(8, K17) - M(9, K0) + M(11, K2) - M(12, K14) + M(14, K12) +
		M(15, K6) - M(17, K8);
	temp += s[0];
	O(0) = prev[0] + W(temp, 0);
	O(17) = prev[17] - W(temp, 17);
	temp = MT(0, K10) - MT(1, K16) + MT(2, K1) - MT(3, K7) + s[1];
	O(1) = prev[1] + W(temp, 1);
	O(16) = prev[16] - W(temp, 16);
	temp = M(0, K11) + M(2, K14) + M(3, K8) + M(5, K17) + M(6, K5) -
		M(8, K15) + M(9, K2) - M(11, K12) + M(12, K0) - M(14, K9) +
		M(15, K3) - M(17, K6);
	temp += s[2];
	O(2) = prev[2] + W(temp, 2);
	O(15) = prev[15] - W(temp, 15);
	temp = M(0, K12) + M(2, K9) + M(3, K15) + M(5, K6) - M(6, K17) +
		M(8, K3) - M(9, K14) + M(11, K0) - M(12, K11) + M(14, K2) -
		M(15, K8) + M(17, K5);
	temp += s[2];
	O(3) = prev[3] + W(temp, 3);
	O(14) = prev[14] - W(temp, 14);
	temp = MT(0, K13) + MT(1, K4) - MT(2, K13) + MT(3, K4) + s[1];
	O(4) = prev[4] + W(temp, 4);
	O(13) = prev[13] - W(temp, 13);
	temp = M(0, K14) + M(2, K0) - M(3, K6) + M(5, K15) - M(6, K8) -
		M(8, K5) + M(9, K12) - M(11, K9) + M(12, K2) + M(14, K11) +
		M(15, K17) + M(17, K3);
	temp += s[0];
	O(5) = prev[5] + W(temp, 5);
	O(12) = prev[12] - W(temp, 12);
	temp = M(0, K15) + M(2, K5) - M(3, K0) - M(5, K9) + M(6, K14) -
		M(8, K11) + M(9, K6) + M(11, K3) - M(12, K8) + M(14, K17) -
		M(15, K12) - M(17, K2);
	temp += s[3];
	O(6) = prev[6] + W(temp, 6);
	O(11) = prev[11] - W(temp, 11);
	temp = MT(0, K16) + MT(1, K10) - MT(2, K7) - MT(3, K1) + s[4];
	O(7) = prev[7] + W(temp, 7);
	O(10) = prev[10] - W(temp, 10);
	temp = M(0, K17) + M(2, K15) - M(3, K14) - M(5, K12) + M(6, K11) +
		M(8, K9) - M(9, K8) - M(11, K6) + M(12, K5) + M(14, K3) -
		M(15, K2) - M(17, K0);
	temp += s[5];
	O(8) = prev[8] + W(temp, 8);
	O(9) = prev[9] - W(temp, 9);

	temp = -M(0, K8) + M(2, K6) - M(3, K12) + M(5, K14) + M(6, K2) -
		M(8, K0) - M(9, K17) + M(11, K15) - M(12, K3) + M(14, K5) +
		M(15, K11) - M(17, K9);
	temp -= s[3];
	prev[0] = W(temp, 18);
	prev[17] = W(temp, 35);
	temp = -MT(0, K7) + MT(1, K1) + MT(2, K16) - MT(3, K10) - s[4];
	prev[1] = W(temp, 19);
	prev[16] = W(temp, 34);
	temp = -M(0, K6) + M(2, K3) + M(3, K9) - M(5, K0) - M(6, K12) +
		M(8, K2) + M(9, K15) - M(11, K5) + M(12, K17) + M(14, K8) -
		M(15, K14) - M(17, K11);
	temp -= s[5];
	prev[2] = W(temp, 20);
	prev[15] = W(temp, 33);
	temp = -M(0, K5) + M(2, K8) + M(3, K2) - M(5, K11) - M(6, K0) +
		M(8, K14) + M(9, K3) - M(11, K17) - M(12, K6) - M(14, K15) +
		M(15, K9) + M(17, K12);
	temp += s[5];
	prev[3] = W(temp, 21);
	prev[14] = W(temp, 32);
	temp = -MT(0, K4) + MT(1, K13) + MT(2, K4) + MT(3, K13) + s[4];
	prev[4] = W(temp, 22);
	prev[13] = W(temp, 31);
	temp = -M(0, K3) - M(2, K17) + M(3, K11) + M(5, K2) + M(6, K9) -
		M(8, K12) - M(9, K5) - M(11, K8) - M(12, K15) + M(14, K6) +
		M(15, K0) + M(17, K14);
	temp += s[3];
	prev[5] = W(temp, 23);
	prev[12] = W(temp, 30);
	temp = -M(0, K2) - M(2, K12) - M(3, K17) + M(5, K8) + M(6, K3) +
		M(8, K6) + M(9, K11) - M(11, K14) - M(12, K9) - M(14, K0) -
		M(15, K5) - M(17, K15);
	temp += s[0];
	prev[6] = W(temp, 24);
	prev[11] = W(temp, 29);
	temp = -MT(0, K1) - MT(1, K7) - MT(2, K10) - MT(3, K16) + s[1];
	prev[7] = W(temp, 25);
	prev[10] = W(temp, 28);
	temp = -M(0, K0) - M(2, K2) - M(3, K3) - M(5, K5) - M(6, K6) -
		M(8, K8) - M(9, K9) - M(11, K11) - M(12, K12) - M(14, K14) -
		M(15, K15) - M(17, K17);
	temp += s[2];
	prev[8] = W(temp, 26);
	prev[9] = W(temp, 27);

	return(0);
}

#undef O
#undef set_k
#undef S
#undef W
#undef MT
#undef M

/****************************************************************************/

static int imdct_s(IMDCT_IO_TYPE *x, IMDCT_IO_TYPE *out,
	MPEGIMDCT_BLOCK_TYPE *prev, WIN_TYPE *win)
{
	static const IMDCT_TYPE K0 = 0.9914448614 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K1 = 0.9238795325 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K2 = 0.7933533403 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K3 = 0.6087614290 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K4 = 0.3826834324 * (1 << IMDCT_BITS);
	static const IMDCT_TYPE K5 = 0.1305261922 * (1 << IMDCT_BITS);

	IMDCT_TYPE temp;
	INT16 i;
#if 1
	IMDCT_TYPE s[2];
	IMDCT_TYPE t[2];
#else
	DECLARE_BUF_IMDCT(s, 2);
	DECLARE_BUF_IMDCT(t, 2);

	SRAM_BUF_IMDCT(s, 2);
	SRAM_BUF_IMDCT(t, 2);
#endif
#ifdef IMDCT_INT
#define M(xi, Kx)	((INT32)x[(xi*3)] * (Kx))
#define MT(ti, Kx)	(t[ti] * (Kx))
#define W(t, wi)	WIN_MULT((t>>IMDCT_BITS), win[wi])
#else
#endif
#define O(i)	out[i*32]

	// Step 1
	O(0) = prev[0];
	O(1) = prev[1];
	O(2) = prev[2];
	O(3) = prev[3];
	O(4) = prev[4];
	O(5) = prev[5];

	s[0] = M(1, K1) + M(4, K4);
	s[1] = M(1, K4) - M(4, K1);

	t[0] = x[0 * 3] - x[3 * 3];
	t[1] = x[2 * 3] + x[5 * 3];
	// 0
	temp = M(0, K3) - M(2, K5) + M(3, K0) - M(5, K2) - s[0];
	O(6) = prev[6] + W(temp, 0);
	O(11) = prev[11] - W(temp, 5);
	// 1
	temp = MT(0, K4) + MT(1, K1) - s[0];
	O(7) = prev[7] + W(temp, 1);
	O(10) = prev[10] - W(temp, 4);
	// 2
	temp = M(0, K5) + M(2, K3) - M(3, K2) - M(5, K0) - s[1];
	O(8) = prev[8] + W(temp, 2);
	O(9) = prev[9] - W(temp, 3);
	// 3

	// 3+3
	temp = -M(0, K2) + M(2, K0) + M(3, K5) - M(5, K3) + s[1];
	O(12) = W(temp, 6);
	O(17) = W(temp, 11);
	// 4+3
	temp = -MT(0, K1) + MT(1, K4) - s[1];
	O(13) = W(temp, 7);
	O(16) = W(temp, 10);
	// 5+3
	temp = -M(0, K0) - M(2, K2) - M(3, K3) - M(5, K5) - s[0];
	O(14) = W(temp, 8);
	O(15) = W(temp, 9);

	// Step 2
	x++;

	s[0] = M(1, K1) + M(4, K4);
	s[1] = M(1, K4) - M(4, K1);

	t[0] = x[0 * 3] - x[3 * 3];
	t[1] = x[2 * 3] + x[5 * 3];
	// 0
	temp = M(0, K3) - M(2, K5) + M(3, K0) - M(5, K2) - s[0];
	O(12) += W(temp, 0);
	O(17) += -W(temp, 5);
	// 1
	temp = MT(0, K4) + MT(1, K1) - s[0];
	O(13) += W(temp, 1);
	O(16) += -W(temp, 4);
	// 2
	temp = M(0, K5) + M(2, K3) - M(3, K2) - M(5, K0) - s[1];
	O(14) += W(temp, 2);
	O(15) += -W(temp, 3);
	// 3

	// 3+3
	temp = -M(0, K2) + M(2, K0) + M(3, K5) - M(5, K3) + s[1];
	prev[0] = W(temp, 6);
	prev[5] = W(temp, 11);
	// 4+3
	temp = -MT(0, K1) + MT(1, K4) - s[1];
	prev[1] = W(temp, 7);
	prev[4] = W(temp, 10);
	// 5+3
	temp = -M(0, K0) - M(2, K2) - M(3, K3) - M(5, K5) - s[0];
	prev[2] = W(temp, 8);
	prev[3] = W(temp, 9);

	// Step 3
	x++;

	s[0] = M(1, K1) + M(4, K4);
	s[1] = M(1, K4) - M(4, K1);

	t[0] = x[0 * 3] - x[3 * 3];
	t[1] = x[2 * 3] + x[5 * 3];
	// 0
	temp = M(0, K3) - M(2, K5) + M(3, K0) - M(5, K2) - s[0];
	prev[0] += W(temp, 0);
	prev[5] += -W(temp, 5);
	// 1
	temp = MT(0, K4) + MT(1, K1) - s[0];
	prev[1] += W(temp, 1);
	prev[4] += -W(temp, 4);
	// 2
	temp = M(0, K5) + M(2, K3) - M(3, K2) - M(5, K0) - s[1];
	prev[2] += W(temp, 2);
	prev[3] += -W(temp, 3);
	// 3

	// 3+3
	temp = -M(0, K2) + M(2, K0) + M(3, K5) - M(5, K3) + s[1];
	prev[6] = W(temp, 6);
	prev[11] = W(temp, 11);
	// 4+3
	temp = -MT(0, K1) + MT(1, K4) - s[1];
	prev[7] = W(temp, 7);
	prev[10] = W(temp, 10);
	// 5+3
	temp = -M(0, K0) - M(2, K2) - M(3, K3) - M(5, K5) - s[0];
	prev[8] = W(temp, 8);
	prev[9] = W(temp, 9);

	prev[12] = prev[13] = prev[14] = prev[15] = prev[16] = prev[17] = 0;

	return(0);
}

#undef O
#undef set_k
#undef W
#undef MT
#undef M

/****************************************************************************/

/*
 *	Apply the hybrid imdct to a granule
 *	Return 0 if Ok
 */

int MPEGIMDCT_hybrid(MPEGIMDCT *mpegimdct, MPEGAUD_FRACT_TYPE *in,
	MPEGAUD_FRACT_TYPE *out, INT16 block_type,
	BOOL mixed, INT16 ch, INT16 sb_max)
{
//#ifdef ASM_OPTIMIZE
#if 0
	PDEBUG_ONCE("asm implemented IMDC.\n");
	MPEGIMDA_hybrid( in, out, mpegimdct->prevblk[ ch ], block_type, mixed, sb_max );
	return 0;
#else

	static BOOL init = FALSE;
	register MPEGIMDCT_BLOCK_TYPE *prev;
	INT16 sb;
	INT16 bt;

	PDEBUG_ONCE("C implemented IMDC.\n");
	if (!init) {
		INT16 i, j;

		init = TRUE;
	}

#define O(i)	out[i*32]

	prev = mpegimdct->prevblk[ch];
	for (sb = 0; sb < sb_max; sb++) {
		bt = ((mixed) && (sb < 2)) ? 0 : block_type;

		if (bt == 2)
			imdct_s(in, out, prev, &win[sb & 1][bt][0]);
		else
			imdct_l(in, out, prev, &win[sb & 1][bt][0]);

		in += 18;
		out++;
		prev += 18;
	}

	for (; sb < MPA_SBLIMIT; sb++) {
		// overlap addition with 0
		O(0) = *prev;
		*prev++ = 0;
		O(1) = *prev;
		*prev++ = 0;
		O(2) = *prev;
		*prev++ = 0;
		O(3) = *prev;
		*prev++ = 0;
		O(4) = *prev;
		*prev++ = 0;
		O(5) = *prev;
		*prev++ = 0;
		O(6) = *prev;
		*prev++ = 0;
		O(7) = *prev;
		*prev++ = 0;
		O(8) = *prev;
		*prev++ = 0;
		O(9) = *prev;
		*prev++ = 0;
		O(10) = *prev;
		*prev++ = 0;
		O(11) = *prev;
		*prev++ = 0;
		O(12) = *prev;
		*prev++ = 0;
		O(13) = *prev;
		*prev++ = 0;
		O(14) = *prev;
		*prev++ = 0;
		O(15) = *prev;
		*prev++ = 0;
		O(16) = *prev;
		*prev++ = 0;
		O(17) = *prev;
		*prev++ = 0;
		out++;
	}

	return(0);
#endif
}


/****************************************************************************/

/*
 *	Reset the MPEGIMDCT module
 */

int MPEGIMDCT_reset(MPEGIMDCT *mpegimdct)
{
	if (!mpegimdct)
		return(-1);

	// Reset previous block buffer
	memset(mpegimdct->prevblk, 0, MPA_MAX_CHANNELS * MPA_GRANULE_SIZE *
	       sizeof(MPEGIMDCT_BLOCK_TYPE));

	return(0);
}

/****************************************************************************/

/*
 *	Close the MPEGIMDCT module
 */

void MPEGIMDCT_close(MPEGIMDCT *mpegimdct)
{
	if (!mpegimdct)
		return;
	ffree(mpegimdct);
}

/****************************************************************************/

/*
 *	Open the MPEGIMDCT module
 */

MPEGIMDCT *MPEGIMDCT_open(void)
{
	MPEGIMDCT *mpegimdct;

	mpegimdct = (MPEGIMDCT *) fmalloc(sizeof(MPEGIMDCT));
	if (!mpegimdct)
		return(NULL);
	MPEGIMDCT_reset(mpegimdct);

	return(mpegimdct);
}

/****************************************************************************/