/*----------------------------------------------------------------------------
 *
 * File: 
 * eas_imaadpcm.c
 *
 * Contents and purpose:
 * Implements the IMA ADPCM decoder
 *
 * Copyright Sonic Network Inc. 2005

 * 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.
 *
 *----------------------------------------------------------------------------
 * Revision Control:
 *   $Revision: 847 $
 *   $Date: 2007-08-27 21:30:08 -0700 (Mon, 27 Aug 2007) $
 *----------------------------------------------------------------------------
*/

#include "eas_data.h"
#include "eas_host.h"
#include "eas_pcm.h"
#include "eas_math.h"
#include "eas_report.h"

// #define _DEBUG_IMA_ADPCM_LOCATE

/*----------------------------------------------------------------------------
 * externs
 *----------------------------------------------------------------------------
*/
extern const EAS_I16 imaIndexTable[];
extern const EAS_I16 imaStepSizeTable[];

/*----------------------------------------------------------------------------
 * prototypes
 *----------------------------------------------------------------------------
*/
static EAS_RESULT IMADecoderInit (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState);
static EAS_RESULT IMADecoderSample (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState);
static void IMADecoderADPCM (S_DECODER_STATE *pState, EAS_U8 nibble);
static EAS_RESULT IMADecoderLocate (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState, EAS_I32 time);

/*----------------------------------------------------------------------------
 * IMA ADPCM Decoder interface
 *----------------------------------------------------------------------------
*/
const S_DECODER_INTERFACE IMADecoder = 
{
	IMADecoderInit,
	IMADecoderSample,
	IMADecoderLocate
};

/*----------------------------------------------------------------------------
 * IMADecoderInit()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Initializes the IMA ADPCM decoder
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) common decoder interface - pEASData not used */
static EAS_RESULT IMADecoderInit (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState)
{
	pState->decoderL.step = 0;
	pState->decoderR.step = 0;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * IMADecoderSample()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Decodes an IMA ADPCM sample
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT IMADecoderSample (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState)
{
	EAS_RESULT result;
	EAS_I16 sTemp;

	/* if high nibble, decode */
	if (pState->hiNibble)
	{
		IMADecoderADPCM(&pState->decoderL, (EAS_U8)(pState->srcByte >> 4));
		pState->hiNibble = EAS_FALSE;
	}

	/* low nibble, need to fetch another byte */
	else
	{
		/* check for loop */
		if ((pState->bytesLeft == 0) && (pState->loopSamples != 0))
		{
			/* seek to start of loop */
			if ((result = EAS_HWFileSeek(pEASData->hwInstData, pState->fileHandle, (EAS_I32) (pState->startPos + pState->loopLocation))) != EAS_SUCCESS)
				return result;
			pState->bytesLeft = pState->byteCount = (EAS_I32) pState->bytesLeftLoop;
			pState->blockCount = 0;
			pState->flags &= ~PCM_FLAGS_EMPTY;
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMADecoderSample: Rewind file to %d, bytesLeft = %d\n", pState->startPos, pState->bytesLeft); */ }
		}

		/* if start of block, fetch new predictor and step index */
		if ((pState->blockSize != 0) && (pState->blockCount == 0) && (pState->bytesLeft != 0))
		{

			/* get predicted sample for left channel */		
			if ((result = EAS_HWGetWord(pEASData->hwInstData, pState->fileHandle, &sTemp, EAS_FALSE)) != EAS_SUCCESS)
				return result;
#ifdef _DEBUG_IMA_ADPCM		
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Predictor: Was %d, now %d\n", pState->decoderL.acc, sTemp); */ }
#endif
			pState->decoderL.acc = pState->decoderL.x1 = sTemp;

			/* get step index for left channel - upper 8 bits are reserved */
			if ((result = EAS_HWGetWord(pEASData->hwInstData, pState->fileHandle, &sTemp, EAS_FALSE)) != EAS_SUCCESS)
				return result;
#ifdef _DEBUG_IMA_ADPCM		
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Step: Was %d, now %d\n", pState->decoderL.step, sTemp); */ }
#endif
			pState->decoderL.step = sTemp & 0xff;

			if (pState->flags & PCM_FLAGS_STEREO)
			{
				/* get predicted sample for right channel */		
				if ((result = EAS_HWGetWord(pEASData->hwInstData, pState->fileHandle, &sTemp, EAS_FALSE)) != EAS_SUCCESS)
					return result;
				pState->decoderR.acc = pState->decoderR.x1 = sTemp;

				/* get step index for right channel - upper 8 bits are reserved */
				if ((result = EAS_HWGetWord(pEASData->hwInstData, pState->fileHandle, &sTemp, EAS_FALSE)) != EAS_SUCCESS)
					return result;
#ifdef _DEBUG_IMA_ADPCM		
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Step: Was %d, now %d\n", pState->decoderR.step, sTemp); */ }
#endif
				pState->decoderR.step = sTemp & 0xff;
				
				pState->blockCount = pState->blockSize - 8;
				pState->bytesLeft -= 8;
			}
			else
			{
				pState->blockCount = pState->blockSize - 4;
				pState->bytesLeft -= 4;
			}
		}
		else
		{
		
			/* get another ADPCM data pair */
			if (pState->bytesLeft)
			{

				if ((result = EAS_HWGetByte(pEASData->hwInstData, pState->fileHandle, &pState->srcByte)) != EAS_SUCCESS)
					return result;
				
				/* decode the low nibble */
				pState->bytesLeft--;
				pState->blockCount--;
				IMADecoderADPCM(&pState->decoderL, (EAS_U8)(pState->srcByte & 0x0f));
				
				if (pState->flags & PCM_FLAGS_STEREO)
					IMADecoderADPCM(&pState->decoderR, (EAS_U8)(pState->srcByte >> 4));
				else
					pState->hiNibble = EAS_TRUE;
			}

			/* out of ADPCM data, generate enough samples to fill buffer */
			else
			{
				pState->decoderL.x1 = pState->decoderL.x0;
				pState->decoderR.x1 = pState->decoderR.x0;
			}
		}
	}
	
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * IMADecoderADPCM()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Decodes an IMA ADPCM sample
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static void IMADecoderADPCM (S_DECODER_STATE *pState, EAS_U8 nibble)
{
	EAS_INT delta;
	EAS_INT stepSize;

	/* get stepsize from table */
	stepSize = imaStepSizeTable[pState->step];

	/* delta = (abs(delta) + 0.5) * step / 4 */
	delta = 0;
	if (nibble & 4)
		delta += stepSize;

	if (nibble & 2)
		/*lint -e{702} use shift for performance */
		delta += stepSize >> 1;

	if (nibble & 1)
		/*lint -e{702} use shift for performance */
		delta += stepSize >> 2;

	/*lint -e{702} use shift for performance */
	delta += stepSize >> 3;

	/* integrate the delta */
	if (nibble & 8)
	  pState->acc -= delta;
	else
	  pState->acc += delta;

	/* saturate */
	if (pState->acc > 32767)
		pState->acc = 32767;
	if (pState->acc < -32768)
		pState->acc = -32768;
	pState->x1 = (EAS_PCM) pState->acc;

	/* compute new step size */
	pState->step += imaIndexTable[nibble];
	if (pState->step < 0)
		pState->step = 0;
	if (pState->step > 88)
		pState->step = 88;

#ifdef _DEBUG_IMA_ADPCM		
	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "In=%u, Pred=%d, Step=%d\n", nibble, pState->acc,  imaStepSizeTable[pState->step]); */ }
#endif	
}

/*----------------------------------------------------------------------------
 * IMADecoderLocate()
 *----------------------------------------------------------------------------
 * Locate in an IMA ADPCM stream
 *----------------------------------------------------------------------------
*/
static EAS_RESULT IMADecoderLocate (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState, EAS_I32 time)
{
	EAS_RESULT result;
	EAS_I32 temp;
	EAS_I32 samplesPerBlock;
	EAS_I32 secs, msecs;

	/* no need to calculate if time is zero */
	if (time == 0)
		temp = 0;
		
	/* not zero */
	else
	{
		
		/* can't seek if not a blocked file */
		if (pState->blockSize == 0)
			return EAS_ERROR_FEATURE_NOT_AVAILABLE;

		/* calculate number of samples per block */
		if (pState->flags & PCM_FLAGS_STEREO)
			samplesPerBlock = pState->blockSize - 7;
		else
			samplesPerBlock = (pState->blockSize << 1) - 7;

		/* break down into secs and msecs */
		secs = time / 1000;
		msecs = time - (secs * 1000);

		/* calculate sample number fraction from msecs */
		temp = (msecs * pState->sampleRate);
		temp = (temp >> 10) + ((temp * 49) >> 21);

		/* add integer sample count */
		temp += secs * pState->sampleRate;

#ifdef _DEBUG_IMA_ADPCM_LOCATE		
		EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x2380b977, 0x00000006 , time, temp);
#endif	

		/* for looped samples, calculate position in the loop */
		if ((temp > pState->byteCount) && (pState->loopSamples != 0))
		{
			EAS_I32 numBlocks;
			EAS_I32 samplesPerLoop;
			EAS_I32 samplesInLastBlock;

			numBlocks = (EAS_I32) (pState->loopStart / pState->blockSize);
			samplesInLastBlock = (EAS_I32) pState->loopStart - (numBlocks * pState->blockSize);
			if (samplesInLastBlock)
			{
				if (pState->flags & PCM_FLAGS_STEREO)
					samplesInLastBlock = samplesInLastBlock - 7;
				else
					/*lint -e{703} use shift for performance */
					samplesInLastBlock = (samplesInLastBlock << 1) - 7;
			}
			samplesPerLoop = numBlocks * samplesPerBlock + samplesInLastBlock;
			temp = temp % samplesPerLoop;
#ifdef _DEBUG_IMA_ADPCM_LOCATE		
			EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x2380b977, 0x00000007 , numBlocks, samplesPerLoop, samplesInLastBlock, temp);
#endif	
		}

		/* find start of block for requested sample */
		temp = (temp / samplesPerBlock) * pState->blockSize;
#ifdef _DEBUG_IMA_ADPCM_LOCATE		
		EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x2380b977, 0x00000008 , temp);
#endif	

	}

	/* seek to new location */
	if ((result = EAS_PESeek(pEASData, pState, &temp)) != EAS_SUCCESS)
		return result;

#ifdef _DEBUG_IMA_ADPCM_LOCATE		
	EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x2380b977, 0x00000009 , pState->bytesLeft);
#endif	

	/* reset state */
	pState->blockCount = 0;
	pState->hiNibble = EAS_FALSE;
	if ((pState->state != EAS_STATE_PAUSING) && (pState->state != EAS_STATE_PAUSED))
		pState->state = EAS_STATE_READY;
	
	return EAS_SUCCESS;	
}