/*
 ** Copyright 2003-2010, VisualOn, Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
/*******************************************************************************
	File:		transform.c

	Content:	MDCT Transform functionss

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

#include "basic_op.h"
#include "psy_const.h"
#include "transform.h"
#include "aac_rom.h"


#define LS_TRANS ((FRAME_LEN_LONG-FRAME_LEN_SHORT)/2) /* 448 */
#define SQRT1_2 0x5a82799a	/* sqrt(1/2) in Q31 */
#define swap2(p0,p1) \
	t = p0; t1 = *(&(p0)+1);	\
	(p0) = p1; *(&(p0)+1) = *(&(p1)+1);	\
	(p1) = t; *(&(p1)+1) = t1

/*********************************************************************************
*
* function name: Shuffle
* description:  Shuffle points prepared function for fft
*
**********************************************************************************/
static void Shuffle(int *buf, int num, const unsigned char* bitTab)
{
    int *part0, *part1;
	int i, j;
	int t, t1;

	part0 = buf;
    part1 = buf + num;

	while ((i = *bitTab++) != 0) {
        j = *bitTab++;

        swap2(part0[4*i+0], part0[4*j+0]);
        swap2(part0[4*i+2], part1[4*j+0]);
        swap2(part1[4*i+0], part0[4*j+2]);
        swap2(part1[4*i+2], part1[4*j+2]);
    }

    do {
        swap2(part0[4*i+2], part1[4*i+0]);
    } while ((i = *bitTab++) != 0);
}

#if !defined(ARMV5E) && !defined(ARMV7Neon)

/*****************************************************************************
*
* function name: Radix4First
* description:  Radix 4 point prepared function for fft
*
**********************************************************************************/
static void Radix4First(int *buf, int num)
{
    int r0, r1, r2, r3;
	int r4, r5, r6, r7;

	for (; num != 0; num--)
	{
		r0 = buf[0] + buf[2];
		r1 = buf[1] + buf[3];
		r2 = buf[0] - buf[2];
		r3 = buf[1] - buf[3];
		r4 = buf[4] + buf[6];
		r5 = buf[5] + buf[7];
		r6 = buf[4] - buf[6];
		r7 = buf[5] - buf[7];

		buf[0] = r0 + r4;
		buf[1] = r1 + r5;
		buf[4] = r0 - r4;
		buf[5] = r1 - r5;
		buf[2] = r2 + r7;
		buf[3] = r3 - r6;
		buf[6] = r2 - r7;
		buf[7] = r3 + r6;

		buf += 8;
	}
}

/*****************************************************************************
*
* function name: Radix8First
* description:  Radix 8 point prepared function for fft
*
**********************************************************************************/
static void Radix8First(int *buf, int num)
{
   int r0, r1, r2, r3;
   int i0, i1, i2, i3;
   int r4, r5, r6, r7;
   int i4, i5, i6, i7;
   int t0, t1, t2, t3;

	for ( ; num != 0; num--)
	{
		r0 = buf[0] + buf[2];
		i0 = buf[1] + buf[3];
		r1 = buf[0] - buf[2];
		i1 = buf[1] - buf[3];
		r2 = buf[4] + buf[6];
		i2 = buf[5] + buf[7];
		r3 = buf[4] - buf[6];
		i3 = buf[5] - buf[7];

		r4 = (r0 + r2) >> 1;
		i4 = (i0 + i2) >> 1;
		r5 = (r0 - r2) >> 1;
		i5 = (i0 - i2) >> 1;
		r6 = (r1 - i3) >> 1;
		i6 = (i1 + r3) >> 1;
		r7 = (r1 + i3) >> 1;
		i7 = (i1 - r3) >> 1;

		r0 = buf[ 8] + buf[10];
		i0 = buf[ 9] + buf[11];
		r1 = buf[ 8] - buf[10];
		i1 = buf[ 9] - buf[11];
		r2 = buf[12] + buf[14];
		i2 = buf[13] + buf[15];
		r3 = buf[12] - buf[14];
		i3 = buf[13] - buf[15];

		t0 = (r0 + r2) >> 1;
		t1 = (i0 + i2) >> 1;
		t2 = (r0 - r2) >> 1;
		t3 = (i0 - i2) >> 1;

		buf[ 0] = r4 + t0;
		buf[ 1] = i4 + t1;
		buf[ 8] = r4 - t0;
		buf[ 9] = i4 - t1;
		buf[ 4] = r5 + t3;
		buf[ 5] = i5 - t2;
		buf[12] = r5 - t3;
		buf[13] = i5 + t2;

		r0 = r1 - i3;
		i0 = i1 + r3;
		r2 = r1 + i3;
		i2 = i1 - r3;

		t0 = MULHIGH(SQRT1_2, r0 - i0);
		t1 = MULHIGH(SQRT1_2, r0 + i0);
		t2 = MULHIGH(SQRT1_2, r2 - i2);
		t3 = MULHIGH(SQRT1_2, r2 + i2);

		buf[ 6] = r6 - t0;
		buf[ 7] = i6 - t1;
		buf[14] = r6 + t0;
		buf[15] = i6 + t1;
		buf[ 2] = r7 + t3;
		buf[ 3] = i7 - t2;
		buf[10] = r7 - t3;
		buf[11] = i7 + t2;

		buf += 16;
	}
}

/*****************************************************************************
*
* function name: Radix4FFT
* description:  Radix 4 point fft core function
*
**********************************************************************************/
static void Radix4FFT(int *buf, int num, int bgn, int *twidTab)
{
	int r0, r1, r2, r3;
	int r4, r5, r6, r7;
	int t0, t1;
	int sinx, cosx;
	int i, j, step;
	int *xptr, *csptr;

	for (num >>= 2; num != 0; num >>= 2)
	{
		step = 2*bgn;
		xptr = buf;

    	for (i = num; i != 0; i--)
		{
			csptr = twidTab;

			for (j = bgn; j != 0; j--)
			{
				r0 = xptr[0];
				r1 = xptr[1];
				xptr += step;

				t0 = xptr[0];
				t1 = xptr[1];
				cosx = csptr[0];
				sinx = csptr[1];
				r2 = MULHIGH(cosx, t0) + MULHIGH(sinx, t1);		/* cos*br + sin*bi */
				r3 = MULHIGH(cosx, t1) - MULHIGH(sinx, t0);		/* cos*bi - sin*br */
				xptr += step;

				t0 = r0 >> 2;
				t1 = r1 >> 2;
				r0 = t0 - r2;
				r1 = t1 - r3;
				r2 = t0 + r2;
				r3 = t1 + r3;

				t0 = xptr[0];
				t1 = xptr[1];
				cosx = csptr[2];
				sinx = csptr[3];
				r4 = MULHIGH(cosx, t0) + MULHIGH(sinx, t1);		/* cos*cr + sin*ci */
				r5 = MULHIGH(cosx, t1) - MULHIGH(sinx, t0);		/* cos*ci - sin*cr */
				xptr += step;

				t0 = xptr[0];
				t1 = xptr[1];
				cosx = csptr[4];
				sinx = csptr[5];
				r6 = MULHIGH(cosx, t0) + MULHIGH(sinx, t1);		/* cos*cr + sin*ci */
				r7 = MULHIGH(cosx, t1) - MULHIGH(sinx, t0);		/* cos*ci - sin*cr */
				csptr += 6;

				t0 = r4;
				t1 = r5;
				r4 = t0 + r6;
				r5 = r7 - t1;
				r6 = t0 - r6;
				r7 = r7 + t1;

				xptr[0] = r0 + r5;
				xptr[1] = r1 + r6;
				xptr -= step;

				xptr[0] = r2 - r4;
				xptr[1] = r3 - r7;
				xptr -= step;

				xptr[0] = r0 - r5;
				xptr[1] = r1 - r6;
				xptr -= step;

				xptr[0] = r2 + r4;
				xptr[1] = r3 + r7;
				xptr += 2;
			}
			xptr += 3*step;
		}
		twidTab += 3*step;
		bgn <<= 2;
	}
}

/*********************************************************************************
*
* function name: PreMDCT
* description:  prepare MDCT process for next FFT compute
*
**********************************************************************************/
static void PreMDCT(int *buf0, int num, const int *csptr)
{
	int i;
	int tr1, ti1, tr2, ti2;
	int cosa, sina, cosb, sinb;
	int *buf1;

	buf1 = buf0 + num - 1;

	for(i = num >> 2; i != 0; i--)
	{
		cosa = *csptr++;
		sina = *csptr++;
		cosb = *csptr++;
		sinb = *csptr++;

		tr1 = *(buf0 + 0);
		ti2 = *(buf0 + 1);
		tr2 = *(buf1 - 1);
		ti1 = *(buf1 + 0);

		*buf0++ = MULHIGH(cosa, tr1) + MULHIGH(sina, ti1);
		*buf0++ = MULHIGH(cosa, ti1) - MULHIGH(sina, tr1);

		*buf1-- = MULHIGH(cosb, ti2) - MULHIGH(sinb, tr2);
		*buf1-- = MULHIGH(cosb, tr2) + MULHIGH(sinb, ti2);
	}
}

/*********************************************************************************
*
* function name: PostMDCT
* description:   post MDCT process after next FFT for MDCT
*
**********************************************************************************/
static void PostMDCT(int *buf0, int num, const int *csptr)
{
	int i;
	int tr1, ti1, tr2, ti2;
	int cosa, sina, cosb, sinb;
	int *buf1;

	buf1 = buf0 + num - 1;

	for(i = num >> 2; i != 0; i--)
	{
		cosa = *csptr++;
		sina = *csptr++;
		cosb = *csptr++;
		sinb = *csptr++;

		tr1 = *(buf0 + 0);
		ti1 = *(buf0 + 1);
		ti2 = *(buf1 + 0);
		tr2 = *(buf1 - 1);

		*buf0++ = MULHIGH(cosa, tr1) + MULHIGH(sina, ti1);
		*buf1-- = MULHIGH(sina, tr1) - MULHIGH(cosa, ti1);

		*buf0++ = MULHIGH(sinb, tr2) - MULHIGH(cosb, ti2);
		*buf1-- = MULHIGH(cosb, tr2) + MULHIGH(sinb, ti2);
	}
}
#else
void Radix4First(int *buf, int num);
void Radix8First(int *buf, int num);
void Radix4FFT(int *buf, int num, int bgn, int *twidTab);
void PreMDCT(int *buf0, int num, const int *csptr);
void PostMDCT(int *buf0, int num, const int *csptr);
#endif


/**********************************************************************************
*
* function name: Mdct_Long
* description:  the long block mdct, include long_start block, end_long block
*
**********************************************************************************/
void Mdct_Long(int *buf)
{
	PreMDCT(buf, 1024, cossintab + 128);

	Shuffle(buf, 512, bitrevTab + 17);
	Radix8First(buf, 512 >> 3);
	Radix4FFT(buf, 512 >> 3, 8, (int *)twidTab512);

	PostMDCT(buf, 1024, cossintab + 128);
}


/**********************************************************************************
*
* function name: Mdct_Short
* description:  the short block mdct
*
**********************************************************************************/
void Mdct_Short(int *buf)
{
	PreMDCT(buf, 128, cossintab);

	Shuffle(buf, 64, bitrevTab);
	Radix4First(buf, 64 >> 2);
	Radix4FFT(buf, 64 >> 2, 4, (int *)twidTab64);

	PostMDCT(buf, 128, cossintab);
}


/*****************************************************************************
*
* function name: shiftMdctDelayBuffer
* description:    the mdct delay buffer has a size of 1600,
*  so the calculation of LONG,STOP must be  spilt in two
*  passes with 1024 samples and a mid shift,
*  the SHORT transforms can be completed in the delay buffer,
*  and afterwards a shift
*
**********************************************************************************/
static void shiftMdctDelayBuffer(Word16 *mdctDelayBuffer, /*! start of mdct delay buffer */
								 Word16 *timeSignal,      /*! pointer to new time signal samples, interleaved */
								 Word16 chIncrement       /*! number of channels */
								 )
{
	Word32 i;
	Word16 *srBuf = mdctDelayBuffer;
	Word16 *dsBuf = mdctDelayBuffer+FRAME_LEN_LONG;

	for(i = 0; i < BLOCK_SWITCHING_OFFSET-FRAME_LEN_LONG; i+= 8)
	{
		*srBuf++ = *dsBuf++;	 *srBuf++ = *dsBuf++;
		*srBuf++ = *dsBuf++;	 *srBuf++ = *dsBuf++;
		*srBuf++ = *dsBuf++;	 *srBuf++ = *dsBuf++;
		*srBuf++ = *dsBuf++;	 *srBuf++ = *dsBuf++;
	}

	srBuf = mdctDelayBuffer + BLOCK_SWITCHING_OFFSET-FRAME_LEN_LONG;
	dsBuf = timeSignal;

	for(i=0; i<FRAME_LEN_LONG; i+=8)
	{
		*srBuf++ = *dsBuf; dsBuf += chIncrement;
		*srBuf++ = *dsBuf; dsBuf += chIncrement;
		*srBuf++ = *dsBuf; dsBuf += chIncrement;
		*srBuf++ = *dsBuf; dsBuf += chIncrement;
		*srBuf++ = *dsBuf; dsBuf += chIncrement;
		*srBuf++ = *dsBuf; dsBuf += chIncrement;
		*srBuf++ = *dsBuf; dsBuf += chIncrement;
		*srBuf++ = *dsBuf; dsBuf += chIncrement;
	}
}


/*****************************************************************************
*
* function name: getScalefactorOfShortVectorStride
* description:  Calculate max possible scale factor for input vector of shorts
* returns:      Maximum scale factor
*
**********************************************************************************/
static Word16 getScalefactorOfShortVectorStride(const Word16 *vector, /*!< Pointer to input vector */
												Word16 len,           /*!< Length of input vector */
												Word16 stride)        /*!< Stride of input vector */
{
	Word16 maxVal = 0;
	Word16 absVal;
	Word16 i;

	for(i=0; i<len; i++){
		absVal = abs_s(vector[i*stride]);
		maxVal |= absVal;
	}

	return( maxVal ? norm_s(maxVal) : 15);
}


/*****************************************************************************
*
* function name: Transform_Real
* description:  Calculate transform filter for input vector of shorts
* returns:      TRUE if success
*
**********************************************************************************/
void Transform_Real(Word16 *mdctDelayBuffer,
                    Word16 *timeSignal,
                    Word16 chIncrement,
                    Word32 *realOut,
                    Word16 *mdctScale,
                    Word16 blockType
                    )
{
	Word32 i,w;
	Word32 timeSignalSample;
	Word32 ws1,ws2;
	Word16 *dctIn0, *dctIn1;
	Word32 *outData0, *outData1;
	Word32 *winPtr;

	Word32 delayBufferSf,timeSignalSf,minSf;

	switch(blockType){


	case LONG_WINDOW:
		/*
		we access BLOCK_SWITCHING_OFFSET (1600 ) delay buffer samples + 448 new timeSignal samples
		and get the biggest scale factor for next calculate more precise
		*/
		delayBufferSf = getScalefactorOfShortVectorStride(mdctDelayBuffer,BLOCK_SWITCHING_OFFSET,1);
		timeSignalSf  = getScalefactorOfShortVectorStride(timeSignal,2*FRAME_LEN_LONG-BLOCK_SWITCHING_OFFSET,chIncrement);
		minSf = min(delayBufferSf,timeSignalSf);
		minSf = min(minSf,14);

		dctIn0 = mdctDelayBuffer;
		dctIn1 = mdctDelayBuffer + FRAME_LEN_LONG - 1;
		outData0 = realOut + FRAME_LEN_LONG/2;

		/* add windows and pre add for mdct to last buffer*/
		winPtr = (int *)LongWindowKBD;
		for(i=0;i<FRAME_LEN_LONG/2;i++){
			timeSignalSample = (*dctIn0++) << minSf;
			ws1 = timeSignalSample * (*winPtr >> 16);
			timeSignalSample = (*dctIn1--) << minSf;
			ws2 = timeSignalSample * (*winPtr & 0xffff);
			winPtr ++;
			/* shift 2 to avoid overflow next */
			*outData0++ = (ws1 >> 2) - (ws2 >> 2);
		}

		shiftMdctDelayBuffer(mdctDelayBuffer,timeSignal,chIncrement);

		/* add windows and pre add for mdct to new buffer*/
		dctIn0 = mdctDelayBuffer;
		dctIn1 = mdctDelayBuffer + FRAME_LEN_LONG - 1;
		outData0 = realOut + FRAME_LEN_LONG/2 - 1;
		winPtr = (int *)LongWindowKBD;
		for(i=0;i<FRAME_LEN_LONG/2;i++){
			timeSignalSample = (*dctIn0++) << minSf;
			ws1 = timeSignalSample * (*winPtr & 0xffff);
			timeSignalSample = (*dctIn1--) << minSf;
			ws2 = timeSignalSample * (*winPtr >> 16);
			winPtr++;
			/* shift 2 to avoid overflow next */
			*outData0-- = -((ws1 >> 2) + (ws2 >> 2));
		}

		Mdct_Long(realOut);
		/* update scale factor */
		minSf = 14 - minSf;
		*mdctScale=minSf;
		break;

	case START_WINDOW:
		/*
		we access BLOCK_SWITCHING_OFFSET (1600 ) delay buffer samples + no timeSignal samples
		and get the biggest scale factor for next calculate more precise
		*/
		minSf = getScalefactorOfShortVectorStride(mdctDelayBuffer,BLOCK_SWITCHING_OFFSET,1);
		minSf = min(minSf,14);

		dctIn0 = mdctDelayBuffer;
		dctIn1 = mdctDelayBuffer + FRAME_LEN_LONG - 1;
		outData0 = realOut + FRAME_LEN_LONG/2;
		winPtr = (int *)LongWindowKBD;

		/* add windows and pre add for mdct to last buffer*/
		for(i=0;i<FRAME_LEN_LONG/2;i++){
			timeSignalSample = (*dctIn0++) << minSf;
			ws1 = timeSignalSample * (*winPtr >> 16);
			timeSignalSample = (*dctIn1--) << minSf;
			ws2 = timeSignalSample * (*winPtr & 0xffff);
			winPtr ++;
			*outData0++ = (ws1 >> 2) - (ws2 >> 2);  /* shift 2 to avoid overflow next */
		}

		shiftMdctDelayBuffer(mdctDelayBuffer,timeSignal,chIncrement);

		outData0 = realOut + FRAME_LEN_LONG/2 - 1;
		for(i=0;i<LS_TRANS;i++){
			*outData0-- = -mdctDelayBuffer[i] << (15 - 2 + minSf);
		}

		/* add windows and pre add for mdct to new buffer*/
		dctIn0 = mdctDelayBuffer + LS_TRANS;
		dctIn1 = mdctDelayBuffer + FRAME_LEN_LONG - 1 - LS_TRANS;
		outData0 = realOut + FRAME_LEN_LONG/2 - 1 -LS_TRANS;
		winPtr = (int *)ShortWindowSine;
		for(i=0;i<FRAME_LEN_SHORT/2;i++){
			timeSignalSample= (*dctIn0++) << minSf;
			ws1 = timeSignalSample * (*winPtr & 0xffff);
			timeSignalSample= (*dctIn1--) << minSf;
			ws2 = timeSignalSample * (*winPtr >> 16);
			winPtr++;
			*outData0-- =  -((ws1 >> 2) + (ws2 >> 2));  /* shift 2 to avoid overflow next */
		}

		Mdct_Long(realOut);
		/* update scale factor */
		minSf = 14 - minSf;
		*mdctScale= minSf;
		break;

	case STOP_WINDOW:
		/*
		we access BLOCK_SWITCHING_OFFSET-LS_TRANS (1600-448 ) delay buffer samples + 448 new timeSignal samples
		and get the biggest scale factor for next calculate more precise
		*/
		delayBufferSf = getScalefactorOfShortVectorStride(mdctDelayBuffer+LS_TRANS,BLOCK_SWITCHING_OFFSET-LS_TRANS,1);
		timeSignalSf  = getScalefactorOfShortVectorStride(timeSignal,2*FRAME_LEN_LONG-BLOCK_SWITCHING_OFFSET,chIncrement);
		minSf = min(delayBufferSf,timeSignalSf);
		minSf = min(minSf,13);

		outData0 = realOut + FRAME_LEN_LONG/2;
		dctIn1 = mdctDelayBuffer + FRAME_LEN_LONG - 1;
		for(i=0;i<LS_TRANS;i++){
			*outData0++ = -(*dctIn1--) << (15 - 2 + minSf);
		}

		/* add windows and pre add for mdct to last buffer*/
		dctIn0 = mdctDelayBuffer + LS_TRANS;
		dctIn1 = mdctDelayBuffer + FRAME_LEN_LONG - 1 - LS_TRANS;
		outData0 = realOut + FRAME_LEN_LONG/2 + LS_TRANS;
		winPtr = (int *)ShortWindowSine;
		for(i=0;i<FRAME_LEN_SHORT/2;i++){
			timeSignalSample = (*dctIn0++) << minSf;
			ws1 = timeSignalSample * (*winPtr >> 16);
			timeSignalSample= (*dctIn1--) << minSf;
			ws2 = timeSignalSample * (*winPtr & 0xffff);
			winPtr++;
			*outData0++ = (ws1 >> 2) - (ws2 >> 2);  /* shift 2 to avoid overflow next */
		}

		shiftMdctDelayBuffer(mdctDelayBuffer,timeSignal,chIncrement);

		/* add windows and pre add for mdct to new buffer*/
		dctIn0 = mdctDelayBuffer;
		dctIn1 = mdctDelayBuffer + FRAME_LEN_LONG - 1;
		outData0 = realOut + FRAME_LEN_LONG/2 - 1;
		winPtr = (int *)LongWindowKBD;
		for(i=0;i<FRAME_LEN_LONG/2;i++){
			timeSignalSample= (*dctIn0++) << minSf;
			ws1 = timeSignalSample *(*winPtr & 0xffff);
			timeSignalSample= (*dctIn1--) << minSf;
			ws2 = timeSignalSample * (*winPtr >> 16);
			*outData0-- =  -((ws1 >> 2) + (ws2 >> 2));  /* shift 2 to avoid overflow next */
			winPtr++;
		}

		Mdct_Long(realOut);
		minSf = 14 - minSf;
		*mdctScale= minSf; /* update scale factor */
		break;

	case SHORT_WINDOW:
		/*
		we access BLOCK_SWITCHING_OFFSET (1600 ) delay buffer samples + no new timeSignal samples
		and get the biggest scale factor for next calculate more precise
		*/
		minSf = getScalefactorOfShortVectorStride(mdctDelayBuffer+TRANSFORM_OFFSET_SHORT,9*FRAME_LEN_SHORT,1);
		minSf = min(minSf,10);


		for(w=0;w<TRANS_FAC;w++){
			dctIn0 = mdctDelayBuffer+w*FRAME_LEN_SHORT+TRANSFORM_OFFSET_SHORT;
			dctIn1 = mdctDelayBuffer+w*FRAME_LEN_SHORT+TRANSFORM_OFFSET_SHORT + FRAME_LEN_SHORT-1;
			outData0 = realOut + FRAME_LEN_SHORT/2;
			outData1 = realOut + FRAME_LEN_SHORT/2 - 1;

			winPtr = (int *)ShortWindowSine;
			for(i=0;i<FRAME_LEN_SHORT/2;i++){
				timeSignalSample= *dctIn0 << minSf;
				ws1 = timeSignalSample * (*winPtr >> 16);
				timeSignalSample= *dctIn1 << minSf;
				ws2 = timeSignalSample * (*winPtr & 0xffff);
				*outData0++ = (ws1 >> 2) - (ws2 >> 2);  /* shift 2 to avoid overflow next */

				timeSignalSample= *(dctIn0 + FRAME_LEN_SHORT) << minSf;
				ws1 = timeSignalSample * (*winPtr & 0xffff);
				timeSignalSample= *(dctIn1 + FRAME_LEN_SHORT) << minSf;
				ws2 = timeSignalSample * (*winPtr >> 16);
				*outData1-- =  -((ws1 >> 2) + (ws2 >> 2));  /* shift 2 to avoid overflow next */

				winPtr++;
				dctIn0++;
				dctIn1--;
			}

			Mdct_Short(realOut);
			realOut += FRAME_LEN_SHORT;
		}

		minSf = 11 - minSf;
		*mdctScale = minSf; /* update scale factor */

		shiftMdctDelayBuffer(mdctDelayBuffer,timeSignal,chIncrement);
		break;
  }
}