/*-------------------------------------------------------------------------*
 *                                                                         *
 *   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)

#include <math.h>
#define M_PI 3.14159265
void  indicate_start(void);
void  indicate_end(void);
#include <memory.h>
#else
#include <string.h> /* memcpy () */
#endif



#include "stddefs.h"
#include "tg.h"

/*--------------------- local defs ----------------------------------------*/
/*--------------------- public vars ---------------------------------------*/
/*--------------------- local vars ----------------------------------------*/
#if defined (_dsp)
#pragma DATA_SECTION (TG_asSin, ".tg_data")
#endif

#include "tgsin.cc"
/*--------------------- local functions -----------------------------------*/
#if 0
/*-------------------------------------------------------------------------*/
S16                         tg_sin
/*-------------------------------------------------------------------------*/
(
S16 sPhase
)
{
    return (S16)(32767. * sin(sPhase*M_PI/32768.));
}
/*-------------------------------------------------------------------------*/
void                        tg_add_sine
/*-------------------------------------------------------------------------*/
(
TG_tTone *pTone,
S16 *pOut
)
{
    S16 k;
    S16 ar0 = pTone->sFreq;
    S16 ar2 = pTone->sPhase;
    S16 t = pTone->sAmp;
    S32 acc;

    for (k = 0; k < STD_FR_SZ; k++)
    {
        ar2 += ar0;     /* deliberately truncating ... */
        acc = tg_sin(ar2);
        *pOut++ += (S16)((acc * t)>>15);
    }
    pTone->sPhase = ar2;
}
#else

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

#endif
/*--------------------- public  functions ---------------------------------*/

/*-------------------------------------------------------------------------*/
void *                      TG_create
/*-------------------------------------------------------------------------*/
(
TG_tDb *pDb
)
{
    pDb++;
	return ( void *)pDb;
}
/*-------------------------------------------------------------------------*/
void                        TG_init
/*-------------------------------------------------------------------------*/
(
TG_tDb *pDb
)
{
    memset(pDb, 0, sizeof(TG_tDb));
}

/*-------------------------------------------------------------------------*/
void                        TG_control
/*-------------------------------------------------------------------------*/
(
TG_tDb *pDb,
TG_tCfg *pCfg
)
{
    switch (pCfg->sCmd)
    {
    case TG_CMD_NONE:
        break;
    case TG_CMD_RESET:
        /* reset phase */
        pDb->Lo.sPhase = 0;
        pDb->Hi.sPhase = (S16)(32767);
        pDb->sState = 0;
        break;
    case TG_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 = TG_ST_PRE_SILENCE;
	        pDb->sCurrFrame = pDb->Cfg.sPreSilenceDuration;
            pDb->Lo.sAmp = 0;
            pDb->Hi.sAmp = 0;
        }
        else
        {
			pDb->sState = TG_ST_SIGNAL;
			pDb->sCurrFrame = pDb->Cfg.sSignalDuration;
            pDb->Lo.sAmp  = pDb->Cfg.Lo.sAmp;
            pDb->Hi.sAmp  = pDb->Cfg.Hi.sAmp;
        }
        break;
    }
}

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

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

	case TG_ST_PRE_SILENCE:
		--pSc->sCurrFrame;
		if (pSc->sCurrFrame <= 0)
		{
			pSc->sState = TG_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 TG_ST_SIGNAL:
        tg_add_sine2(&pSc->Lo, pOut);
        tg_add_sine2(&pSc->Hi, pOut);

        if (pSc->Cfg.sSignalDuration > 0)
        {
		    --pSc->sCurrFrame;
		    if (pSc->sCurrFrame <= 0)
		    {
                if (pSc->Cfg.sPostSilenceDuration > 0)
                {
			        pSc->sState = TG_ST_POST_SILENCE;
			        pSc->sCurrFrame = pSc->Cfg.sPostSilenceDuration;
                }
                else
                {
        			pSc->sState = TG_ST_IDLE;
                }
                pSc->Lo.sAmp  = 0;
                pSc->Hi.sAmp  = 0;

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

	case TG_ST_POST_SILENCE:
		--pSc->sCurrFrame;
		if (pSc->sCurrFrame <= 0)
		{
			pSc->sState = TG_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;
}