static const NUAN_TCHAR * _dataPathList[] = {
    __TEXT("\\lang\\"),
    __TEXT("\\tts\\"),
};

static VPLATFORM_RESOURCES _stResources = {
    VPLATFORM_CURRENT_VERSION,
    sizeof(_dataPathList)/sizeof(_dataPathList[0]),
    (NUAN_TCHAR **)&_dataPathList[0],
};

static VAUTO_INSTALL    _stInstall = {VAUTO_CURRENT_VERSION};
static VAUTO_HSPEECH    _hSpeech = {NULL, 0};
static VAUTO_HINSTANCE  _hTtsInst = {NULL, 0};
static WaveOut *        _waveOut = NULL;
static WaveOutBuf *     _curBuffer = NULL;
static int              _volume = 100;
static int              _speechRate = 0; // use default speech rate

static NUAN_ERROR _Callback (VAUTO_HINSTANCE        hTtsInst,
                                   VAUTO_OUTDEV_HINSTANCE hOutDevInst,
                                   VAUTO_CALLBACKMSG    * pcbMessage,
                                   VAUTO_USERDATA         UserData);
static const TCHAR * _szLangTLW = NULL;

static VAUTO_PARAMID _paramID[] = {
    VAUTO_PARAM_SPEECHRATE,
    VAUTO_PARAM_VOLUME
};

static NUAN_ERROR _TTS_GetFrequency(VAUTO_HINSTANCE hTtsInst, short *pFreq) {
    NUAN_ERROR  Error = NUAN_OK;
    VAUTO_PARAM TtsParam;

    /*-- get frequency used by current voicefont --*/
    TtsParam.eID = VAUTO_PARAM_FREQUENCY;

    if (NUAN_OK != (Error = vauto_ttsGetParamList (hTtsInst, &TtsParam, 1)) ) {
        ErrorV(_T("vauto_ttsGetParamList rc=0x%1!x!\n"), Error);
        return Error;
    }
    switch(TtsParam.uValue.usValue)
    {
    case VAUTO_FREQ_8KHZ:  *pFreq = 8000;
        break;
    case VAUTO_FREQ_11KHZ: *pFreq = 11025;
        break;
    case VAUTO_FREQ_16KHZ: *pFreq = 16000;
        break;
    case VAUTO_FREQ_22KHZ: *pFreq = 22050;
        break;
    default: break;
    }
    return NUAN_OK;
}


int TTS_SelectLanguage(int langId) {
    NUAN_ERROR nrc;

    VAUTO_LANGUAGE     arrLanguages[16];
    VAUTO_VOICEINFO    arrVoices[4];
    VAUTO_SPEECHDBINFO arrSpeechDB[4];

    NUAN_U16 nLanguageCount, nVoiceCount, nSpeechDBCount;
    nLanguageCount = sizeof(arrLanguages)/sizeof(arrLanguages[0]);
    nVoiceCount    = sizeof(arrVoices)   /sizeof(arrVoices[0]);
    nSpeechDBCount = sizeof(arrSpeechDB)/sizeof(arrSpeechDB[0]);
    int nVoice = 0, nSpeechDB = 0;

    nrc = vauto_ttsGetLanguageList( _hSpeech, &arrLanguages[0], &nLanguageCount);
    if(nrc != NUAN_OK){
        TTS_ErrorV(_T("vauto_ttsGetLanguageList rc=0x%1!x!\n"), nrc);
        return 0;
    }
    if(nLanguageCount == 0 || nLanguageCount<=langId){
        TTS_Error(_T("vauto_ttsGetLanguageList: No proper languages found.\n"));
        return 0;
    }

    _szLangTLW = arrLanguages[langId].szLanguageTLW;
    NUAN_TCHAR* szLanguage      = arrLanguages[langId].szLanguage;

    nVoice = 0; // select first voice;
    NUAN_TCHAR* szVoiceName      = arrVoices[nVoice].szVoiceName;

    nSpeechDB = 0; // select first speech DB

    {
        VAUTO_PARAM stTtsParam[7];
        int cnt = 0;

        // language
        stTtsParam[cnt].eID = VAUTO_PARAM_LANGUAGE;
        _tcscpy(stTtsParam[cnt].uValue.szStringValue, szLanguage);
        cnt++;

        // voice
        stTtsParam[cnt].eID = VAUTO_PARAM_VOICE;
        _tcscpy(stTtsParam[cnt].uValue.szStringValue, szVoiceName);
        cnt++;

        // speechbase parameter - frequency
        stTtsParam[cnt].eID = VAUTO_PARAM_FREQUENCY;
        stTtsParam[cnt].uValue.usValue = arrSpeechDB[nSpeechDB].u16Freq;
        cnt++;

        // speechbase parameter - reduction type
        stTtsParam[cnt].eID = VAUTO_PARAM_VOICE_MODEL;
        _tcscpy(stTtsParam[cnt].uValue.szStringValue, arrSpeechDB[nSpeechDB].szVoiceModel);
        cnt++;

        if (_speechRate) {
            // Speech rate
            stTtsParam[cnt].eID = VAUTO_PARAM_SPEECHRATE;
            stTtsParam[cnt].uValue.usValue = _speechRate;
            cnt++;
        }

        if (_volume) {
            // Speech volume
            stTtsParam[cnt].eID = VAUTO_PARAM_VOLUME;
            stTtsParam[cnt].uValue.usValue = _volume;
            cnt++;
        }

        nrc = vauto_ttsSetParamList(_hTtsInst, &stTtsParam[0], cnt);
        if(nrc != NUAN_OK){
            ErrorV(_T("vauto_ttsSetParamList rc=0x%1!x!\n"), nrc);
            return 0;
        }
    }
    return 1;
}

int TTS_Initialize(int defLanguageId) {
    NUAN_ERROR nrc;

    nrc = vplatform_GetInterfaces(&_stInstall, &_stResources);
    if(nrc != NUAN_OK){
        Error(_T("vplatform_GetInterfaces rc=%1!d!\n"), nrc);
        return 0;
    }
    nrc = vauto_ttsInitialize(&_stInstall, &_hSpeech);
    if(nrc != NUAN_OK){
        Error(_T("vauto_ttsInitialize rc=0x%1!x!\n"), nrc);
        TTS_Cleanup();
        return 0;
    }
    nrc =  vauto_ttsOpen(_hSpeech, _stInstall.hHeap, _stInstall.hLog, &_hTtsInst, NULL);
    if(nrc != NUAN_OK){
        ErrorV(_T("vauto_ttsOpen rc=0x%1!x!\n"), nrc);
        TTS_Cleanup();
        return 0;
    }

    // Ok, time to select language
    if(!TTS_SelectLanguage(defLanguageId)){
        TTS_Cleanup();
        return 0;
    }

    // init Wave out device
    {
        short freq;
        if (NUAN_OK != _TTS_GetFrequency(_hTtsInst, &freq))
        {
            TTS_ErrorV(_T("_TTS_GetFrequency rc=0x%1!x!\n"), nrc);
            TTS_Cleanup();
            return 0;
        }

        _waveOut = WaveOut_Open(freq, 1, 4);
        if (_waveOut == NULL){
            TTS_Cleanup();
            return 0;
        }
    }

    // init TTS output
    {
        VAUTO_OUTDEVINFO stOutDevInfo;
        stOutDevInfo.hOutDevInstance = _waveOut;
        stOutDevInfo.pfOutNotify = TTS_Callback;              // Notify using callback!

        nrc = vauto_ttsSetOutDevice(_hTtsInst, &stOutDevInfo);
        if(nrc != NUAN_OK){
            ErrorV(_T("vauto_ttsSetOutDevice rc=0x%1!x!\n"), nrc);
            TTS_Cleanup();
            return 0;
        }
    }

    // OK TTS engine initialized
    return 1;

}

void TTS_Cleanup(void) {
    if(_hTtsInst.pHandleData){
        vauto_ttsStop(_hTtsInst);
        vauto_ttsClose(_hTtsInst);
    }
    if(_hSpeech.pHandleData){
        vauto_ttsUnInitialize(_hSpeech);
    }
    if(_waveOut){
        WaveOut_Close(_waveOut);
        _waveOut = NULL;
    }
    vplatform_ReleaseInterfaces(&_stInstall);
    memset(&_stInstall, 0, sizeof(_stInstall));
    _stInstall.fmtVersion = VAUTO_CURRENT_VERSION;
}

int  TTS_Speak(const TCHAR * const message, int length) {

    VAUTO_INTEXT stText;
    stText.eTextFormat  = VAUTO_NORM_TEXT;
    stText.szInText     = (void*) message;
    stText.ulTextLength = length * sizeof(NUAN_TCHAR);
    TraceV(_T("TTS_Speak: %1\n"), message);
    NUAN_ERROR rc = vauto_ttsProcessText2Speech(_hTtsInst, &stText);
    if (rc == NUAN_OK) {
        return 1;
    }
    if (rc == NUAN_E_TTS_USERSTOP) {
        return 2;
    }
    ErrorV(_T("vauto_ttsProcessText2Speech rc=0x%1!x!\n"), rc);
    return 0;
}


static NUAN_ERROR TTS_Callback (VAUTO_HINSTANCE        hTtsInst,
                                   VAUTO_OUTDEV_HINSTANCE hOutDevInst,
                                   VAUTO_CALLBACKMSG    * pcbMessage,
                                   VAUTO_USERDATA         UserData) {
    VAUTO_OUTDATA * outData;
    switch(pcbMessage->eMessage){
    case VAUTO_MSG_BEGINPROCESS:
        WaveOut_Start(_waveOut);
        break;
    case VAUTO_MSG_ENDPROCESS:
        break;
    case VAUTO_MSG_STOP:
        break;
    case VAUTO_MSG_OUTBUFREQ:
        outData = (VAUTO_OUTDATA *)pcbMessage->pParam;
        memset(outData, 0, sizeof(VAUTO_OUTDATA));
        {
            WaveOutBuf * buf = WaveOut_GetBuffer(_waveOut);
            if(buf){
                VAUTO_OUTDATA * outData = (VAUTO_OUTDATA *)pcbMessage->pParam;
                outData->eAudioFormat     = VAUTO_16LINEAR;
                outData->pOutPcmBuf       = WaveOutBuf_Data(buf);
                outData->ulPcmBufLen      = WaveOutBuf_Size(buf);
                _curBuffer = buf;
                break;
            }
            TTS_Trace(_T("VAUTO_MSG_OUTBUFREQ: processing was stopped\n"));
        }
        return NUAN_E_TTS_USERSTOP;
    case VAUTO_MSG_OUTBUFDONE:
        outData = (VAUTO_OUTDATA *)pcbMessage->pParam;
        WaveOutBuf_SetSize(_curBuffer, outData->ulPcmBufLen);
        WaveOut_PutBuffer(_waveOut, _curBuffer);
        _curBuffer = NULL;
        break;
    default:
        break;
    }
    return NUAN_OK;
}

typedef struct RECOG_OBJECTS_S {
    void             *pHeapInst;          // Pointer to the heap.

    const char	   *acmod;				  // path to acmod data
    const char	   *ddg2p;				  // path to ddg2p data
    const char	   *clc;				  // path to clc data
    const char	   *dct;				  // path to dct data
    const char	   *dynctx;				  // path to empty dyn ctx data

    LH_COMPONENT      hCompBase;          // Handle to the base component.
    LH_COMPONENT      hCompAsr;           // Handle to the ASR component.
    LH_COMPONENT      hCompPron;		  // Handle to the pron component (dyn ctx)

    LH_OBJECT         hAcMod;             // Handle to the AcMod object.
    LH_OBJECT         hRec;				  // Handle to the SingleThreadedRec Object
    LH_OBJECT         hLex;				  // Handle to lexicon object (dyn ctx)
    LH_OBJECT         hDdg2p;			  // Handle to ddg2p object (dyn ctx)
    LH_OBJECT		  hClc;				  // Handle to the CLC (DDG2P backup)
    LH_OBJECT         hDct;				  // Handle to dictionary object (dyn ctx)
    LH_OBJECT         hCache;			  // Handle to cache object (dyn ctx)
    LH_OBJECT         hCtx[5];            // Handle to the Context object.
    LH_OBJECT         hResults[5];        // Handle to the Best results object.
    ASRResult        *results[5];         // recognition results temporary storage
    LH_OBJECT         hUswCtx;            // Handle to the UserWord Context object.
    LH_OBJECT         hUswResult;         // Handle to the UserWord Result object.

    unsigned long     sampleFreq;         // Sampling frequency.
    unsigned long     frameShiftSamples;  // Size of one frame in samples
    int               requestCancel;      // boolean indicating user wants to cancel recognition

    // used to generate transcriptions for dyn ctx
    LH_BNF_TERMINAL		*pTerminals;
    unsigned int		terminals_count;
    unsigned int		*terminals_transtype; // array with same size as pTerminals; each value indicates the type of transcription in pTerminal: user-provided, from_ddg2p, from_dct, from_clc
    SLOT_TERMINAL_LIST	*pSlots;
    unsigned int		slots_count;

    // reco options
    int			isNumber;	// set to 1 when doing number recognition
    const char *		UswFile;	// path to file where userword should be recorded

    char * staticCtxID;

} RECOG_OBJECTS;

// store ASR objects
static RECOG_OBJECTS recogObjects;

static int ConstructRecognizer(RECOG_OBJECTS *pRecogObjects,
                               const char *szAcModFN, const char * ddg2p, const char * clc, const char * dct, const char * dynctx) {
    LH_ERROR lhErr = LH_OK;
    PH_ERROR phErr = PH_OK;
    ST_ERROR stErr = ST_OK;

    LH_ISTREAM_INTERFACE  IStreamInterface;
    void                 *pIStreamAcMod = NULL;
    LH_ACMOD_INFO        *pAcModInfo;
    LH_AUDIOCHAINEVENT_INTERFACE    EventInterface;

    /* close old objects */
    if(!lh_ObjIsNull(pRecogObjects->hAcMod)){
        DestroyRecognizer(pRecogObjects);
    }
    pRecogObjects->sampleFreq      = 0;
    pRecogObjects->requestCancel   = 0;
    pRecogObjects->pTerminals      = NULL;
    pRecogObjects->terminals_count = 0;
    pRecogObjects->pSlots          = NULL;
    pRecogObjects->slots_count     = 0;
    pRecogObjects->staticCtxID     = NULL;

    pRecogObjects->acmod  = szAcModFN;
    pRecogObjects->ddg2p  = ddg2p;
    pRecogObjects->clc	  = clc;
    pRecogObjects->dct	  = dct;
    pRecogObjects->dynctx = dynctx;

    EventInterface.pfevent = evt_HandleEvent;
    EventInterface.pfadvance = evt_Advance;

    // Create the input stream for the acoustic model.
    stErr = st_CreateStreamReaderFromFile(szAcModFN, &IStreamInterface, &pIStreamAcMod);
    if (ST_OK != stErr) goto error;

    // Create the AcMod object.
    lhErr = lh_CreateAcMod(pRecogObjects->hCompAsr, &IStreamInterface, pIStreamAcMod, NULL, &(pRecogObjects->hAcMod));
    if (LH_OK != lhErr) goto error;

    // Retrieve some information from the AcMod object.
    lhErr = lh_AcModBorrowInfo(pRecogObjects->hAcMod, &pAcModInfo);
    if (LH_OK != lhErr) goto error;
    pRecogObjects->sampleFreq = pAcModInfo->sampleFrequency;
        pRecogObjects->frameShiftSamples = pAcModInfo->frameShift * pRecogObjects->sampleFreq/1000;

    // Create a SingleThreadRec object
    lhErr = lh_CreateSingleThreadRec(pRecogObjects->hCompAsr, &EventInterface, pRecogObjects, 3000, pRecogObjects->sampleFreq, pRecogObjects->hAcMod, &pRecogObjects->hRec);
    if (LH_OK != lhErr) goto error;

    // cretae DDG2P & lexicon for dyn ctx
    if (pRecogObjects->ddg2p) {
        int rc = InitDDG2P(pRecogObjects);
        if (rc<0) goto error;
    } else if (pRecogObjects->clc) {
        int rc = InitCLCandDCT(pRecogObjects);
        if (rc<0) goto error;
    } else {
        // TODO: what now?
    }

    // Return without errors.
    return 0;

error:
    // Print an error message if the error comes from the private heap or stream component.
    // Errors from the VoCon3200 component have been printed by the callback.
    if (PH_OK != phErr) {
        printf("Error from the private heap component, error code = %d.\n", phErr);
    }
    if (ST_OK != stErr) {
        printf("Error from the stream component, error code = %d.\n", stErr);
    }

    return -1;
}

static int DestroyRecognizer(RECOG_OBJECTS *pRecogObjects) {
    unsigned int curCtx;
    if (!lh_ObjIsNull(pRecogObjects->hUswResult)){
        lh_ObjClose(&pRecogObjects->hUswResult); pRecogObjects->hUswResult = lh_GetNullObj();
    }
    if (!lh_ObjIsNull(pRecogObjects->hUswCtx)){
        lh_ObjClose(&pRecogObjects->hUswCtx); pRecogObjects->hUswCtx = lh_GetNullObj();
    }
    if (!lh_ObjIsNull(pRecogObjects->hDct)){
        lh_ObjClose(&pRecogObjects->hDct); pRecogObjects->hDct = lh_GetNullObj();
    }
    if (!lh_ObjIsNull(pRecogObjects->hCache)){
        lh_ObjClose(&pRecogObjects->hCache); pRecogObjects->hCache = lh_GetNullObj();
    }
    if (!lh_ObjIsNull(pRecogObjects->hClc)){
        lh_ObjClose(&pRecogObjects->hClc); pRecogObjects->hClc = lh_GetNullObj();
    }
    if (!lh_ObjIsNull(pRecogObjects->hLex)){
        lh_LexClearG2P(pRecogObjects->hLex);
        lh_ObjClose(&pRecogObjects->hLex); pRecogObjects->hLex = lh_GetNullObj();
    }
    if (!lh_ObjIsNull(pRecogObjects->hDdg2p)){
        lh_DDG2PClearDct (pRecogObjects->hDdg2p);
        lh_ObjClose(&pRecogObjects->hDdg2p); pRecogObjects->hDdg2p = lh_GetNullObj();
    }
    for(curCtx=0; curCtx<sizeof(recogObjects.hCtx)/sizeof(recogObjects.hCtx[0]); curCtx++){
        if (!lh_ObjIsNull(pRecogObjects->hCtx[curCtx])){
            lh_RecRemoveCtx(pRecogObjects->hRec, pRecogObjects->hCtx[curCtx]);
            lh_ObjClose(&pRecogObjects->hCtx[curCtx]); pRecogObjects->hCtx[curCtx] = lh_GetNullObj();
        }
        if (!lh_ObjIsNull(pRecogObjects->hResults[curCtx])){
            lh_ObjClose(&pRecogObjects->hResults[curCtx]); pRecogObjects->hResults[curCtx] = lh_GetNullObj();
        }
    }
    if (!lh_ObjIsNull(pRecogObjects->hRec)){
        lh_ObjClose(&pRecogObjects->hRec); pRecogObjects->hRec = lh_GetNullObj();
    }
    if (!lh_ObjIsNull(pRecogObjects->hAcMod)){
        lh_ObjClose(&pRecogObjects->hAcMod); pRecogObjects->hAcMod = lh_GetNullObj();
    }

    return 0;
}

int ASR_Initialize(const char * acmod, const char * ddg2p, const char * clc, const char * dct, const char * dynctx) {
    int rc = 0;
    size_t curCtx;
    LH_HEAP_INTERFACE     HeapInterface;

    // Initialization of all handles.
    recogObjects.pHeapInst		= NULL;
    recogObjects.hCompBase		= lh_GetNullComponent();
    recogObjects.hCompAsr		= lh_GetNullComponent();
    recogObjects.hCompPron		= lh_GetNullComponent();
    recogObjects.hAcMod			= lh_GetNullObj();

    for(curCtx=0; curCtx<sizeof(recogObjects.hCtx)/sizeof(recogObjects.hCtx[0]); curCtx++){
        recogObjects.hCtx[curCtx]       = lh_GetNullObj();
        recogObjects.hResults[curCtx]   = lh_GetNullObj();
    }

    recogObjects.hRec           = lh_GetNullObj();
    recogObjects.hLex			= lh_GetNullObj();
    recogObjects.hDdg2p			= lh_GetNullObj();
    recogObjects.hClc			= lh_GetNullObj();
    recogObjects.hCache			= lh_GetNullObj();
    recogObjects.hDct			= lh_GetNullObj();
    recogObjects.hUswCtx		= lh_GetNullObj();
    recogObjects.hUswResult		= lh_GetNullObj();
    recogObjects.sampleFreq		= 0;
    recogObjects.requestCancel  = 0;
    recogObjects.pTerminals		= NULL;
    recogObjects.terminals_count= 0;
    recogObjects.pSlots			= NULL;
    recogObjects.slots_count	= 0;
    recogObjects.staticCtxID    = NULL;

    // Construct all components and objects needed for recognition.
    // Connect the audiochain objects.
    if (acmod) {
        // initialize components
        // Create a base and an ASR component. (+pron for dyn ctx)
        if(LH_OK != lh_InitBase(&HeapInterface, recogObjects.pHeapInst, LhErrorCallBack, NULL, &recogObjects.hCompBase))
            goto error;
        if(LH_OK != lh_InitAsr(recogObjects.hCompBase, &HeapInterface, recogObjects.pHeapInst, &recogObjects.hCompAsr))
            goto error;
        if(LH_OK != lh_InitPron(recogObjects.hCompBase, &HeapInterface, recogObjects.pHeapInst, &recogObjects.hCompPron))
            goto error;
        rc = ConstructRecognizer(&recogObjects, acmod, ddg2p, clc, dct, dynctx);
        if (rc<0) goto error;
    }

    return rc;

error:
    // An error occured. Close the engine.
    CloseOnError(&recogObjects);
    return -1;
}

int ASR_UnInitialize(void)
{
    int rc;

    // Disconnects the audiochain objects.
    // Closes all objects and components of the vocon recognizer.
    rc = DestroyRecognizer(&recogObjects);

    // Close the PRON component.
    lh_ComponentTerminate(&recogObjects.hCompPron);
    // Close the ASR and Base component.
    lh_ComponentTerminate(&recogObjects.hCompAsr);
    lh_ComponentTerminate(&recogObjects.hCompBase);

    return 0;
}

int evt_HandleEvent(void *pEvtInst, unsigned long type, LH_TIME timeMs) {
    RECOG_OBJECTS *pRecogObjects = (RECOG_OBJECTS*)pEvtInst;
    if ( type & LH_AUDIOCHAIN_EVENT_BOS ){
        // ask upper level for beep
        printf ("Receiving event LH_AUDIOCHAIN_EVENT_BOS at time %d ms.\n", timeMs);
    }

    if ( type & LH_AUDIOCHAIN_EVENT_TS_FX )   {
        printf ("Receiving event LH_AUDIOCHAIN_EVENT_TS_FX at time %d ms.\n", timeMs);
    }

    if ( type & LH_AUDIOCHAIN_EVENT_TS_REC )   {
        printf ("Receiving event LH_AUDIOCHAIN_EVENT_TS_REC at time %d ms.\n", timeMs);
    }
    if ( type & LH_AUDIOCHAIN_EVENT_FX_ABNORMCOND )   {
        LH_ERROR         lhErr = LH_OK;
        LH_FX_ABNORMCOND abnormCondition;
        printf ("Receiving event LH_AUDIOCHAIN_EVENT_FX_ABNORMCOND at time %d ms.\n", timeMs);
        // Find out what the exact abnormal condition is.
        lhErr = lh_FxGetAbnormCondition(pRecogObjects->hRec, &abnormCondition);
        if (LH_OK != lhErr) goto error;

        switch (abnormCondition) {
    case LH_FX_BADSNR:
        printf ("Abnormal condition: LH_FX_BADSNR.\n");
        break;
    case LH_FX_OVERLOAD:
        printf ("Abnormal condition: LH_FX_OVERLOAD.\n");
        break;
    case LH_FX_TOOQUIET:
        printf ("Abnormal condition: LH_FX_TOOQUIET.\n");
        break;
    case LH_FX_NOSIGNAL:
        printf ("Abnormal condition: LH_FX_NOSIGNAL.\n");
        break;
    case LH_FX_POORMIC:
        printf ("Abnormal condition: LH_FX_POORMIC.\n");
        break;
    case LH_FX_NOLEADINGSILENCE:
        printf ("Abnormal condition: LH_FX_NOLEADINGSILENCE.\n");
        break;
        }
    }

    // LH_AUDIOCHAIN_EVENT_FX_TIMER
    // It usually is used to get the signal level and SNR at regular intervals.
    if ( type & LH_AUDIOCHAIN_EVENT_FX_TIMER )   {
        LH_ERROR            lhErr = LH_OK;
        LH_FX_SIGNAL_LEVELS SignalLevels;
        printf ("Receiving event LH_AUDIOCHAIN_EVENT_FX_TIMER at time %d ms.\n", timeMs);
        lhErr = lh_FxGetSignalLevels(pRecogObjects->hRec, &SignalLevels);
        if (LH_OK != lhErr) goto error;
        printf ("Signal level: %ddB, SNR: %ddB at time %dms.\n", SignalLevels.energy, SignalLevels.SNR, SignalLevels.timeMs);
    }


    // LH_AUDIOCHAIN_EVENT_RESULT
    if ( type & LH_AUDIOCHAIN_EVENT_RESULT ){
        LH_ERROR         lhErr = LH_OK;
        LH_OBJECT        hNBestRes = lh_GetNullObj();
        LH_OBJECT        hCtx      = lh_GetNullObj();
        printf ("Receiving event LH_AUDIOCHAIN_EVENT_RESULT at time %d ms.\n", timeMs);

        // Get the NBest result object and process it.
        lhErr = lh_RecCreateResult (pRecogObjects->hRec, &hNBestRes);
        if (LH_OK == lhErr) {
            if (LH_OK == lh_ResultBorrowSourceCtx(hNBestRes, &hCtx)){
                int i;
                int _ready = 0;
                for(i=0; i<sizeof(pRecogObjects->hCtx)/sizeof(pRecogObjects->hCtx[0]); i++){
                    if(!lh_ObjIsNull(pRecogObjects->hCtx[i])){
                        if(hCtx.pObj == pRecogObjects->hCtx[i].pObj){
                            if(!lh_ObjIsNull(pRecogObjects->hResults[i])){
                                lh_ObjClose(&pRecogObjects->hResults[i]);
                            }
                            pRecogObjects->hResults[i] = hNBestRes;
                            hNBestRes = lh_GetNullObj();
                            _ready = 1;
                            break;
                        }
                    } else {
                        break;
                    }
                }
                if (_ready) {
                    for (i=0; i<sizeof(pRecogObjects->hCtx)/sizeof(pRecogObjects->hCtx[0]); i++) {
                        if(!lh_ObjIsNull(pRecogObjects->hCtx[i])){
                            if(lh_ObjIsNull(pRecogObjects->hResults[i])){
                                _ready = 0;
                            }
                        }
                    }
                }

                ASSERT(lh_ObjIsNull(hNBestRes));
                if (_ready) {
                    ProcessResult (pRecogObjects);
                    for(i=0; i<sizeof(pRecogObjects->hResults)/sizeof(pRecogObjects->hResults[0]); i++){
                        if(!lh_ObjIsNull(pRecogObjects->hResults[i])){
                            lh_ObjClose(&pRecogObjects->hResults[i]);
                        }
                    }
                }
            }
            // Close the NBest result object.
        }
    }

    return 0;

error:
    return -1;

}

static int ProcessResult (RECOG_OBJECTS   *pRecogObjects) {
    LH_ERROR  lhErr = LH_OK;
    size_t    curCtx, i, k, count=0;
    size_t    nbrHypothesis;
    ASRResult *r = NULL;
    long lid;

    // get total hyp count
    for(curCtx=0; curCtx<sizeof(pRecogObjects->hCtx)/sizeof(pRecogObjects->hCtx[0]); curCtx++){
        if(!lh_ObjIsNull(pRecogObjects->hResults[curCtx])){
            if(LH_OK == lh_NBestResultGetNbrHypotheses (pRecogObjects->hResults[curCtx], &nbrHypothesis)){
                count += nbrHypothesis;
            }
        }
    }

    // traces
    printf ("\n");
    printf (" __________RESULT %3d items max_______________\n", count);
    printf ("|        |        |\n");
    printf ("| result | confi- | result string [start rule]\n");
    printf ("| number | dence  |\n");
    printf ("|________|________|___________________________\n");
    printf ("|        |        |\n");

    if (count>0) {
        r = ASRResult_New(count);
        // Get & print out the result information for each hypothesis.
        count = 0;
        curCtx = sizeof(pRecogObjects->hCtx)/sizeof(pRecogObjects->hCtx[0]);
        for(; curCtx>0; curCtx--){
            LH_OBJECT hNBestRes = pRecogObjects->hResults[curCtx-1];
            if(!lh_ObjIsNull(hNBestRes)){
                LH_HYPOTHESIS   *pHypothesis;
                if(LH_OK == lh_NBestResultGetNbrHypotheses (hNBestRes, &nbrHypothesis)){
                    for (i = 0; i < nbrHypothesis; i++) {
                        char            *szResultWords;
                        // Retrieve information on the recognition result.
                        if (LH_OK == lh_NBestResultFetchHypothesis (hNBestRes, i, &pHypothesis)){
                            // Get the result string.
                            if (LH_OK == lh_NBestResultFetchWords (hNBestRes, i, &szResultWords)){
                                printf ("| %6lu | %6lu | '%s' [%s]\n", i, pHypothesis->conf, szResultWords, pHypothesis->szStartRule);
                                // Return the fetched data to the engine.
                                lh_NBestResultReturnWords (hNBestRes, szResultWords);
                            }
                            lh_NBestResultReturnHypothesis (hNBestRes, pHypothesis);
                        }
                    }
                }
            }
        }
    }
    // traces
    printf ("|________|________|___________________________\n");
    printf ("\n");
    return 0;
}