/*-------------------------------------------------------------------------*
 *                                                                         *
 *   THIS IS AN UNPUBLISHED WORK CONTAINING CONFIDENTIAL AND PROPRIETARY   *
 *   INFORMATION.  IF PUBLICATION OCCURS, THE FOLLOWING NOTICE APPLIES:    *
 *      "COPYRIGHT 2001 MICHAEL TSIROULNIKOV, ALL RIGHTS RESERVED"         *
 *                                                                         *
 *-------------------------------------------------------------------------*/

#if ! defined (_dsp)
void  indicate_start(void);
void  indicate_end(void);
#include <memory.h>
#else
#include <string.h> /* memcpy () */
#endif

#include "tg.h"
#include "tgsin.cc"

extern void tg_add_sine2(TG_tTone *pTone, S16 *pOut);

/*--------------------- local defs ----------------------------------------*/
/*--------------------- public vars ---------------------------------------*/
/*--------------------- local vars ----------------------------------------*/
/*--------------------- local functions -----------------------------------*/
/*-------------------------------------------------------------------------*/
static void             _add_sine2
/*-------------------------------------------------------------------------*/
(
TG_tTone *pTone,
S16 *pTo
)
{
    S32 ac0;
    S32 ac1;
    S32 ac2;
    S32 ac3 = pTone->sPhase;
    S16 t0, t1;

    int k;

    for (k = 0; k < TG_FR_SZ/2; k++)
    {
        ac3 = ac3 + pTone->sFreq;
        ac2 = ac3 >> 8;
        t0  = (S16)(ac2 & 0xff);

        ac3 = ac3 + pTone->sFreq;
        ac2 = ac3 >> 8;
        t1  = (S16)(ac2 & 0xff);

        ac0 = ((S32)*pTo++)<<15;
        ac1 = ((S32)*pTo--)<<15;

        ac0 = ac0 + TG_asSin[t0] * (S32) (pTone->sAmp);
        ac1 = ac1 + TG_asSin[t1] * (S32) (pTone->sAmp);

        *pTo++ = (S16)(ac0>>15);
        *pTo++ = (S16)(ac1>>15);
    }
    pTone->sPhase = (S16)ac3;
}
/*--------------------- public  functions ---------------------------------*/

/*-------------------------------------------------------------------------*/
void                        TG_MIKET_init_db
/*-------------------------------------------------------------------------*/
(
TG_tDb *pDb
)
{
    memset(pDb, 0, sizeof(TG_tDb));
}

/*-------------------------------------------------------------------------*/
void                        TG_MIKET_control
/*-------------------------------------------------------------------------*/
(
TG_tDb *pDb,
S16 sCmd,
ITG_Status *pCfg
)
{
    switch (sCmd)
    {
    case ITG_CMD_NONE:
        break;
    case ITG_CMD_RESET:
        /* reset phase */
        pDb->Lo.sPhase = 0;
        pDb->Hi.sPhase = 0;
        pDb->sState = 0;
        break;
    case ITG_CMD_TONE:
        /* copy cfg */
        pDb->Cfg = *pCfg;
        /* setup freq */
        pDb->Lo.sFreq = pCfg->Lo.sFreq;
        pDb->Hi.sFreq = pCfg->Hi.sFreq;
        if (pDb->Cfg.sPreSilenceDuration > 0)
        {
            /* setup for PRE_SILENCE */
            pDb->sState = ITG_ST_PRE_SILENCE;
	        pDb->sCurrFrame = pDb->Cfg.sPreSilenceDuration;
            pDb->Lo.sAmp = 0;
            pDb->Hi.sAmp = 0;
        }
        else
        {
			pDb->sState = ITG_ST_SIGNAL;
			pDb->sCurrFrame = pDb->Cfg.sSignalDuration;
            pDb->Lo.sAmp  = pDb->Cfg.Lo.sAmp;
            pDb->Hi.sAmp  = pDb->Cfg.Hi.sAmp;
        }
        break;
    }
  	pCfg->State = pDb->sState;
}

/*-------------------------------------------------------------------------*/
S16                         TG_MIKET_process
/*-------------------------------------------------------------------------*/
/* function returns zero when work has been done */
(
TG_tDb *pDb,
TG_tSc *pSc,
S16 *pOut
)
{
    /* copy data from Db into Scratch */
    memcpy(pSc, pDb, sizeof(TG_tDb));

	switch (pSc->sState)
	{
    case ITG_ST_IDLE:
        /* do nothing in idle state */
        break;

	case ITG_ST_PRE_SILENCE:
		--pSc->sCurrFrame;
		if (pSc->sCurrFrame <= 0)
		{
			pSc->sState = ITG_ST_SIGNAL;
			pSc->sCurrFrame = pSc->Cfg.sSignalDuration;
            pSc->Lo.sAmp  = pSc->Cfg.Lo.sAmp;
            pSc->Hi.sAmp  = pSc->Cfg.Hi.sAmp;
#if ! defined (_dsp)
            indicate_start();
#endif
		}
		break;

	case ITG_ST_SIGNAL:
        _add_sine2(&pSc->Lo, pOut);
        _add_sine2(&pSc->Hi, pOut);

        if (pSc->Cfg.sSignalDuration < 0)
        {
            /* forever */
        }
        else
        {
		    --pSc->sCurrFrame;
		    if (pSc->sCurrFrame <= 0)
		    {
                if (pSc->Cfg.sPostSilenceDuration > 0)
                {
			        pSc->sState = ITG_ST_POST_SILENCE;
			        pSc->sCurrFrame = pSc->Cfg.sPostSilenceDuration;
                }
                else
                {
        			pSc->sState = ITG_ST_IDLE;
                }
                pSc->Lo.sAmp  = 0;
                pSc->Hi.sAmp  = 0;

#if ! defined (_dsp)
                indicate_end();
#endif
		    }
        }
		break;

	case ITG_ST_POST_SILENCE:
		--pSc->sCurrFrame;
		if (pSc->sCurrFrame <= 0)
		{
			pSc->sState = ITG_ST_IDLE;
		}
		break;

	default:
/* log err ??? */
		break;
    } /* end-of-switch */

    /* copy data from Db into Scratch */
    memcpy(pDb, pSc, sizeof(TG_tDb));

    return pSc->sState;
}