/*
 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
 *
 * 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 picosig.c
 *
 * Signal Generation PU - Implementation
 *
 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
 * All rights reserved.
 *
 * History:
 * - 2009-04-20 -- initial version
 *
 */

#include "picoos.h"
#include "picodsp.h"
#include "picosig2.h"
#include "picodata.h"
#include "picosig.h"
#include "picodbg.h"
#include "picokpdf.h"

#ifdef __cplusplus
extern "C" {
#endif
#if 0
}
#endif

#define PICOSIG_IN_BUFF_SIZE PICODATA_BUFSIZE_SIG   /*input buffer size for SIG */
#define PICOSIG_OUT_BUFF_SIZE PICODATA_BUFSIZE_SIG  /*output buffer size for SIG*/

#define PICOSIG_COLLECT     0
#define PICOSIG_SCHEDULE    1
#define PICOSIG_PLAY        2
#define PICOSIG_PROCESS     3
#define PICOSIG_FEED        4

/*----------------------------------------------------------
 // Internal function declarations
 //---------------------------------------------------------*/

static picodata_step_result_t sigStep(register picodata_ProcessingUnit this,
        picoos_int16 mode, picoos_uint16 * numBytesOutput);

/*----------------------------------------------------------
 // Name    :   sig_subobj
 // Function:   subobject definition for the sig processing
 // Shortcut:   sig
 //---------------------------------------------------------*/
typedef struct sig_subobj
{
    /*----------------------PU voice management------------------------------*/
    /* picorsrc_Voice voice; */
    /*----------------------PU state management------------------------------*/
    picoos_uint8 procState; /* where to take up work at next processing step */
    picoos_uint8 retState;  /* where to return after next processing step */
    picoos_uint8 needMoreInput; /* more data necessary to start processing   */
    /*----------------------PU input management------------------------------*/
    picoos_uint8 inBuf[PICOSIG_IN_BUFF_SIZE]; /* internal input buffer */
    picoos_uint16 inBufSize;/* actually allocated size */
    picoos_uint16 inReadPos, inWritePos; /* next pos to read/write from/to inBuf*/
    /*Input audio file management*/
    picoos_char sInSDFileName[255];
    picoos_SDFile sInSDFile;
    picoos_uint32 sInSDFilePos;
    /*----------------------PU output management-----------------------------*/
    picoos_uint8 outBuf[PICOSIG_OUT_BUFF_SIZE]; /* internal output buffer */
    picoos_uint16 outBufSize;                /* actually allocated size */
    picoos_uint16 outReadPos, outWritePos;  /* next pos to read/write from/to outBuf*/
    picoos_bool outSwitch;                  /* output destination switch 0:buffer, 1:file*/
    picoos_char sOutSDFileName[255];        /* output file name */
    picoos_SDFile sOutSDFile;               /* output file handle */
    picoos_single fSampNorm;                /* running normalization factor */
    picoos_uint32 nNumFrame;                /* running count for frame number in output items */
    /*---------------------- other working variables ---------------------------*/
    picoos_uint8 innerProcState; /*where to take up work at next processing step*/
    /*-----------------------Definition of the local storage for this PU--------*/
    sig_innerobj_t sig_inner;
    picoos_single pMod; /*pitch modifier*/
    picoos_single vMod; /*Volume modifier*/
    picoos_single sMod; /*speaker modifier*/
    /*knowledge bases */
    picokpdf_PdfMUL pdflfz, pdfmgc;
    picoos_uint32 scmeanpowLFZ, scmeanpowMGC;
    picoos_uint32 scmeanLFZ, scmeanMGC;
    picokpdf_PdfPHS pdfphs;

} sig_subobj_t;

/* ******************************************************************************
 *   generic PU management
 ********************************************************************************/

/**
 * initialization of the PU (processing unit)
 * @param    this : sig PU object
 * @return  PICO_OK : init ok
 * @return  PICO_ERR_OTHER : init failed
 * @callgraph
 * @callergraph
 */
static pico_status_t sigInitialize(register picodata_ProcessingUnit this)
{
    sig_subobj_t *sig_subObj;
    if (NULL == this || NULL == this->subObj) {
        return PICO_ERR_OTHER;
    }
    sig_subObj = (sig_subobj_t *) this->subObj;
    sig_subObj->inBufSize = PICOSIG_IN_BUFF_SIZE;
    sig_subObj->outBufSize = PICOSIG_OUT_BUFF_SIZE;
    sig_subObj->inReadPos = 0;
    sig_subObj->inWritePos = 0;
    sig_subObj->outReadPos = 0;
    sig_subObj->outWritePos = 0;
    sig_subObj->needMoreInput = 0;
    sig_subObj->procState = PICOSIG_COLLECT;
    sig_subObj->retState = PICOSIG_COLLECT;
    sig_subObj->innerProcState = 0;
    sig_subObj->nNumFrame = 0;

    /*-----------------------------------------------------------------
     * MANAGE Item I/O control management
     ------------------------------------------------------------------*/
    sig_subObj->sInSDFile = NULL;
    sig_subObj->sInSDFilePos = 0;
    sig_subObj->sInSDFileName[0] = '\0';
    sig_subObj->outSwitch = 0; /*PU sends output to buffer (nextPU)*/
    sig_subObj->sOutSDFile = NULL;
    sig_subObj->sOutSDFileName[0] = '\0';
    sig_subObj->nNumFrame = 0;

    /*-----------------------------------------------------------------
     * MANAGE LINGWARE INITIALIZATION IF NEEDED
     ------------------------------------------------------------------*/
    sig_subObj->pdfmgc = picokpdf_getPdfMUL(
            this->voice->kbArray[PICOKNOW_KBID_PDF_MGC]);
    sig_subObj->pdflfz = picokpdf_getPdfMUL(
            this->voice->kbArray[PICOKNOW_KBID_PDF_LFZ]);
    sig_subObj->pdfphs = picokpdf_getPdfPHS(
            this->voice->kbArray[PICOKNOW_KBID_PDF_PHS]);

    sig_subObj->scmeanpowLFZ = sig_subObj->pdflfz->bigpow
            - sig_subObj->pdflfz->meanpow;
    sig_subObj->scmeanpowMGC = sig_subObj->pdfmgc->bigpow
            - sig_subObj->pdfmgc->meanpow;
    sig_subObj->scmeanLFZ = (1 << (picoos_uint32) sig_subObj->scmeanpowLFZ);
    sig_subObj->scmeanMGC = (1 << (picoos_uint32) sig_subObj->scmeanpowMGC);
    sig_subObj->fSampNorm = PICOSIG_NORM1 * sig_subObj->pdfmgc->amplif;

    /*-----------------------------------------------------------------
     * Initialize memory for DSP
     * ------------------------------------------------------------------*/
    sigDspInitialize(&(sig_subObj->sig_inner));

    /*-----------------------------------------------------------------
     * Initialize modifiers
     * ------------------------------------------------------------------*/
    /*pitch , volume , speaker modifiers*/
    sig_subObj->pMod = 1.0f;
    sig_subObj->vMod = 1.0f;
    sig_subObj->sMod = 1.0f;

    return PICO_OK;
}/*sigInitialize*/

/**
 * terminates the PU (processing unit)
 * @param    this : sig PU object
 * @return  PICO_OK : termination ok
 * @return  PICO_ERR_OTHER : termination failed
 * @callgraph
 * @callergraph
 */
static pico_status_t sigTerminate(register picodata_ProcessingUnit this)
{

    sig_subobj_t *sig_subObj;
    if (NULL == this || NULL == this->subObj) {
        return PICO_ERR_OTHER;
    }
    sig_subObj = (sig_subobj_t *) this->subObj;

    return PICO_OK;
}/*sigTerminate*/

/**
 * deallocates the PU (processing unit) sub object
 * @param    this : sig PU object
 * @param    mm : the engine memory manager
 * @return  PICO_OK : deallocation ok
 * @return  PICO_ERR_OTHER : deallocation failed
 * @callgraph
 * @callergraph
 */
static pico_status_t sigSubObjDeallocate(register picodata_ProcessingUnit this,
        picoos_MemoryManager mm)
{
    sig_subobj_t *sig_subObj;
    if ((NULL == this) || ((this)->subObj == NULL)) {
        return PICO_ERR_OTHER;
    }
    sig_subObj = (sig_subobj_t *) (this)->subObj;

    if (sig_subObj->sInSDFile != NULL) {
        picoos_sdfCloseIn(this->common, &(sig_subObj->sInSDFile));
        sig_subObj->sInSDFile = NULL;
        sig_subObj->sInSDFileName[0] = '\0';
    }

    if (sig_subObj->sOutSDFile != NULL) {
        picoos_sdfCloseOut(this->common, &(sig_subObj->sOutSDFile));
        sig_subObj->sOutSDFile = NULL;
        sig_subObj->sOutSDFileName[0] = '\0';
    }

    sigDeallocate(mm, &(sig_subObj->sig_inner));

    picoos_deallocate(this->common->mm, (void *) &this->subObj);

    return PICO_OK;
}/*sigSubObjDeallocate*/

/**
 * creates a new sig processing unit
 * @param    mm : the engine memory manager
 * @param    common : the engine common object
 * @param    cbIn : the PU input buffer
 * @param    cbOut : the PU output buffer
 * @param    voice : the voice descriptor object
 * @return  a valid PU handle if creation is OK
 * @return  NULL if creation is !=OK
 * @callgraph
 * @callergraph
 */
picodata_ProcessingUnit picosig_newSigUnit(picoos_MemoryManager mm,
        picoos_Common common, picodata_CharBuffer cbIn,
        picodata_CharBuffer cbOut, picorsrc_Voice voice)
{
    sig_subobj_t *sig_subObj;

    picodata_ProcessingUnit this = picodata_newProcessingUnit(mm, common, cbIn,
            cbOut, voice);
    if (NULL == this) {
        return NULL;
    }
    this->initialize = sigInitialize;

    PICODBG_DEBUG(("picosig_newSigUnit -- creating SIG PU"));
    /*Init function pointers*/
    this->step = sigStep;
    this->terminate = sigTerminate;
    this->subDeallocate = sigSubObjDeallocate;
    /*sub obj allocation*/
    this->subObj = picoos_allocate(mm, sizeof(sig_subobj_t));

    if (NULL == this->subObj) {
        PICODBG_ERROR(("Error in Sig Object allocation"));
        picoos_deallocate(mm, (void *) &this);
        return NULL;
    }
    sig_subObj = (sig_subobj_t *) this->subObj;

    /*-----------------------------------------------------------------
     * Allocate memory for DSP inner algorithms
     * ------------------------------------------------------------------*/
    if (sigAllocate(mm, &(sig_subObj->sig_inner)) != 0) {
        PICODBG_ERROR(("Error in Sig Sub Object Allocation"));
         picoos_deallocate(mm, (void *) &this);
        return NULL;
    }

    /*-----------------------------------------------------------------
     * Initialize memory for DSP (this may be re-used elsewhere, e.g.Reset)
     * ------------------------------------------------------------------*/
    if (PICO_OK != sigInitialize(this)) {
        PICODBG_ERROR(("Error in iSig Sub Object initialization"));
        sigDeallocate(mm, &(sig_subObj->sig_inner));
        picoos_deallocate(mm, (void *) &this);
        return NULL;
    }PICODBG_DEBUG(("SIG PU creation succeded!!"));
    return this;
}/*picosig_newSigUnit*/

/**
 * pdf access for phase
 * @param    this : sig object pointer
 * @param    phsIndex : index of phase vectot in the pdf
 * @param    phsVect : pointer to base of array where to store the phase values
 * @param    numComponents : pointer to the variable to store the number of components
 * @return   PICO_OK : pdf retrieved
 * @return   PICO_ERR_OTHER : pdf not retrieved
 * @callgraph
 * @callergraph
 */
static pico_status_t getPhsFromPdf(register picodata_ProcessingUnit this,
        picoos_uint16 phsIndex, picoos_int32 *phsVect,
        picoos_int16 *numComponents)
{
    sig_subobj_t *sig_subObj;
    picokpdf_PdfPHS pdf;
    static int nFrame = 0;

    picoos_uint32 nIndexValue;
    picoos_uint8 *nCurrIndexOffset, *nContent;
    picoos_uint16 nI;

    if (NULL == this || NULL == this->subObj) {
        return PICODATA_PU_ERROR;
    }
    sig_subObj = (sig_subobj_t *) this->subObj;
    pdf = sig_subObj->pdfphs;
    /*check incoming index*/
    if (phsIndex >= pdf->numvectors) {
        return PICODATA_PU_ERROR;
    }
    nCurrIndexOffset = ((picoos_uint8*) pdf->indexBase) + phsIndex * sizeof(picoos_uint32);
    nIndexValue = (0xFF000000 & ((*(nCurrIndexOffset+3)) << 24)) | (0x00FF0000 & ((*(nCurrIndexOffset+2)) << 16)) |
                  (0x0000FF00 & ((*(nCurrIndexOffset+1)) << 8))  | (0x000000FF & ((*nCurrIndexOffset)));
    nContent = pdf->contentBase;
    nContent += nIndexValue;
    *numComponents = (picoos_int16) *nContent++;
    if (*numComponents>PICODSP_PHASEORDER) {
        PICODBG_DEBUG(("WARNING : Frame %d -- Phase vector[%d] Components = %d --> too big\n",  nFrame, phsIndex, *numComponents));
        *numComponents = PICODSP_PHASEORDER;
    }
    for (nI=0; nI<*numComponents; nI++) {
        phsVect[nI] = (picoos_int32) *nContent++;
    }
    for (nI=*numComponents; nI<PICODSP_PHASEORDER; nI++) {
        phsVect[nI] = 0;
    }
    nFrame++;
    return PICO_OK;
}/*getPhsFromPdf*/

/**
 * processes one item with sig algo
 * @param    this : the PU object pointer
 * @param    inReadPos : read position in input buffer
 * @param    numinb : number of bytes in input buffer (including header)
 * @param    outWritePos : write position in output buffer
 * @param    numoutb : number of bytes produced in output buffer
 * @return  PICO_OK : processing successful and terminated
 * @return  PICO_STEP_BUSY : processing successful but still things to do
 * @return  PICO_ERR_OTHER : errors
 * @remarks processes a full input item
 * @remarks input data is one or more item, taken from local storage
 * @remarks output data is one or more item, written in local storage
 * @callgraph
 * @callergraph
 */
static pico_status_t sigProcess(register picodata_ProcessingUnit this,
        picoos_uint16 inReadPos, picoos_uint16 numinb,
        picoos_uint16 outWritePos, picoos_uint16 *numoutb)
{

    register sig_subobj_t * sig_subObj;
    picoos_int16 n_i;
    picoos_int16 n_frames, n_count;
    picoos_int16 *s_data, offset;
    picoos_int32 f_data, mlt, *t1, *tmp1, *tmp2;
    picoos_uint16 tmp_uint16;
    picopal_int16 tmp_int16;
    picoos_uint16 i, cnt;
    picoos_int16 hop_p_half;

    sig_subObj = (sig_subobj_t *) this->subObj;

    numinb = numinb; /* avoid warning "var not used in this function"*/

    /*defaults to 0 for output bytes*/
    *numoutb = 0;

    /*Input buffer contains an item FRAME_PAR*/
    switch (sig_subObj->innerProcState) {

        case 0:
            /*---------------------------------------------
             Shifting old values
             ---------------------------------------------*/
            for (n_count = 0; n_count < CEPST_BUFF_SIZE-1; n_count++) {
                sig_subObj->sig_inner.F0Buff[n_count]=sig_subObj->sig_inner.F0Buff[n_count+1];
                sig_subObj->sig_inner.PhIdBuff[n_count]=sig_subObj->sig_inner.PhIdBuff[n_count+1];
                sig_subObj->sig_inner.VoicingBuff[n_count]=sig_subObj->sig_inner.VoicingBuff[n_count+1];
                sig_subObj->sig_inner.FuVBuff[n_count]=sig_subObj->sig_inner.FuVBuff[n_count+1];
            }
            for (n_count = 0; n_count < PHASE_BUFF_SIZE-1; n_count++) {
                sig_subObj->sig_inner.VoxBndBuff[n_count]=sig_subObj->sig_inner.VoxBndBuff[n_count+1];
            }

            tmp1 = sig_subObj->sig_inner.CepBuff[0];
            for (n_count = 0; n_count < CEPST_BUFF_SIZE-1; n_count++) {
                sig_subObj->sig_inner.CepBuff[n_count]=sig_subObj->sig_inner.CepBuff[n_count+1];
            }
            sig_subObj->sig_inner.CepBuff[CEPST_BUFF_SIZE-1]=tmp1;

            tmp1 = sig_subObj->sig_inner.PhsBuff[0];
            for (n_count = 0; n_count < PHASE_BUFF_SIZE-1; n_count++) {
                sig_subObj->sig_inner.PhsBuff[n_count]=sig_subObj->sig_inner.PhsBuff[n_count+1];
            }
            sig_subObj->sig_inner.PhsBuff[PHASE_BUFF_SIZE-1]=tmp1;

            /*---------------------------------------------
             Frame related initializations
             ---------------------------------------------*/
            sig_subObj->sig_inner.prevVoiced_p = sig_subObj->sig_inner.voiced_p;
            /*---------------------------------------------
             Get input data from PU buffer in internal buffers
             -------------------------------------------------*/
            /*load the phonetic id code*/
            picoos_mem_copy((void *) &sig_subObj->inBuf[inReadPos
                    + sizeof(picodata_itemhead_t)],                   /*src*/
            (void *) &tmp_uint16, sizeof(tmp_uint16));                /*dest+size*/
            sig_subObj->sig_inner.PhIdBuff[CEPST_BUFF_SIZE-1] = (picoos_int16) tmp_uint16; /*store into newest*/
            tmp_uint16 = (picoos_int16) sig_subObj->sig_inner.PhIdBuff[0];                 /*assign oldest*/
            sig_subObj->sig_inner.phId_p = (picoos_int16) tmp_uint16;                      /*assign oldest*/

            /*load pitch values*/
            for (i = 0; i < sig_subObj->pdflfz->ceporder; i++) {
                picoos_mem_copy((void *) &(sig_subObj->inBuf[inReadPos
                        + sizeof(picodata_itemhead_t) + sizeof(tmp_uint16) + 3
                        * i * sizeof(tmp_uint16)]),                   /*src*/
                (void *) &tmp_uint16, sizeof(tmp_uint16));            /*dest+size*/

                sig_subObj->sig_inner.F0Buff[CEPST_BUFF_SIZE-1] = (picoos_int16) tmp_uint16;/*store into newest*/
                tmp_uint16 = (picoos_int16) sig_subObj->sig_inner.F0Buff[0];                /*assign oldest*/

                /*convert in float*/
                sig_subObj->sig_inner.F0_p
                        = (tmp_uint16 ? ((picoos_single) tmp_uint16
                                / sig_subObj->scmeanLFZ) : (picoos_single) 0.0);

                if (sig_subObj->sig_inner.F0_p != (picoos_single) 0.0f) {
                    sig_subObj->sig_inner.F0_p = (picoos_single) exp(
                            (picoos_single) sig_subObj->sig_inner.F0_p);

                }
                /* voicing */
                picoos_mem_copy((void *) &(sig_subObj->inBuf[inReadPos
                        + sizeof(picodata_itemhead_t) + sizeof(tmp_uint16) + 3
                        * i * sizeof(tmp_uint16) + sizeof(tmp_uint16)]),/*src*/
                (void *) &tmp_uint16, sizeof(tmp_uint16));              /*dest+size*/

                sig_subObj->sig_inner.VoicingBuff[CEPST_BUFF_SIZE-1] = (picoos_int16) tmp_uint16;/*store into newest*/
                tmp_uint16 = (picoos_int16) sig_subObj->sig_inner.VoicingBuff[0];                /*assign oldest*/

                sig_subObj->sig_inner.voicing = (picoos_single) ((tmp_uint16
                        & 0x01) * 8 + (tmp_uint16 & 0x0e) / 2)
                        / (picoos_single) 15.0f;

                /* unrectified f0 */
                picoos_mem_copy((void *) &(sig_subObj->inBuf[inReadPos
                        + sizeof(picodata_itemhead_t) + sizeof(tmp_uint16) + 3
                        * i * sizeof(tmp_uint16) + 2 * sizeof(tmp_uint16)]),/*src*/
                (void *) &tmp_uint16, sizeof(tmp_uint16));                  /*dest+size*/

                sig_subObj->sig_inner.FuVBuff[CEPST_BUFF_SIZE-1] = (picoos_int16) tmp_uint16;/*store into newest*/
                tmp_uint16 = (picoos_int16) sig_subObj->sig_inner.FuVBuff[0];                /*assign oldest*/

                sig_subObj->sig_inner.Fuv_p = (picoos_single) tmp_uint16
                        / sig_subObj->scmeanLFZ;
                sig_subObj->sig_inner.Fuv_p = (picoos_single) EXP((double)sig_subObj->sig_inner.Fuv_p);
            }
            /*load cep values*/
            offset = inReadPos + sizeof(picodata_itemhead_t)
                    + sizeof(tmp_uint16) +
                    3 * sig_subObj->pdflfz->ceporder * sizeof(tmp_int16);

            tmp1 = sig_subObj->sig_inner.CepBuff[CEPST_BUFF_SIZE-1];   /*store into CURR */
            tmp2 = sig_subObj->sig_inner.CepBuff[0];                   /*assign oldest*/

            for (i = 0; i < sig_subObj->pdfmgc->ceporder; i++) {
                picoos_mem_copy((void *) &(sig_subObj->inBuf[offset + i
                        * sizeof(tmp_int16)]),                /*src*/
                (void *) &tmp_int16, sizeof(tmp_int16));    /*dest+size*/

                tmp1 [i] = (picoos_int32) tmp_int16;
                sig_subObj->sig_inner.wcep_pI[i] = (picoos_int32) tmp2[i];
            }

            if (sig_subObj->inBuf[inReadPos+ 3] > sig_subObj->inBuf[inReadPos+ 2]*2 + 8) {
                /*load phase values*/
                /*get the index*/
                picoos_mem_copy((void *) &(sig_subObj->inBuf[offset + sig_subObj->pdfmgc->ceporder
                        * sizeof(tmp_int16)]),                /*src*/
                (void *) &tmp_int16, sizeof(tmp_int16));    /*dest+size*/

                /*store into buffers*/
                tmp1 = sig_subObj->sig_inner.PhsBuff[PHASE_BUFF_SIZE-1];
                /*retrieve values from pdf*/
                getPhsFromPdf(this, tmp_int16, tmp1, &(sig_subObj->sig_inner.VoxBndBuff[PHASE_BUFF_SIZE-1]));
            } else {
                /* no support for phase found */
                sig_subObj->sig_inner.VoxBndBuff[PHASE_BUFF_SIZE-1] = 0;
            }

            /*pitch modifier*/
            sig_subObj->sig_inner.F0_p *= sig_subObj->pMod;
            sig_subObj->sig_inner.Fuv_p *= sig_subObj->pMod;
            if (sig_subObj->sig_inner.F0_p > 0.0f) {
                sig_subObj->sig_inner.voiced_p = 1;
            } else {
                sig_subObj->sig_inner.voiced_p = 0;
            }
            sig_subObj->sig_inner.n_available++;
            if (sig_subObj->sig_inner.n_available>3)  sig_subObj->sig_inner.n_available = 3;

            if (sig_subObj->sig_inner.n_available < 3) {
                return PICO_STEP_BUSY;
            }

            sig_subObj->innerProcState = 3;
            return PICO_STEP_BUSY;

        case 3:
            /*Convert from mfcc to power spectrum*/
            save_transition_frame(&(sig_subObj->sig_inner));
            mel_2_lin_lookup(&(sig_subObj->sig_inner), sig_subObj->scmeanpowMGC);
            sig_subObj->innerProcState += 1;
            return PICO_STEP_BUSY;

        case 4:
            /*Reconstruct PHASE SPECTRUM */
            phase_spec2(&(sig_subObj->sig_inner));
            sig_subObj->innerProcState += 1;
            return PICO_STEP_BUSY;

        case 5:
            /*Prepare Envelope spectrum for inverse FFT*/
            env_spec(&(sig_subObj->sig_inner));
            sig_subObj->innerProcState += 1;
            return PICO_STEP_BUSY;

        case 6:
            /*Generate the impulse response of the vocal tract */
            impulse_response(&(sig_subObj->sig_inner));
            sig_subObj->innerProcState += 1;
            return PICO_STEP_BUSY;

        case 7:
            /*Sum up N impulse responses according to excitation  */
            td_psola2(&(sig_subObj->sig_inner));
            sig_subObj->innerProcState += 1;
            return PICO_STEP_BUSY;

        case 8:
            /*Ovladd */
            overlap_add(&(sig_subObj->sig_inner));
            sig_subObj->innerProcState += 1;
            return PICO_STEP_BUSY;

        case 9:
            /*-----------------------------------------
             Save the output FRAME item (0:hop-1)
             swap remaining buffer
             ---------------------------------------------*/
            n_frames = 2;
            *numoutb = 0;
            hop_p_half = (sig_subObj->sig_inner.hop_p) / 2;
            for (n_count = 0; n_count < n_frames; n_count++) {
                sig_subObj->outBuf[outWritePos]
                        = (picoos_uint8) PICODATA_ITEM_FRAME;
                sig_subObj->outBuf[outWritePos + 1]
                        = (picoos_uint8) (hop_p_half);
                sig_subObj->outBuf[outWritePos + 2]
                        = (picoos_uint8) (sig_subObj->nNumFrame % ((hop_p_half)));
                sig_subObj->outBuf[outWritePos + 3]
                        = (picoos_uint8) sig_subObj->sig_inner.hop_p;
                s_data = (picoos_int16 *) &(sig_subObj->outBuf[outWritePos + 4]);

                /*range control and clipping*/
                mlt = (picoos_int32) ((sig_subObj->fSampNorm * sig_subObj->vMod)
                        * PICODSP_END_FLOAT_NORM);
                t1 = &(sig_subObj->sig_inner.WavBuff_p[n_count * (hop_p_half)]);
                for (n_i = 0; n_i < hop_p_half; n_i++) { /*Normalization*/
                    f_data = *t1++ * mlt;
                    if (f_data >= 0)
                        f_data >>= 14;
                    else
                        f_data = -(-f_data >> 14);
                    if (f_data > PICOSIG_MAXAMP)
                        f_data = PICOSIG_MAXAMP;
                    if (f_data < PICOSIG_MINAMP)
                        f_data = PICOSIG_MINAMP;
                    *s_data = (picoos_int16) (f_data);
                    s_data++;
                }
                sig_subObj->nNumFrame = sig_subObj->nNumFrame + 1;
                *numoutb += ((picoos_int16) n_i * sizeof(picoos_int16)) + 4;
                outWritePos += *numoutb;
            }/*end for n_count*/
            /*Swap remaining buffer*/
            cnt = sig_subObj->sig_inner.m2_p - sig_subObj->sig_inner.hop_p;
            tmp1 = sig_subObj->sig_inner.WavBuff_p;
            tmp2
                    = &(sig_subObj->sig_inner.WavBuff_p[sig_subObj->sig_inner.hop_p]);
            FAST_DEVICE(cnt,*(tmp1++)=*(tmp2++);)
            ;
            cnt = sig_subObj->sig_inner.m2_p - (sig_subObj->sig_inner.m2_p
                    - sig_subObj->sig_inner.hop_p);
            FAST_DEVICE(cnt,*(tmp1++)=0;)
            ;
            sig_subObj->innerProcState = 0; /*reset to step 0*/
            sig_subObj->nNumFrame += 2;
            return PICO_OK;
        default:
            return PICO_ERR_OTHER;
    }
    return PICO_ERR_OTHER;
}/*sigProcess*/

/**
 * selects items to be dealth with by this PU
 * @param    item : pointer to current item head
 * @return  TRUE : item should be managed
 * @return  FALSE : item should be passed on next PU
 * @remarks item pointed to by *item should be already valid
 * @callgraph
 * @callergraph
 */
static pico_status_t sig_deal_with(const picoos_uint8 *item)
{
    picodata_itemhead_t head;
    pico_status_t s_result;
    s_result = FALSE;
    head.type = item[0];
    head.info1 = item[1];
    head.info2 = item[2];
    head.len = item[3];
    switch (head.type) {
        case PICODATA_ITEM_FRAME_PAR:
            /*the only item that is managed by sig, so far, is "FRAME_PAR"*/
            s_result = TRUE;
            break;
        case PICODATA_ITEM_CMD:
            if ((head.info1 == PICODATA_ITEMINFO1_CMD_PLAY) || (head.info1
                    == PICODATA_ITEMINFO1_CMD_SAVE) || (head.info1
                    == PICODATA_ITEMINFO1_CMD_UNSAVE)) {
                if (head.info2 == PICODATA_ITEMINFO2_CMD_TO_SIG) {
                    return TRUE;
                }
            }
            if ((head.info1 == PICODATA_ITEMINFO1_CMD_PITCH) || (head.info1
                    == PICODATA_ITEMINFO1_CMD_VOLUME) || (head.info1
                    == PICODATA_ITEMINFO1_CMD_SPEAKER)) {
                return TRUE;
            }
            break;
        default:
            break;
    }
    return s_result;
} /*sig_deal_with*/

/**
 * selects items to be managed as commands by this PU
 * @param    item : pointer to current item head
 * @return  TRUE : item should be managed as a command
 * @return  FALSE : item is not a PU command
 * @remarks item pointed to by *item should be already valid
 * @callgraph
 * @callergraph
 */
static pico_status_t sig_is_command(const picoos_uint8 *item)
{
    picodata_itemhead_t head;
    head.type = item[0];
    head.info1 = item[1];
    head.info2 = item[2];
    head.len = item[3];
    switch (head.type) {
        case PICODATA_ITEM_CMD:
            if ((head.info1 == PICODATA_ITEMINFO1_CMD_PLAY) || (head.info1
                    == PICODATA_ITEMINFO1_CMD_SAVE) || (head.info1
                    == PICODATA_ITEMINFO1_CMD_UNSAVE)) {
                if (head.info2 == PICODATA_ITEMINFO2_CMD_TO_SIG) {
                    return TRUE;
                }
            }
            if ((head.info1 == PICODATA_ITEMINFO1_CMD_PITCH) || (head.info1
                    == PICODATA_ITEMINFO1_CMD_VOLUME) || (head.info1
                    == PICODATA_ITEMINFO1_CMD_SPEAKER)) {
                return TRUE;
            }
            break;
        default:
            break;
    }
    return FALSE;
} /*sig_is_command*/

/**
 * performs a step of the sig processing
 * @param    this : pointer to current PU (Control Unit)
 * @param    mode : mode for the PU
 * @param    numBytesOutput : pointer to number of bytes produced (output)
 * @param    this : pointer to current PU (Control Unit)
 * @return  one of the "picodata_step_result_t" values
 * @callgraph
 * @callergraph
 */
static picodata_step_result_t sigStep(register picodata_ProcessingUnit this,
        picoos_int16 mode, picoos_uint16 * numBytesOutput)
{
    register sig_subobj_t * sig_subObj;
    pico_status_t s_result;
    picoos_bool b_res;
    pico_status_t s_deal_with;
    picoos_uint16 blen;
    picoos_uint16 numinb, numoutb;
    pico_status_t rv;
    picoos_int16 *s_data;
    picoos_int16 hop_p_half;
    picoos_uint32 n_samp, n_i;
    picoos_char s_temp_file_name[255];
    picoos_uint32 n_start, n_fram, n_bytes;
    picoos_single f_value;
    picoos_uint16 n_value;
    picoos_uint32 n_pos;
    /*wav file play volume control*/
    picoos_int16 *s_t1;
    picoos_int32 sf_data, sf_mlt;
    picoos_uint32 sf;
    picoos_encoding_t enc;
    picoos_uint32 numSamples;

    numinb = 0;
    numoutb = 0;
    rv = PICO_OK;
    s_result = PICO_OK;

    if (NULL == this || NULL == this->subObj) {
        return PICODATA_PU_ERROR;
    }
    sig_subObj = (sig_subobj_t *) this->subObj;

    /*Init number of output bytes*/
    *numBytesOutput = 0;

    mode = mode; /* avoid warning "var not used in this function" */

    while (1) { /* exit via return */

        PICODBG_DEBUG(("picosig.sigStep -- doing state %i",sig_subObj->procState));

        switch (sig_subObj->procState) {

            case PICOSIG_COLLECT:
                /* ************** item collector ***********************************/
                /*collecting items from the PU input buffer*/
                s_result = picodata_cbGetItem(this->cbIn,
                        &(sig_subObj->inBuf[sig_subObj->inWritePos]),
                        sig_subObj->inBufSize - sig_subObj->inWritePos, &blen);

                PICODBG_DEBUG(("picosig.sigStep -- got item, status: %d",rv));

                if (s_result == PICO_EOF) {
                    /*no items available : remain in state 0 and return idle*/
                    return PICODATA_PU_IDLE;
                }
                if ((PICO_OK == s_result) && (blen > 0)) {
                    /* we now have one item : CHECK IT */
                    s_result = picodata_is_valid_item(
                            &(sig_subObj->inBuf[sig_subObj->inWritePos]), blen);
                    if (s_result != TRUE) {
                        PICODBG_DEBUG(("picosig.sigStep -- item is not valid: discard"));
                        /*Item not valid : remain in state PICOSIG_COLLECT*/
                        return PICODATA_PU_BUSY;
                    }
                    /*item ok: it could be sent to schedule state*/
                    sig_subObj->inWritePos += blen;
                    sig_subObj->needMoreInput = FALSE;
                    sig_subObj->procState = PICOSIG_SCHEDULE;
                    /* uncomment next to split into two steps */
                    return PICODATA_PU_ATOMIC;
                }
                /*no EOF, no OK --> errors : remain in state PICOSIG_COLLECT and return error*/
                return PICODATA_PU_ERROR;
                break;

            case PICOSIG_SCHEDULE:
                /* *************** item processing ***********************************/
                numinb = PICODATA_ITEM_HEADSIZE
                        + sig_subObj->inBuf[sig_subObj->inReadPos + 3];

                /*verify that current item has to be dealth with by this PU*/
                s_deal_with = sig_deal_with(
                        &(sig_subObj->inBuf[sig_subObj->inReadPos]));

                switch (s_deal_with) {

                    case TRUE:
                        /* we have to manage this item */
                        if (FALSE == sig_is_command(
                                &(sig_subObj->inBuf[sig_subObj->inReadPos])))
                        {
                            /*no commands, item to deal with : switch to process state*/
                            sig_subObj->procState = PICOSIG_PROCESS;
                            sig_subObj->retState = PICOSIG_COLLECT;
                            return PICODATA_PU_BUSY; /*data still to process or to feed*/

                        } else {

                            /*we need to manage this item as a SIG command-item*/

                            switch (sig_subObj->inBuf[sig_subObj->inReadPos + 1]) {

                                case PICODATA_ITEMINFO1_CMD_PLAY:
                                    /*CMD recognized : consume the command */
                                    sig_subObj->inReadPos += numinb;
                                    if (sig_subObj->inReadPos
                                            >= sig_subObj->inWritePos) {
                                        sig_subObj->inReadPos = 0;
                                        sig_subObj->inWritePos = 0;
                                    }
                                    /*default next state setting*/
                                    sig_subObj->procState =
                                       sig_subObj->retState = PICOSIG_COLLECT;

                                    /*--------- wav file play management --------------*/
                                    if (sig_subObj->sInSDFile != NULL) {
                                        /*input wav file is already open : return*/
                                        return PICODATA_PU_BUSY;
                                    }
                                    /*get temp file name*/
                                    picoos_strlcpy(
                                            (picoos_char*) s_temp_file_name,
                                            (picoos_char*) &(sig_subObj->inBuf[sig_subObj->inReadPos
                                                    + 4]),
                                            sig_subObj->inBuf[sig_subObj->inReadPos
                                                    + 3] + 1);
                                    /*avoid input/output file name clashes*/
                                    if (sig_subObj->sOutSDFile != NULL) {
                                        if (picoos_strncmp(
                                                (picoos_char*) s_temp_file_name,
                                                (picoos_char*) sig_subObj->sOutSDFileName,
                                                picoos_strlen(
                                                        (picoos_char*) s_temp_file_name))
                                                == 0) {
                                            PICODBG_WARN(("input and output files has the same name!\n"));
                                            return PICODATA_PU_BUSY;
                                        }
                                    }
                                    /*actual sampled data file open*/
                                    b_res = picoos_sdfOpenIn(this->common,
                                                &(sig_subObj->sInSDFile),
                                        s_temp_file_name, &sf,
                                                &enc, &numSamples);
                                    if (b_res != TRUE) {
                                        PICODBG_DEBUG(("Error on opening file %s\n", s_temp_file_name));
                                        sig_subObj->sInSDFile = NULL;
                                        sig_subObj->sInSDFileName[0] = '\0';
                                        return PICODATA_PU_BUSY;
                                    }
                                    /*input file handle is now valid : store filename*/
                                    picoos_strlcpy(
                                            (picoos_char*) sig_subObj->sInSDFileName,
                                            (picoos_char*) s_temp_file_name,
                                            sig_subObj->inBuf[sig_subObj->inReadPos
                                                    + 3] + 1);
                                    sig_subObj->sInSDFilePos = 0;
                                    /*switch to state PLAY and return*/
                                    sig_subObj->procState =
                                        sig_subObj->retState = PICOSIG_PLAY;
                                    return PICODATA_PU_BUSY;
                                    break;

                                case PICODATA_ITEMINFO1_CMD_SAVE:
                                    /*CMD recognized : consume the command */
                                    sig_subObj->inReadPos += numinb;
                                    if (sig_subObj->inReadPos
                                            >= sig_subObj->inWritePos) {
                                        sig_subObj->inReadPos = 0;
                                        sig_subObj->inWritePos = 0;
                                    }
                                    /*prepare return state*/
                                    sig_subObj->procState = PICOSIG_COLLECT;
                                    sig_subObj->retState = PICOSIG_COLLECT;
                                    /*check about output file*/
                                    if ((sig_subObj->sOutSDFile != NULL)
                                            || (sig_subObj->outSwitch == 1)) {
                                        /*output sig file is already active : return*/
                                        return PICODATA_PU_BUSY;
                                    }
                                    /*get temp file name*/
                                    picoos_strlcpy(
                                            (picoos_char*) s_temp_file_name,
                                            (picoos_char*) &(sig_subObj->inBuf[sig_subObj->inReadPos
                                                    + 4]),
                                            sig_subObj->inBuf[sig_subObj->inReadPos
                                                    + 3] + 1);
                                    /*check extension*/
                                    if (picoos_has_extension(s_temp_file_name,
                                            PICODATA_PUTYPE_WAV_OUTPUT_EXTENSION)
                                            == FALSE){
                                        /*extension unsupported : return*/
                                        return PICODATA_PU_BUSY;
                                    }
                                    /*avoid input/output file name clashes*/
                                    if (sig_subObj->sInSDFile != NULL) {
                                        if (picoos_strncmp(
                                                (picoos_char*) sig_subObj->sInSDFileName,
                                                (picoos_char*) s_temp_file_name,
                                                picoos_strlen(
                                                        (picoos_char*) sig_subObj->sInSDFileName))
                                                == 0) {
                                            /*input and output files has the same name : do not allow opening for writing*/
                                            PICODBG_WARN(("input and output files has the same name!\n"));
                                            return PICODATA_PU_BUSY;
                                        }
                                    }
                                    /*try to open*/
                                    picoos_sdfOpenOut(this->common,
                                            &(sig_subObj->sOutSDFile),
                                            s_temp_file_name,
                                            SAMPLE_FREQ_16KHZ, PICOOS_ENC_LIN);
                                    if (sig_subObj->sOutSDFile == NULL) {
                                        PICODBG_DEBUG(("Error on opening file %s\n", sig_subObj->sOutSDFileName));
                                        sig_subObj->outSwitch = 0;
                                        sig_subObj->sOutSDFileName[0] = '\0';
                                    } else {
                                        /*open OK*/
                                        sig_subObj->outSwitch = 1;
                                        /*store output filename*/
                                        picoos_strlcpy(
                                                (picoos_char*) sig_subObj->sOutSDFileName,
                                                (picoos_char*) s_temp_file_name,
                                                sig_subObj->inBuf[sig_subObj->inReadPos + 3] + 1);
                                    }
                                    return PICODATA_PU_BUSY;
                                    break;

                                case PICODATA_ITEMINFO1_CMD_UNSAVE:
                                    /*CMD recognized : consume the command */
                                    sig_subObj->inReadPos += numinb;
                                    if (sig_subObj->inReadPos
                                            >= sig_subObj->inWritePos) {
                                        sig_subObj->inReadPos = 0;
                                        sig_subObj->inWritePos = 0;
                                    }
                                    /*prepare return state*/
                                    sig_subObj->procState = PICOSIG_COLLECT;
                                    sig_subObj->retState = PICOSIG_COLLECT;
                                    /*close the output file if any*/
                                    if ((sig_subObj->sOutSDFile == NULL)
                                            || (sig_subObj->outSwitch == 0)) {
                                        /*output sig file is not active : return*/
                                        PICODBG_DEBUG(("Error on requesting a binary samples file output closing : no file output handle exist\n"));
                                        return PICODATA_PU_BUSY;
                                    }
                                    picoos_sdfCloseOut(this->common,
                                            &(sig_subObj->sOutSDFile));
                                    sig_subObj->outSwitch = 0;
                                    sig_subObj->sOutSDFile = NULL;
                                    sig_subObj->sOutSDFileName[0] = '\0';
                                    return PICODATA_PU_BUSY;
                                    break;

                                case PICODATA_ITEMINFO1_CMD_PITCH:
                                case PICODATA_ITEMINFO1_CMD_VOLUME:
                                case PICODATA_ITEMINFO1_CMD_SPEAKER:
                                    n_pos = 4;
                                    picoos_read_mem_pi_uint16(
                                            &(sig_subObj->inBuf[sig_subObj->inReadPos]),
                                            &n_pos, &n_value);
                                    b_res = FALSE;
                                    switch (sig_subObj->inBuf[sig_subObj->inReadPos + 2]) {
                                        case 'a' :
                                        /*absloute modifier*/
                                        f_value = (picoos_single) n_value
                                                / (picoos_single) 100.0f;
                                            b_res = TRUE;
                                            break;
                                        case 'r' :
                                            /*relative modifier*/
                                            f_value = (picoos_single) n_value
                                                    / (picoos_single) 1000.0f;
                                            b_res = TRUE;
                                            break;
                                        default :
                                            f_value = (picoos_single)0; /*avoid warnings*/
                                            break;
                                    }
                                    if (b_res) {
                                        switch (sig_subObj->inBuf[sig_subObj->inReadPos + 1]) {
                                            case PICODATA_ITEMINFO1_CMD_PITCH :
                                            sig_subObj->pMod = f_value;
                                                break;
                                            case PICODATA_ITEMINFO1_CMD_VOLUME :
                                            sig_subObj->vMod = f_value;
                                                break;
                                            case PICODATA_ITEMINFO1_CMD_SPEAKER :
                                            sig_subObj->sMod = f_value;
                                            sig_subObj->sig_inner.sMod_p
                                                    = sig_subObj->sMod;
                                            /*call the function needed to initialize the speaker factor*/
                                            mel_2_lin_init(
                                                    &(sig_subObj->sig_inner));
                                                 break;
                                            default :
                                                break;
                                        }
                                    }

                                    /*CMD recognized : consume the command */
                                    sig_subObj->inReadPos += numinb;
                                    if (sig_subObj->inReadPos
                                            >= sig_subObj->inWritePos) {
                                        sig_subObj->inReadPos = 0;
                                        sig_subObj->inWritePos = 0;
                                    }
                                    /*prepare proc state*/
                                    sig_subObj->procState = PICOSIG_COLLECT;
                                    sig_subObj->retState = PICOSIG_COLLECT;
                                    return PICODATA_PU_BUSY;
                                    break;
                                default:
                                    break;
                            }/*switch command type*/
                        } /*end if is command*/
                        break;

                    case FALSE:

                        /*we DO NOT have to deal with this item on this PU.
                         * Normally these are still alive boundary or flush items*/
                        /*copy item from PU input to PU output buffer,
                         * i.e. make it ready to FEED*/
                        s_result = picodata_copy_item(
                                &(sig_subObj->inBuf[sig_subObj->inReadPos]),
                                numinb,
                                &(sig_subObj->outBuf[sig_subObj->outWritePos]),
                                sig_subObj->outBufSize - sig_subObj->outWritePos,
                                &numoutb);
                        if (s_result != PICO_OK) {
                            /*item not prepared properly to be sent to next PU :
                             * do not change state and retry next time*/
                            sig_subObj->procState = PICOSIG_SCHEDULE;
                            sig_subObj->retState = PICOSIG_COLLECT;
                            return PICODATA_PU_BUSY; /*data still to process or to feed*/
                        }

                        /*if end of sentence reset number of frames(only needed for debugging purposes)*/
                        if ((sig_subObj->inBuf[sig_subObj->inReadPos]
                                == PICODATA_ITEM_BOUND)
                                && ((sig_subObj->inBuf[sig_subObj->inReadPos + 1]
                                        == PICODATA_ITEMINFO1_BOUND_SEND)
                                        || (sig_subObj->inBuf[sig_subObj->inReadPos
                                                + 1]
                                                == PICODATA_ITEMINFO1_BOUND_TERM))) {
                            PICODBG_INFO(("End of sentence - Processed frames : %d",
                                            sig_subObj->nNumFrame));
                            sig_subObj->nNumFrame = 0;
                        }

                        /*item processed and put in oputput buffer : consume the item*/
                            sig_subObj->inReadPos += numinb;
                        sig_subObj->outWritePos += numoutb;
                            if (sig_subObj->inReadPos >= sig_subObj->inWritePos) {
                                /* inBuf exhausted */
                                sig_subObj->inReadPos = 0;
                                sig_subObj->inWritePos = 0;
                                sig_subObj->needMoreInput = FALSE;
                            }
                            sig_subObj->procState = PICOSIG_FEED;
                            sig_subObj->retState = PICOSIG_COLLECT;
                        return PICODATA_PU_BUSY; /*data still to process or to feed*/
                        break;

                    default:
                        break;
                }/*end switch s_deal_with*/

                break; /*end case sig_schedule*/

            case PICOSIG_PROCESS:
                /* *************** item processing ***********************************/
                numinb = PICODATA_ITEM_HEADSIZE
                        + sig_subObj->inBuf[sig_subObj->inReadPos + 3];

                /*Process a full item*/
                s_result = sigProcess(this, sig_subObj->inReadPos, numinb,
                        sig_subObj->outWritePos, &numoutb);

                if (s_result == PICO_OK) {
                    sig_subObj->inReadPos += numinb;
                    if (sig_subObj->inReadPos >= sig_subObj->inWritePos) {
                        sig_subObj->inReadPos = 0;
                        sig_subObj->inWritePos = 0;
                        sig_subObj->needMoreInput = FALSE;
                    }
                    sig_subObj->outWritePos += numoutb;
                    sig_subObj->procState = PICOSIG_FEED;
                    sig_subObj->retState = PICOSIG_COLLECT;
                    PICODBG_DEBUG(("picosig.sigStep -- leaving PICO_PROC, inReadPos = %i, outWritePos = %i",sig_subObj->inReadPos, sig_subObj->outWritePos));
                    return PICODATA_PU_BUSY; /*data to feed*/
                }
                return PICODATA_PU_BUSY; /*data still to process : remain in PROCESS STATE*/
                break;

            case PICOSIG_PLAY:

                /*management of wav file play*/
                s_data = (picoos_int16 *) &(sig_subObj->outBuf[sig_subObj->outWritePos + 4]);
                hop_p_half = sig_subObj->sig_inner.hop_p / 2;
                /*read directly into PU output buffer*/
                n_samp = hop_p_half;
                b_res = picoos_sdfGetSamples(sig_subObj->sInSDFile,
                        sig_subObj->sInSDFilePos, &n_samp, s_data);
                sig_subObj->sInSDFilePos += n_samp;

                if ((FALSE == b_res) || (0 == n_samp)) {
                    /*file play is complete or file read error*/
                    picoos_sdfCloseIn(this->common, &(sig_subObj->sInSDFile));
                    sig_subObj->sInSDFile = NULL;
                    sig_subObj->sInSDFileName[0] = '\0';
                    sig_subObj->procState = PICOSIG_COLLECT;
                    sig_subObj->retState = PICOSIG_COLLECT;
                    return PICODATA_PU_BUSY; /*check if data in input buffer*/
                }
                /*-----------------------------------*/
                /*Volume control of wav file playback*/
                /*    (code borrowed from sigProcess)*/
                /*Volume mod and clipping control    */
                /*     directly into PU output buffer*/
                /*-----------------------------------*/
                sf_mlt = (picoos_int32) ((sig_subObj->vMod) * 16.0f);
                s_t1 = &(s_data[0]);

                for (n_i = 0; n_i < n_samp; n_i++) {
                    if (*s_t1 != 0) {
                        sf_data = (picoos_int32) (*s_t1) * sf_mlt;
                        sf_data >>= 4;
                        if (sf_data > PICOSIG_MAXAMP) {
                            sf_data = PICOSIG_MAXAMP;
                        } else if (sf_data < PICOSIG_MINAMP) {
                            sf_data = PICOSIG_MINAMP;
                        }
                        *s_t1 = (picoos_int16) (sf_data);
                    }
                    s_t1++;
                }
                /*Add header info*/
                sig_subObj->outBuf[sig_subObj->outWritePos]
                        = (picoos_uint8) PICODATA_ITEM_FRAME;
                sig_subObj->outBuf[sig_subObj->outWritePos + 1]
                        = (picoos_uint8) n_samp;
                sig_subObj->outBuf[sig_subObj->outWritePos + 2]
                        = (picoos_uint8) (sig_subObj->nNumFrame % (hop_p_half)); /*number of frame % 64*/
                sig_subObj->outBuf[sig_subObj->outWritePos + 3]
                        = (picoos_uint8) n_samp * 2;
                /*Item content*/
                sig_subObj->outWritePos += (n_samp * sizeof(picoos_int16)) + 4; /*including header*/
                sig_subObj->procState = PICOSIG_FEED;
                sig_subObj->retState = PICOSIG_PLAY;
                break;

            case PICOSIG_FEED:
                /* ************** item output/feeding ***********************************/
                switch (sig_subObj->outSwitch) {
                    case 0:
                        /*feeding items to PU output buffer*/
                        s_result = picodata_cbPutItem(this->cbOut,
                                &(sig_subObj->outBuf[sig_subObj->outReadPos]),
                                sig_subObj->outWritePos - sig_subObj->outReadPos,
                                &numoutb);
                        break;
                    case 1:
                        /*feeding items to file*/
                        if (sig_subObj->outBuf[sig_subObj->outReadPos]
                                == PICODATA_ITEM_FRAME) {
                            if ((sig_subObj->sOutSDFile) != NULL) {
                                n_start = (picoos_uint32) (sig_subObj->outReadPos)
                                                + PICODATA_ITEM_HEADSIZE;
                                n_bytes = (picoos_uint32) sig_subObj->outBuf[(sig_subObj->outReadPos)
                                                + PICODATA_ITEMIND_LEN];
                                n_fram = (picoos_uint32) sig_subObj->outBuf[(sig_subObj->outReadPos)
                                                + PICODATA_ITEMIND_INFO2];
                                if (picoos_sdfPutSamples(
                                        sig_subObj->sOutSDFile,
                                        n_bytes / 2,
                                        (picoos_int16*) &(sig_subObj->outBuf[n_start]))) {
                                    PICODBG_DEBUG(("Nframe:%d - Nbytes %d\n", n_fram, n_bytes));
                                    numoutb = n_bytes + 4;
                                    s_result = PICO_OK;
                                    /* also feed item to next PU */
                                    s_result = picodata_cbPutItem(
                                                    this->cbOut,
                                                    &(sig_subObj->outBuf[sig_subObj->outReadPos]),
                                                    sig_subObj->outWritePos
                                                            - sig_subObj->outReadPos,
                                                    &numoutb);
                                } else {
                                    /*write error : close file + cleanup handles*/
                                    if (sig_subObj->sOutSDFile != NULL) {
                                        picoos_sdfCloseOut(this->common, &(sig_subObj->sOutSDFile));
                                        sig_subObj->sOutSDFile = NULL;
                                    }
                                    sig_subObj->sOutSDFileName[0] = '\0';
                                    sig_subObj->outSwitch = 0;
                                    PICODBG_DEBUG(("Error in writing :%d bytes to output file %s\n", numoutb, &(sig_subObj->sOutSDFileName[0])));
                                    s_result = PICO_ERR_OTHER;
                                }
                            }
                        } else {
                            /*continue to feed following PU with items != FRAME */
                            s_result = picodata_cbPutItem(
                                            this->cbOut,
                                            &(sig_subObj->outBuf[sig_subObj->outReadPos]),
                                sig_subObj->outWritePos  - sig_subObj->outReadPos,
                                            &numoutb);
                        }
                        break;
                    default:
                        s_result = PICO_ERR_OTHER;
                        break;
                }
                PICODBG_DEBUG(("picosig.sigStep -- put item, status: %d",s_result));

                if (PICO_OK == s_result) {

                    sig_subObj->outReadPos += numoutb;
                    *numBytesOutput = numoutb;
                    /*-------------------------*/
                    /*reset the output pointers*/
                    /*-------------------------*/
                    if (sig_subObj->outReadPos >= sig_subObj->outWritePos) {
                        sig_subObj->outReadPos = 0;
                        sig_subObj->outWritePos = 0;
                        sig_subObj->procState = sig_subObj->retState;
                    }
                    return PICODATA_PU_BUSY;

                } else if (PICO_EXC_BUF_OVERFLOW == s_result) {

                    PICODBG_DEBUG(("picosig.sigStep ** feeding, overflow, PICODATA_PU_OUT_FULL"));
                    return PICODATA_PU_OUT_FULL;

                } else if ((PICO_EXC_BUF_UNDERFLOW == s_result)
                        || (PICO_ERR_OTHER == s_result)) {

                    PICODBG_DEBUG(("picosig.sigStep ** feeding problem, discarding item"));
                    sig_subObj->outReadPos = 0;
                    sig_subObj->outWritePos = 0;
                    sig_subObj->procState = sig_subObj->retState;
                    return PICODATA_PU_ERROR;

                }
                break;
            default:
                /*NOT feeding items*/
                s_result = PICO_EXC_BUF_IGNORE;
                break;
        }/*end switch*/
        return PICODATA_PU_BUSY; /*check if there is more data to process after feeding*/

    }/*end while*/
    return PICODATA_PU_IDLE;
}/*sigStep*/

#ifdef __cplusplus
}
#endif

/* Picosig.c end */