block.c

jpeg and mpeg 编解码技术源代码

#include <math.h>
#include "dolby_def.h"
#include "dolby_win.h"

#ifndef PI
#define PI                   3.14159265359
#endif


static Float	fhg_long [NWINLONG];
static Float	fhg_short [NWINSHORT];
static Float	fhg_edler [NWINLONG];
static Float	dol_edler [NWINLONG];
static Float	fhg_adv [NWINADV];
static Float	dol_adv [NWINADV];

static Float *windowPtr [N_WINDOW_TYPES] [N_WINDOW_SHAPES] = {
    {fhg_long,	dol_long},
    {fhg_short,	dol_short},
    {fhg_edler,	dol_edler},
    {fhg_adv,	dol_adv}
};	


static int		windowLeng [N_WINDOW_TYPES] = {
	1024, //sizeof(fhg_long)/sizeof(Float),	
	128, //sizeof(fhg_short)/sizeof(Float),	
	1024, //sizeof(fhg_edler)/sizeof(Float),	
	1024 //sizeof(fhg_adv)/sizeof(Float)
};



/*****************************************************************************
*
*	InitBlock
*	calculate windows for use by Window()
*	input: none
*	output: none
*	local static: none
*	globals: shortWindow[], longWindow[]
*
*****************************************************************************/
void InitBlock (void) {

	/* calc half-window data */

    static int             i, j;
    register float	phaseInc;

	/* init half-windows */

	/* FhG long window */
    phaseInc = PI / (2.0 * NWINLONG);
    for (i = 0; i < NWINLONG; i++) {
		fhg_long [i]  = sin(phaseInc * (i + 0.5));
	}

	/* FhG short window */
    phaseInc = PI / (2.0 * NWINSHORT);
    for (i = 0; i < NWINSHORT; i++) {
		fhg_short [i] = sin(phaseInc * (i + 0.5));
	}

	/* Edler windows */
    for (i = 0, j = 0; i < NFLAT; i++, j++) {
		fhg_edler[j] = 0.0;
		dol_edler[j] = 0.0;
	}
    for (i = 0; i < NWINSHORT; i++, j++) {
		fhg_edler [j] = fhg_short [i];
		dol_edler [j] = dol_short [i];
	}
    for ( ; j < NWINFLAT; j++) {
		fhg_edler [j] = 1.0;
		dol_edler [j] = 1.0;
	}

	/* Advanced Edler windows */
    for (i = 0, j = 0; i < NADV0; i++, j++) {
		fhg_adv [j] = 0.0;
		dol_adv [j] = 0.0;
	}
    for (i = 0; i < NWINSHORT; i++, j++) {
		fhg_adv[j] = fhg_short[i];
		dol_adv[j] = dol_short[i];
	}
    for ( ; j < NWINADV; j++) {
		fhg_adv[j] = 1.0;
		dol_adv[j] = 1.0;
	}
}


/*****************************************************************************
*
*	Window
*	window input sequence based on window type
*	input: see below
*	output: see below
*	local static:
*	  firstTime				flag = need to initialize data structures
*	globals: shortWindow[], longWindow[]
*
*****************************************************************************/

void ITransformBlock (
	Float* dataPtr,				/* vector to be windowed in place	*/
	BLOCK_TYPE bT,				/* input: window type				*/
	Wnd_Shape *wnd_shape,
	Float *state				/* input/output						*/
	)
{
    static int	firstTime = 1;
	int leng0, leng1;
    int			i,leng;
    Float		*windPtr;
    WINDOW_TYPE	beginWT, endWT;

    if (firstTime)  {
		InitBlock();			/*	calculate windows	*/
		firstTime = 0;
	}

    if((bT==LONG_BLOCK) || (bT==START_FLAT_BLOCK)) {
		beginWT = WT_LONG;
	} else if(bT==STOP_FLAT_BLOCK) {
		beginWT = WT_FLAT;
	} else
		beginWT = WT_SHORT;

    if ((bT == LONG_BLOCK) || (bT == STOP_FLAT_BLOCK)) {
		endWT = WT_LONG;
	} else if (bT == START_FLAT_BLOCK)  {
		endWT = WT_FLAT;
	} else
		endWT = WT_SHORT;

    leng0 = windowLeng [beginWT];
    leng1 = windowLeng [endWT];

//	ITransform (dataPtr, leng0 + leng1, leng1);
//	MDCT (dataPtr, leng0 + leng1, leng1);
	IMDCT (dataPtr, leng0 + leng1);

	/*	first half of window */
	/*     windPtr = windowPtr [0] [0];  */
	windPtr = windowPtr [beginWT] [wnd_shape->prev_bk];  


    for (i = 0; i < windowLeng [beginWT]; i++)  {
		*dataPtr++ *= *windPtr++;
	}

	/*	second half of window */
    leng = windowLeng [endWT];
    windPtr = windowPtr [endWT] [wnd_shape->this_bk] + leng - 1;
    for (i = 0; i < leng; i++) {
		*dataPtr++ *= *windPtr--;
	}

	wnd_shape->prev_bk = wnd_shape->this_bk;
}