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

#include "picoos.h"
#include "picodbg.h"
#include "picodata.h"

#include "picoknow.h"
#include "picokfst.h"
#include "picoktab.h"
#include "picotrns.h"

#include "picospho.h"

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

#define SPHO_BUFSIZE (3 * PICODATA_BUFSIZE_DEFAULT)


#define SPHO_MAX_ALTDESC_SIZE (60 * PICOTRNS_MAX_NUM_POSSYM)


#define SPHO_SMALLEST_SIL_DUR 1


/** @addtogroup picospho
 *
 * Algorithmic description
 * =======================
 * The main function, sphoStep, is divided into the subprocesses (processing states) described further down.
 *
 * Flow control:
 * ------------
 * The processing flow is controlled by setting
 *                       - 'procState' :       the next state to be processed
 *                       - 'feedFollowState' : the state to be processed after the feed state (the feed state is treated like a primitive "subroutine")
 *                       - some other flags
 *
 * Buffering:
 * ---------
 * - The input items are mainly stored and processed in two buffers, collectively called 'inBuf'
 *                       - cbuf  : unstructured buffer containing item contents
 *                       - headx : structured buffer containing item heads, each expanded by a pointer to the item contents
 *                                 and space for a boundary potentially to be inserted (to the left of the original item)
 * - For transduction, phonemes and their position are extracted from inBuf into
 *                       - phonBuf,
 *   processed there, and the resulting phonemes realigned with inBuf.
 * - Word items are split into syllables, stored in
 *                       - sylBuf
 * - Items to be output are stored in outBuf
 *
 * Windowing:
 * ---------
 *   Optimal solutions are achieved if a whole sentence is processed at once. However, if any of the buffers are too small,
 *   only sentence parts are processed. To improve the quality of such sub-optimal solutions, a moving-window-with-overlap is applied:
 *   - [0,headxReadPos[              : the window considered for transduction
 *   - [activeStartPos,activeEndPos[ : the "active" subrange of the window actually used for output
 *   - penultima                     : the position (within the active range) that should be used as new window start when shifting the window
 *
 * After PROCESS_PARSE:
 *   0             activeStartPos      penultima    activeEndPos   headxReadPos              headxWritePos
 *  |             |                   |            |              |                         |
 *  |-------------=================================---------------|                                         ['----': context '====' : active subrange)
 *
 * After PROCESS_SHIFT:
 *                                     0            activeStartPos                           headWritePos
 *                  |                 |            |                                        |
 *                                    |------------... (only left context is known; new active range,  penultima, and right context to be established at next parse)
 *
 * Processing states:
 * -----------------
 * - INIT              : initialize state variables
 * - COLLECT           : collect items into internal buffers ("inBuf")
 * - PROCESS_PARSE     : go through inBuf items and extract position/phoneme pairs into phoneme buffer 'phonBuf'
 *                       word boundary phonemes are inserted between words
 * - PROCESS_TRANSDUCE : transduce phonBuf
 * - PROCESS_BOUNDS    : go through inBuf items again and match against transduced pos/phoneme
 *                       this is the first round of alignment, only inserting/deleting/modifying bounds, according to
 *                       - existing BOUND items
 *                       - newly produced word bounds separating WORDPHON items
 *                       - bound upgrades/downgrades from transduction
 *                       - bound upgrades/downgrades/insertions from SIL command items (originating e.g. from <break> text commands)
 *                       all relevant bounds are placed in the corresponding headx extention; original bound items become invalid.
 * - PROCESS_RECOMB    : go through inBuf items again and match against transduced pos/phoneme
 *                       this is the second round of alignment, treating non-BOUND items
 *                       - WORDPHONs are broken into syllables by "calling" PROCESS_SYL
 *                       - "side-bounds" (in the headx extension) are output by "calling" FEED
 *                       - BOUND items are consumed with no effect
 *                       - other items are output unchanged "calling" FEED
 * - PROCESS_SYL       : the WORDPHON coming from RECOMB is matched against the phonBuf and (new) SYLLPHON items
 *                       are created. (the original wordphon is consumed)
 * - FEED              : feeds one item and returns to spho->feedFollowState
 * - SHIFT             : items in inBuf are shifted left to make room for new items. If a sentence doesn't fit
 *                       inBuf in its entirety, left and/or right contexts are kept so they can be considered in
 *                       the next transduction.
 */


/* PU sphoStep states */
#define SPHO_STEPSTATE_INIT               0
#define SPHO_STEPSTATE_COLLECT            1
#define SPHO_STEPSTATE_PROCESS_PARSE      2
#define SPHO_STEPSTATE_PROCESS_TRANSDUCE  3
#define SPHO_STEPSTATE_PROCESS_BOUNDS     4
#define SPHO_STEPSTATE_PROCESS_RECOMB     5
#define SPHO_STEPSTATE_PROCESS_SYL        6
#define SPHO_STEPSTATE_FEED               7
#define SPHO_STEPSTATE_SHIFT              8

#define SPHO_POS_INVALID (PICOTRNS_POS_INVALID)   /* indicates that no position was set yet */

/* nr item restriction: maximum number of extended item heads in headx */
#define SPHO_MAXNR_HEADX    60

/* nr item restriction: maximum size of all item contents together in cont */
#define SPHO_MAXSIZE_CBUF (30 * 255)

/* "expanded head": item head expanded by a content position and a by boundary information
 *  potentially inserted "to the left" of the item */
typedef struct {
    picodata_itemhead_t head;
    picoos_uint16 cind;
    picoos_uint8 boundstrength; /* bstrength to the left, 0 if not set */
    picoos_uint8 phrasetype; /* btype for following phrase, 0 if not set */
    picoos_int16 sildur; /* silence duration for boundary, -1 if not set */
} picospho_headx_t;


#define SPHO_MSGSTR_SIZE 32

/** object       : SentPhoUnit
 *  shortcut     : spho
 *  derived from : picodata_ProcessingUnit
 */
typedef struct spho_subobj {
    picoos_Common common;

    /* we use int16 for buffer positions so we can indicate exceptional positions (invalid etc.) with negative
     * integers */
    picoos_uint8 procState; /* for next processing step decision */

    /* buffer for item headers */
    picoos_uint8 tmpbuf[PICODATA_MAX_ITEMSIZE]; /* tmp. location for an item */

    picospho_headx_t headx[SPHO_MAXNR_HEADX]; /* "expanded head" buffer */
    picoos_uint16 headxBufSize; /* actually allocated size (if one day headxBuf is allocated dynamically) */
    picoos_uint16 headxReadPos, headxWritePos;

    picoos_uint8 cbuf[SPHO_MAXSIZE_CBUF];
    picoos_uint16 cbufBufSize; /* actually allocated size */
    picoos_uint16 cbufWritePos; /* next position to write to, 0 if buffer empty */

    picoos_uint8 outBuf[PICODATA_BUFSIZE_DEFAULT]; /* internal output buffer to hold just one item */
    picoos_uint16 outBufSize; /* actually allocated size (if one day outBuf is allocated dynamically) */
    picoos_uint16 outReadPos; /* next pos to read from inBuf for output */

    /* picoos_int16 outWritePos; */ /* next pos to output from in buf */

    picoos_uint8 sylBuf[255]; /* internal buffer to hold contents of syl item to be output */
    picoos_uint8 sylReadPos, sylWritePos; /* next pos to read from sylBuf, next pos to write to sylBuf */

    /* buffer for internal calculation of transducer */
    picotrns_AltDesc altDescBuf;
    /* the number of AltDesc in the buffer */
    picoos_uint16 maxAltDescLen;

    /* the input to a transducer should not be larger than PICOTRNS_MAX_NUM_POSSYM
     * so the output may expand (up to 4*PICOTRNS_MAX_NUM_POSSYM) */

    picotrns_possym_t phonBufA[4 * PICOTRNS_MAX_NUM_POSSYM + 1];
    picotrns_possym_t phonBufB[4 * PICOTRNS_MAX_NUM_POSSYM + 1];
    picotrns_possym_t * phonBuf;
    picotrns_possym_t * phonBufOut;
    picoos_uint16 phonReadPos, phonWritePos; /* next pos to read from phonBufIn, next pos to write to phonBufIn */

    picoos_int16 activeStartPos; /* start position of items to be treated (at end of left context) */
    picoos_int16 penultima, activeEndPos; /* positions of last two bounds/words; SPHO_POS_INVALID means uninitialized */
    picoos_int16 lastPhraseBoundPos; /* position of the last bound encountered (<0 if inexistent or not reachable */
    picoos_uint8 lastPhraseType; /* phrase type of the last phrase boundary, 0 if not set */

    picoos_uint8 needMoreInput, /* more data necessary to decide on token */
    suppressParseWordBound, /* dont produce word boundary */
    suppressRecombWordBound, /* dont produce word boundary */
    breakPending, /* received a break but didn't interpret it yet */
    /* sentEnd, */ /* sentence end detected */
    force, /* in forced state */
    wordStarted, /* is it the first syl in the word: expect POS */
    sentenceStarted;

    picoos_uint16 breakTime; /* time argument of the pending break command */

    picoos_uint8 feedFollowState; /* where to return after feed */

    /* fst knowledge bases */
    picoos_uint8 numFsts;
    picokfst_FST fst[PICOKNOW_MAX_NUM_SPHO_FSTS];
    picoos_uint8 curFst; /* the fst to be applied next */

    /* fixed ids knowledge base */
    picoktab_FixedIds fixedIds;

    /* phones kb */
    picoktab_Phones phones;

    /* some soecial ids from phones */
    picoos_uint8 primStressId, secondStressId, syllSepId;

} spho_subobj_t;


static pico_status_t sphoReset(register picodata_ProcessingUnit this)
{

    spho_subobj_t * spho;

    if (NULL == this || NULL == this->subObj) {
        return picoos_emRaiseException(this->common->em,
                                       PICO_ERR_NULLPTR_ACCESS, NULL, NULL);
    }
    spho = (spho_subobj_t *) this->subObj;

    spho->curFst = 0;

/* processing state */
    spho->procState = SPHO_STEPSTATE_INIT;
    spho->needMoreInput = TRUE;
    spho->suppressParseWordBound = FALSE;
    spho->suppressRecombWordBound = FALSE;
    spho->breakPending = FALSE;
    spho->force = 0;
    spho->sentenceStarted = 0;


    /* item buffer headx/cbuf */
    spho->headxBufSize = SPHO_MAXNR_HEADX;
    spho->headxReadPos = 0;
    spho->headxWritePos = 0;

    spho->cbufWritePos = 0;
    spho->cbufBufSize = SPHO_MAXSIZE_CBUF;

    /* possym buffer */
    spho->phonBuf = spho->phonBufA;
    spho->phonBufOut = spho->phonBufB;
    spho->phonReadPos = 0;

    /* overlapping */
    spho->activeStartPos = 0;
    spho->penultima = SPHO_POS_INVALID;
    spho->activeEndPos = SPHO_POS_INVALID;

    return PICO_OK;
}


static pico_status_t sphoInitialize(register picodata_ProcessingUnit this)
{
    picoos_uint8 i;
    spho_subobj_t * spho;
    picokfst_FST fst;

    picoknow_kb_id_t myKbIds[PICOKNOW_MAX_NUM_SPHO_FSTS] = PICOKNOW_KBID_SPHO_ARRAY;

    PICODBG_DEBUG(("init"));

    if (NULL == this || NULL == this->subObj) {
        return picoos_emRaiseException(this->common->em,
                                       PICO_ERR_NULLPTR_ACCESS, NULL, NULL);
    }

    spho = (spho_subobj_t *) this->subObj;

    spho->numFsts = 0;

    spho->curFst = 0;

    for (i = 0; i<PICOKNOW_MAX_NUM_SPHO_FSTS; i++) {
        fst = picokfst_getFST(this->voice->kbArray[myKbIds[i]]);
        if (NULL != fst) {
            spho->fst[spho->numFsts++] = fst;
        }
    }
    spho->fixedIds = picoktab_getFixedIds(this->voice->kbArray[PICOKNOW_KBID_FIXED_IDS]);
    spho->phones = picoktab_getPhones(this->voice->kbArray[PICOKNOW_KBID_TAB_PHONES]);

    spho->syllSepId = picoktab_getSyllboundID(spho->phones);
    spho->primStressId = picoktab_getPrimstressID(spho->phones);
    spho->secondStressId = picoktab_getSecstressID(spho->phones);

    PICODBG_DEBUG(("got %i fsts", spho->numFsts));


    return sphoReset(this);

}

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


static pico_status_t sphoTerminate(register picodata_ProcessingUnit this)
{
    return PICO_OK;
}


static pico_status_t sphoSubObjDeallocate(register picodata_ProcessingUnit this,
        picoos_MemoryManager mm)
{
    spho_subobj_t * spho;

    spho = (spho_subobj_t *) this->subObj;

    if (NULL != this) {
        if (NULL != this->subObj) {
            spho = (spho_subobj_t *) (this->subObj);
            picotrns_deallocate_alt_desc_buf(spho->common->mm,&spho->altDescBuf);
            picoos_deallocate(mm, (void *) &this->subObj);
        }
    }
    return PICO_OK;
}

picodata_ProcessingUnit picospho_newSentPhoUnit(picoos_MemoryManager mm,
        picoos_Common common, picodata_CharBuffer cbIn,
        picodata_CharBuffer cbOut, picorsrc_Voice voice)
{
    spho_subobj_t * spho;

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

    this->initialize = sphoInitialize;
    this->step = sphoStep;
    this->terminate = sphoTerminate;
    this->subDeallocate = sphoSubObjDeallocate;

    this->subObj = picoos_allocate(mm, sizeof(spho_subobj_t));
    if (this->subObj == NULL) {
        picoos_deallocate(mm, (void **)(void*)&this);
        return NULL;
    }
    spho = (spho_subobj_t *) this->subObj;

    spho->common = this->common;

    /* these are given by the pre-allocated array sizes */
    spho->outBufSize = PICODATA_BUFSIZE_DEFAULT;


    spho->altDescBuf = picotrns_allocate_alt_desc_buf(spho->common->mm, SPHO_MAX_ALTDESC_SIZE, &spho->maxAltDescLen);
    if (NULL == spho->altDescBuf) {
        picotrns_deallocate_alt_desc_buf(spho->common->mm,&spho->altDescBuf);
        picoos_emRaiseException(spho->common->em,PICO_EXC_OUT_OF_MEM, NULL,NULL);
        return NULL;
    }

    sphoInitialize(this);
    return this;
}


/* ***********************************************************************/
/*                          process buffered item list                   */
/* ***********************************************************************/


/* shift relevant data in headx/'cbuf' (between 'readPos' incl and writePos non-incl) to 'start'.
 * modify read/writePos accordingly */
static picoos_int16 shift_range_left_1(spho_subobj_t *spho, picoos_int16 * from, picoos_int16 to)
{

    /* remember shift parameters for cbuf */
    picoos_uint16
        c_i,
        c_j,
        c_diff,
        c_writePos,
        i,
        j,
        diff,
        writePos;
    i = to;
    j = *from;
    diff = j-i;
    writePos = spho->headxWritePos;
    c_i = spho->headx[to].cind;
    if (j < writePos) {
      c_j = spho->headx[j].cind;
    } else {
        c_j = spho->cbufWritePos;
    }
    c_diff = c_j - c_i;
    c_writePos = spho->cbufWritePos;

    PICODBG_DEBUG((
                    "shifting buffer region [%i,%i[ down to %i",*from, writePos, to
                    ));


    /* PICODBG_ASSERT((i<j)); */
    if (i > j) {
        return -1;
    }
    /* shift cbuf */
    while (c_j < c_writePos) {
        spho->cbuf[c_i++] = spho->cbuf[c_j++];
    }
    /* shift headx */
    while (j < writePos) {
        spho->headx[j].cind -= c_diff;
        spho->headx[i++] = spho->headx[j++];
    }
    spho->headxWritePos -= diff;
    *from = to;
    spho->cbufWritePos -= c_diff;
    /*  */
    PICODBG_DEBUG((
                    "readPos,WritePos are now [%i,%i[, returning shift amount %i",*from, spho->headxWritePos, diff
            ));
    return diff;
}

static pico_status_t sphoAddPhoneme(register spho_subobj_t *spho, picoos_int16 pos, picoos_int16 sym) {
    picoos_uint8 plane, unshifted;
    /* just for debuging */
    unshifted = picotrns_unplane(sym,&plane);
    PICODBG_TRACE(("adding %i/%i (%c on plane %i) at phonBuf[%i]",pos,sym,unshifted,plane,spho->phonWritePos));
    if (2* PICOTRNS_MAX_NUM_POSSYM <= spho->phonWritePos) {
        /* not an error! */
        PICODBG_DEBUG(("couldn't add because phon buffer full"));
        return PICO_EXC_BUF_OVERFLOW;
    } else {
        spho->phonBuf[spho->phonWritePos].pos = pos;
        spho->phonBuf[spho->phonWritePos].sym = sym;
        spho->phonWritePos++;
        return PICO_OK;
    }
}

static pico_status_t sphoAddStartPhoneme(register spho_subobj_t *spho) {
    return sphoAddPhoneme(spho, PICOTRNS_POS_IGNORE,
            (PICOKFST_PLANE_INTERN << 8) + spho->fixedIds->phonStartId);
}

static pico_status_t sphoAddTermPhonemes(register spho_subobj_t *spho, picoos_uint16 pos) {
    return sphoAddPhoneme(spho, pos,
            (PICOKFST_PLANE_PB_STRENGTHS << 8) + PICODATA_ITEMINFO1_BOUND_SEND)
            && sphoAddPhoneme(spho, PICOTRNS_POS_IGNORE,
                    (PICOKFST_PLANE_INTERN << 8) + spho->fixedIds->phonTermId);
}

/* return "syllable accent" (or prominence) symbol, given "word accent" symbol 'wacc' and stress value (no=0, primary=1, secondary=2) */
static picoos_uint16 sphoGetSylAccent(register spho_subobj_t *spho,
        picoos_uint8 wacc, picoos_uint8 sylStress)
{
    PICODBG_ASSERT(sylStress <= 2);

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

    switch (sylStress) {
        case 0: /* non-stressed syllable gets no prominence */
            /* return spho->fixedIds->accId[0]; */
            return PICODATA_ACC0;
            break;
        case 1: /* primary-stressed syllable gets word prominence */
            return wacc;
            break;
        case 2: /* secondary-stressed syllable gets no prominence or secondary stress prom. (4) */
            return (PICODATA_ACC0 == wacc) ? PICODATA_ACC0
                     : PICODATA_ACC4;
            /*return (spho->fixedIds->accId[0] == wacc) ? spho->fixedIds->accId[0]
                     : spho->fixedIds->accId[4]; */
             break;
        default:
            /* never occurs :-) */
            return PICODATA_ACC0;
            break;
    }
}


/* ***********************************************************************/
/*                          extract phonemes of an item into a phonBuf   */
/* ***********************************************************************/
static pico_status_t sphoExtractPhonemes(register picodata_ProcessingUnit this,
        register spho_subobj_t *spho, picoos_uint16 pos,
        picoos_uint8 convertAccents, picoos_uint8 * suppressWB)
{
    pico_status_t rv = PICO_OK;
    picoos_uint16 i, j;
    picoos_int16 fstSymbol;
    picoos_uint8 curStress;
    picotrns_possym_t tmpPosSym;
    picoos_uint16 oldPos, curPos;
    picodata_itemhead_t * head;
    picoos_uint8* content;

#if defined(PICO_DEBUG)
    picoos_char msgstr[SPHO_MSGSTR_SIZE];
#endif


    /*
     Items considered in a transduction are a BOUND or a WORDPHON item. its starting offset within the
     headxBuf is given as 'pos'.
     Elements that go into the transduction receive "their" position in the buffer.
     */

    oldPos = spho->phonWritePos;

    head = &(spho->headx[pos].head);
    content = spho->cbuf + spho->headx[pos].cind;

    PICODBG_TRACE(("doing item %s\n",
            picodata_head_to_string(head,msgstr,SPHO_MSGSTR_SIZE)));

    switch (head->type) {
        case PICODATA_ITEM_BOUND:
            /* map SBEG, SEND and TERM (as sentence closing) to SEND */
            fstSymbol = (PICODATA_ITEMINFO1_BOUND_SBEG == head->info1 || PICODATA_ITEMINFO1_BOUND_TERM == head->info1) ? PICODATA_ITEMINFO1_BOUND_SEND : head->info1;
            PICODBG_TRACE(("found bound of type %c\n",head->info1));
           /* BOUND(<bound strength><phrase type>) */
            /* insert bound strength */
            PICODBG_TRACE(("inserting phrase bound phoneme %c and setting suppresWB=1\n",fstSymbol));
            fstSymbol += (PICOKFST_PLANE_PB_STRENGTHS << 8);
            rv = sphoAddPhoneme(spho,pos,fstSymbol);
            /* phrase type not used */
            /* suppress next word boundary */
            (*suppressWB) = 1;
            break;

        case PICODATA_ITEM_WORDPHON:
            /* WORDPHON(POS,WACC)phon */
            PICODBG_TRACE(("found WORDPHON"));
            /* insert word boundary if not suppressed */
            if (!(*suppressWB)) {
                fstSymbol = (PICOKFST_PLANE_PB_STRENGTHS << 8) + PICODATA_ITEMINFO1_BOUND_PHR0;
                PICODBG_TRACE(("adding word boundary phone"));
                rv = sphoAddPhoneme(spho,pos,fstSymbol);
            }
            (*suppressWB) = 0;
            /* for the time being, we force to use POS so we can transduce all fsts in a row without reconsulting the items */


            /* If 'convertAccents' then the accentuation is not directly encoded. It rather influences the mapping of
             * the word accent symbol to the actual accent phoneme which is put after the syllable separator. */
            if (convertAccents) {
                PICODBG_TRACE(("converting accents"));
                /* extracting phonemes IN REVERSE order replacing syllable symbols with prominence symbols */
                curPos = spho->phonWritePos;
                curStress = 0; /* no stress */
                for (i = head->len; i > 0 ;) {
                    i--;
                    if (spho->primStressId == content[i]) {
                        curStress = 1;
                        PICODBG_DEBUG(("skipping primary stress at pos %i (in 1 .. %i)",i, head->len));
                        continue; /* skip primary stress symbol */
                    } else if (spho->secondStressId == content[i]) {
                        curStress = 2;
                        PICODBG_DEBUG(("skipping secondary stress at pos %i (in 1 .. %i)",i, head->len));
                        continue; /* skip secundary stress symbol */
                    } else if (spho->syllSepId == content[i]) {
                        fstSymbol = (PICOKFST_PLANE_POS << 8) + head->info1;
                        rv = sphoAddPhoneme(spho, pos, fstSymbol);
                        /* replace syllSepId by combination of syllable stress and word prominence */
                        fstSymbol = sphoGetSylAccent(spho,head->info2,curStress);
                        curStress = 0;
                        /* add accent */
                        fstSymbol += (PICOKFST_PLANE_ACCENTS << 8);
                        rv = sphoAddPhoneme(spho,pos,fstSymbol);
                        if (PICO_OK != rv) {
                            break;
                        }
                       /* and keep syllable boundary */
                        fstSymbol = (PICOKFST_PLANE_PHONEMES << 8) + content[i];
                    } else {
                        /* normal phoneme */
                        fstSymbol = (PICOKFST_PLANE_PHONEMES << 8) + content[i];
                    }
                    if (PICO_OK == rv) {
                        rv = sphoAddPhoneme(spho,pos,fstSymbol);
                    }
                }
                if (PICO_OK == rv) {
                    /* bug 366: we position the "head" into the item header and not on the first phoneme
                     * because there might be no phonemes at all */
                    /* insert head of the first syllable of a word */
                         fstSymbol = (PICOKFST_PLANE_POS << 8) + head->info1;
                        rv = sphoAddPhoneme(spho,pos,fstSymbol);
                    fstSymbol = sphoGetSylAccent(spho,head->info2,curStress);
                    curStress = 0;
                   fstSymbol += (PICOKFST_PLANE_ACCENTS << 8);
                   rv = sphoAddPhoneme(spho,pos,fstSymbol);
                }
                if (PICO_OK == rv) {
                    /* invert sympos portion */
                    i = curPos;
                    j=spho->phonWritePos-1;
                    while (i < j) {
                        tmpPosSym.pos = spho->phonBuf[i].pos;
                        tmpPosSym.sym = spho->phonBuf[i].sym;
                        spho->phonBuf[i].pos = spho->phonBuf[j].pos;
                        spho->phonBuf[i].sym = spho->phonBuf[j].sym;
                        spho->phonBuf[j].pos = tmpPosSym.pos;
                        spho->phonBuf[j].sym = tmpPosSym.sym;
                        i++;
                        j--;
                    }
                }
            } else { /* convertAccents */
                for (i = 0; i <head->len; i++) {
                    fstSymbol = (PICOKFST_PLANE_PHONEMES << 8) + content[i];
                    rv = sphoAddPhoneme(spho,pos,fstSymbol);
                }
            }
            break;
        default:
            picoos_emRaiseException(this->common->em,rv,NULL,NULL);
            break;
    } /* switch(head->type) */
    if (PICO_OK != rv) {
        spho->phonWritePos = oldPos;
    }
    return rv;
}


#define SPHO_POSSYM_OK           0
#define SPHO_POSSYM_OUT_OF_RANGE 1
#define SPHO_POSSYM_END          2
#define SPHO_POSSYM_INVALID     -3
/* *readPos is the next position in phonBuf to be read, and *writePos is the first position not to be read (may be outside
 * buf).
 * 'rangeEnd' is the first possym position outside the desired range.
 * Possible return values:
 * SPHO_POSSYM_OK            : 'pos' and 'sym' are set to the read possym, *readPos is advanced
 * SPHO_POSSYM_OUT_OF_RANGE  : pos is out of range. 'pos' is set to that of the read possym, 'sym' is undefined
 * SPHO_POSSYM_UNDERFLOW     : no more data in buf. 'pos' is set to PICOTRNS_POS_INVALID,    'sym' is undefined
 * SPHO_POSSYM_INVALID       : "strange" pos.       'pos' is set to PICOTRNS_POS_INVALID,    'sym' is undefined
 */
static pico_status_t getNextPosSym(spho_subobj_t * spho, picoos_int16 * pos, picoos_int16 * sym,
        picoos_int16 rangeEnd) {
    /* skip POS_IGNORE */
    while ((spho->phonReadPos < spho->phonWritePos) && (PICOTRNS_POS_IGNORE == spho->phonBuf[spho->phonReadPos].pos))  {
        PICODBG_DEBUG(("ignoring phone at spho->phonBuf[%i] because it has pos==IGNORE",spho->phonReadPos));
        spho->phonReadPos++;
    }
    if ((spho->phonReadPos < spho->phonWritePos)) {
        *pos = spho->phonBuf[spho->phonReadPos].pos;
        if ((PICOTRNS_POS_INSERT == *pos) || ((0 <= *pos) && (*pos < rangeEnd))) {
            *sym = spho->phonBuf[spho->phonReadPos++].sym;
            return SPHO_POSSYM_OK;
        } else if (*pos < 0){ /* *pos is "strange" (e.g. POS_INVALID) */
            return SPHO_POSSYM_INVALID;
        } else {
            return SPHO_POSSYM_OUT_OF_RANGE;
        }
    } else {
        /* no more possyms to read */
        *pos = PICOTRNS_POS_INVALID;
        return SPHO_POSSYM_END;
    }
}


/** Calculate bound strength modified by transduction
 *
 * Given the original bound strength 'orig' and the desired target strength 'target' (suggested by fst),
 *  calculate the modified bound strength.
 *
 * @param orig  original bound strength
 * @param target target bound strength
 * @return resulting bound strength
 */
static picoos_uint8 fstModifiedBoundStrength(picoos_uint8 orig, picoos_uint8 target)
{
    switch (orig) {
        case PICODATA_ITEMINFO1_BOUND_PHR1:
        case PICODATA_ITEMINFO1_BOUND_PHR2:
            /* don't allow primary phrase bounds to be demoted to word bound */
            if (PICODATA_ITEMINFO1_BOUND_PHR0 == target) {
                return PICODATA_ITEMINFO1_BOUND_PHR3;
            }
        case PICODATA_ITEMINFO1_BOUND_PHR0:
        case PICODATA_ITEMINFO1_BOUND_PHR3:
            return target;
            break;
        default:
            /* don't allow bounds other than phrase or word bounds to be changed */
            return orig;
            break;
    }
}

/** Calculate bound strength modified by a \<break> command
 *
 * Given the original (predicted and possibly fst-modified) bound strength, and a time value from an
 * overwriding \<break> command, calculate the modified bound strength.
 *
 * @param orig original bound strength
 * @param time time given as property of \<break> command
 * @param wasPrimary
 * @return modified bound strength
 */
static picoos_uint8 breakModifiedBoundStrength(picoos_uint8 orig, picoos_uint16 time, picoos_bool wasPrimary)
{
    picoos_uint8 modified = (0 == time) ? PICODATA_ITEMINFO1_BOUND_PHR3 :
        (50 < time) ? PICODATA_ITEMINFO1_BOUND_PHR1 : PICODATA_ITEMINFO1_BOUND_PHR2;
    switch (orig) {
        /* for word and phrase breaks, return 'modified', unless a non-silence gets time==0, in which
         * case return no break (word break) */
        case PICODATA_ITEMINFO1_BOUND_PHR0:
            if (0 == time) {
                return PICODATA_ITEMINFO1_BOUND_PHR0;
            }
        case PICODATA_ITEMINFO1_BOUND_PHR3:
            if (!wasPrimary && (0 == time)) {
                return PICODATA_ITEMINFO1_BOUND_PHR0;
            }
        case PICODATA_ITEMINFO1_BOUND_PHR1:
        case PICODATA_ITEMINFO1_BOUND_PHR2:
            return modified;
            break;
        default:
            return orig;
            break;
    }
}

static picoos_bool breakStateInterrupting(picodata_itemhead_t * head,
        picoos_bool * breakBefore, picoos_bool * breakAfter) {

    picoos_bool result = 1;

    *breakBefore = 0;
    *breakAfter = 0;

    if (PICODATA_ITEM_WORDPHON == head->type) {

    } else if (PICODATA_ITEM_CMD == head->type) {
        if ((PICODATA_ITEMINFO1_CMD_PLAY == head->info1)
                || (PICODATA_ITEMINFO1_CMD_SAVE == head->info1)
                || (PICODATA_ITEMINFO1_CMD_UNSAVE == head->info1)) {
            *breakBefore = 1;
            *breakAfter = 1;
        } else if (PICODATA_ITEMINFO1_CMD_SAVE == head->info1) {
            *breakBefore = 1;
        } else if (PICODATA_ITEMINFO1_CMD_UNSAVE == head->info1) {
            *breakAfter = 1;
        } else if (PICODATA_ITEMINFO1_CMD_IGNSIG == head->info1) {
            if (PICODATA_ITEMINFO2_CMD_START == head->info2) {
                *breakBefore = 1;
            } else {
                *breakAfter = 1;
            }
        }
    } else {
        result = 0;
    }
    return result;
}


static void putSideBoundToOutput(spho_subobj_t * spho)
{

    picodata_itemhead_t ohead;
    picoos_uint8 ocontent[2*sizeof(picoos_uint16)];
    picoos_int16 sildur;
    picoos_uint16 clen;

    /* create boundary */
    ohead.type = PICODATA_ITEM_BOUND;
    ohead.info1 = spho->headx[spho->outReadPos].boundstrength;
    ohead.info2 = spho->headx[spho->outReadPos].phrasetype;
    sildur = spho->headx[spho->outReadPos].sildur;
    if ((sildur < 0)
            || (PICODATA_ITEMINFO1_BOUND_PHR0 == ohead.info1)
            || (PICODATA_ITEMINFO1_BOUND_PHR3 == ohead.info1)) {
        PICODBG_DEBUG(("outputting a bound of strength '%c' and type '%c' without duration constraints",ohead.info1, ohead.info2));
        ohead.len = 0;
    } else {
        picoos_uint32 pos = 0;
        picoos_write_mem_pi_uint16(ocontent,&pos,sildur);
        picoos_write_mem_pi_uint16(ocontent,&pos,sildur);
        PICODBG_DEBUG(("outputting a bound of strength '%c' and type '%c' with duration constraints [%i,%i]",ohead.info1, ohead.info2,sildur, sildur));
        ohead.len = pos;
    }
    picodata_put_itemparts(&ohead, ocontent, ohead.len,
            spho->outBuf, spho->outBufSize, &clen);
    /* disable side bound */
    spho->headx[spho->outReadPos].boundstrength = 0;
}

/** Set bound strength and sil dur.
 *
 * given the original bound strength 'orig_strength' and the fst-suggested bound strength 'fst_strength'
 * and possibly being in a pending break state, calculate the resulting bound strength and set boundstrength
 * and sildur of the current item (spho->headx[spho->outReadPos]) accordingly.
 * if a boundstrength was set, also calculate the phrasetype and if necessary (and reachable), modify the phrase type
 * of the previous phrase boundary.
 *
 * @param spho
 * @param orig_strength
 * @param orig_type
 * @param fst_strength
 */
static void setSideBound(spho_subobj_t * spho, picoos_uint8 orig_strength, picoos_uint8 orig_type, picoos_uint8 fst_strength) {
    picoos_uint8 strength;

    /* insert modified bound according to transduction symbol, if any */
    if (PICODATA_ITEMINFO1_NA == orig_strength) {
        /* no original/fst strength given */
        orig_strength = PICODATA_ITEMINFO1_BOUND_PHR0;
        strength = PICODATA_ITEMINFO1_BOUND_PHR0;
    } else {
        strength = fstModifiedBoundStrength(orig_strength,fst_strength);
        spho->headx[spho->outReadPos].boundstrength = strength;
        spho->headx[spho->outReadPos].sildur = -1;
        PICODBG_DEBUG(("setting bound strength to fst-suggested value %c (was %c)",strength, spho->headx[spho->outReadPos].boundstrength, spho->breakTime));
    }

    /* insert modified bound according to pending break, if any */
    if (spho->breakPending) {
        /* the calculation is based on the fst-modified value (because this is what the customer wants to
         * override)
         */
        strength = breakModifiedBoundStrength(strength, spho->breakTime, (PICODATA_ITEMINFO1_BOUND_PHR1 == orig_strength));
        PICODBG_DEBUG(("setting bound strength to break-imposed value %c (was %c) and time to %i",strength, spho->headx[spho->outReadPos].boundstrength, spho->breakTime));
        spho->headx[spho->outReadPos].boundstrength =  strength;
        spho->headx[spho->outReadPos].sildur = spho->breakTime;
        spho->breakPending = FALSE;
    }
    if (spho->headx[spho->outReadPos].boundstrength) {
        /* we did set a bound strength, possibly promoting or demoting a boundary; now set the phrase type
         * possibly also changing the phrase type of the previous phrase bound
         */
        picoos_uint8 fromPhrase = ((PICODATA_ITEMINFO1_BOUND_PHR0 != orig_strength));
        picoos_uint8 toPhrase = ((PICODATA_ITEMINFO1_BOUND_PHR0 != strength));

        PICODBG_DEBUG(("setting phrase type (wasPhrase=%i, isPhrase=%i)",fromPhrase,toPhrase));
        if (toPhrase) {
            if (fromPhrase) {
                spho->lastPhraseType = orig_type;
            } else { /*promote */
                if (spho->activeStartPos <= spho->lastPhraseBoundPos) {
                    /* we still can change prev phrase bound */
                    /* since a new phrase boundary is introduced, we have to 'invent'
                     * an additional phrase type here. For that, we have to use some of the
                     * knowledge that otherwise is handled in picoacph.
                     */
                    spho->headx[spho->lastPhraseBoundPos].phrasetype
                            = PICODATA_ITEMINFO2_BOUNDTYPE_P;
                }
            }
            spho->lastPhraseBoundPos = spho->outReadPos;
            spho->headx[spho->lastPhraseBoundPos].phrasetype
                    = spho->lastPhraseType;

        } else {
            spho->headx[spho->outReadPos].phrasetype = PICODATA_ITEMINFO2_NA;
            if (fromPhrase) { /* demote */
                spho->lastPhraseType = orig_type;
                if (spho->activeStartPos <= spho->lastPhraseBoundPos) {
                    /* we still can change prev phrase bound */
                    spho->headx[spho->lastPhraseBoundPos].phrasetype
                        = spho->lastPhraseType;
                }
            }
        }
    }
}


/* ***********************************************************************/
/*                          sphoStep function                            */
/* ***********************************************************************/


static picodata_step_result_t sphoStep(register picodata_ProcessingUnit this,
        picoos_int16 mode, picoos_uint16 * numBytesOutput)
{

    register spho_subobj_t *spho;
    pico_status_t rv= PICO_OK;
    picoos_uint16 blen;
    picodata_itemhead_t ihead, ohead;
    picoos_uint8 *icontent;
    picoos_uint16 nextInPos;
#if defined(PICO_DEBUG)
    picoos_char msgstr[SPHO_MSGSTR_SIZE];
#endif

    /* used in FEED and FEED_SYM */
    picoos_uint16 clen;
    picoos_int16 pos, sym, sylsym;
    picoos_uint8 plane;

    /* used in BOUNDS */
    picoos_bool breakBefore, breakAfter;

    /* pico_status_t rvP= PICO_OK; */

    picoos_uint16 curPos /*, nextPos */;
    picoos_uint16 remHeadxSize, remCbufSize;


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

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

    *numBytesOutput = 0;
    while (1) { /* exit via return */
        PICODBG_INFO(("doing state %i, headxReadPos: %d, headxWritePos: %d",
                        spho->procState, spho->headxReadPos, spho->headxWritePos));

        switch (spho->procState) {

            case SPHO_STEPSTATE_INIT:
                /* **********************************************************************/
                /* INIT                                                              */
                /* **********************************************************************/
                PICODBG_DEBUG(("INIT"));
            /* (re)set values for PARSE */
            spho->penultima = SPHO_POS_INVALID;
            spho->activeEndPos = SPHO_POS_INVALID;
            spho->headxReadPos = 0;
            spho->phonReadPos = 0;
            spho->phonWritePos = 0;
            spho->lastPhraseType = PICODATA_ITEMINFO2_NA;
            spho->lastPhraseBoundPos = -1;

            spho->procState = SPHO_STEPSTATE_COLLECT;
            break;


            case SPHO_STEPSTATE_COLLECT:
                /* **********************************************************************/
                /* COLLECT                                                              */
                /* **********************************************************************/
                /* collect state: get items from charBuf and store in
                 * internal inBuf
                 */
                PICODBG_TRACE(("COLLECT"));
                rv = PICO_OK;
                remHeadxSize = spho->headxBufSize - spho->headxWritePos;
                remCbufSize = spho->cbufBufSize - spho->cbufWritePos;
                curPos = spho->headxWritePos;
                while ((PICO_OK == rv) && (remHeadxSize > 0) && (remCbufSize > 0)) {
                    PICODBG_DEBUG(("COLLECT getting item at headxWritePos %i (remaining %i)",spho->headxWritePos, remHeadxSize));
                    rv = picodata_cbGetItem(this->cbIn, spho->tmpbuf, PICODATA_MAX_ITEMSIZE, &blen);
                    if (PICO_OK == rv) {
                        rv = picodata_get_itemparts(spho->tmpbuf,
                                            PICODATA_MAX_ITEMSIZE, &(spho->headx[spho->headxWritePos].head),
                                                    &(spho->cbuf[spho->cbufWritePos]), remCbufSize, &blen);
                        if (PICO_OK == rv) {
                            spho->headx[spho->headxWritePos].cind = spho->cbufWritePos;
                            spho->headx[spho->headxWritePos].boundstrength = 0;
                            spho->headxWritePos++;
                            remHeadxSize--;
                            spho->cbufWritePos += blen;
                            remCbufSize -= blen;
                        }
                    }
                }
                if ((PICO_OK == rv) && ((remHeadxSize <= 0) || (remCbufSize <= 0))) {
                    rv = PICO_EXC_BUF_OVERFLOW;
                }

                /* in normal circumstances, rv is either PICO_EOF (no more items in cbIn) or PICO_BUF_OVERFLOW
                 * (if no more items fit into headx) */
                if ((PICO_EOF != rv) && (PICO_EXC_BUF_OVERFLOW != rv)) {
                    PICODBG_DEBUG(("COLLECT ** problem getting item, unhandled, rv: %i", rv));
                    picoos_emRaiseException(this->common->em, rv,
                    NULL, NULL);
                    return PICODATA_PU_ERROR;
                }
                if (PICO_EOF == rv) { /* there are no more items available */
                    if (curPos < spho->headxWritePos) { /* we did get some new items */
                        PICODBG_DEBUG(("COLLECT read %i items",
                                        spho->headxWritePos - curPos));
                        spho->needMoreInput = FALSE;
                    }
                    if (spho->needMoreInput) { /* not enough items to proceed */
                        PICODBG_DEBUG(("COLLECT need more data, returning IDLE"));
                        return PICODATA_PU_IDLE;
                    } else {
                        spho->procState = SPHO_STEPSTATE_PROCESS_PARSE;
                        /* uncomment next to split into two steps */
                        /* return PICODATA_PU_ATOMIC; */
                    }
                } else { /* input buffer full */
                    PICODBG_DEBUG(("COLLECT input buffer full"));
                    if (spho->needMoreInput) { /* forced output because we can't get more data */
                        spho->needMoreInput = FALSE;
                        spho->force = TRUE;
                    }
                    spho->procState = SPHO_STEPSTATE_PROCESS_PARSE;
                }
                break;

           case SPHO_STEPSTATE_PROCESS_PARSE:

                /* **********************************************************************/
                /* PARSE: items -> input pos/phon pairs */
                /* **********************************************************************/

                /* parse one item at a time */
                /* If
                 *    - the item is a sentence end or
                 *    - it is the last item and force=1 or
                 *    - the phon buffer is full
                 * then set inReadPos to 0 and go to TRANSDUCE
                 * else advance by one item */

                /* look at the current item */
                PICODBG_TRACE(("PARSE"));
                if (spho->headxReadPos >= spho->headxWritePos) {
                    /* no more items in headx */
                    if (spho->force) {
                        PICODBG_INFO(("no more items in headx but we are forced to transduce"));

                        /* headx is full; we are forced to transduce before reaching the sentence end */
                        spho->force = FALSE;
                        if (SPHO_POS_INVALID == spho->activeEndPos) {
                            spho->activeEndPos = spho->headxReadPos;
                        }
                        spho->procState = SPHO_STEPSTATE_PROCESS_TRANSDUCE;
                    } else {
                        /* we try to get more data */
                        PICODBG_INFO(("no more items in headx, try to collect more"));
                        spho->needMoreInput = TRUE;
                        spho->procState = SPHO_STEPSTATE_COLLECT;
                    }
                    break;
                }

                ihead = spho->headx[spho->headxReadPos].head;
                icontent = spho->cbuf + spho->headx[spho->headxReadPos].cind;

                PICODBG_DEBUG(("PARSE looking at item %s",picodata_head_to_string(&ihead,msgstr,SPHO_MSGSTR_SIZE)));
                /* treat header */
                if (PICODATA_ITEM_BOUND == ihead.type) {
                    /* see if it is a sentence end or termination boundary (flush) */
                    if ((PICODATA_ITEMINFO1_BOUND_SEND == ihead.info1)
                    || (PICODATA_ITEMINFO1_BOUND_TERM == ihead.info1)) {
                        PICODBG_INFO(("PARSE found sentence  end or term BOUND"));

                        if (spho->sentenceStarted) {
                            /* its the end of the sentence */
                            PICODBG_INFO(("PARSE found sentence end"));
                            spho->sentenceStarted = 0;
                            /* there is no need for a right context; move the active end to the end */
                            /* add sentence termination phonemes */
                            sphoAddTermPhonemes(spho, spho->headxReadPos);
                            spho->headxReadPos++;
                            spho->activeEndPos = spho->headxReadPos;
                            /* we may discard all information up to activeEndPos, after processing of last
                             * sentence part
                             */
                            spho->penultima = spho->activeEndPos;

                            /* transduce */
                            spho->procState = SPHO_STEPSTATE_PROCESS_TRANSDUCE;
                            /* uncomment to split */
                            /* return PICODATA_PU_BUSY; */
                            break;
                        } else {
                            if (PICODATA_ITEMINFO1_BOUND_TERM == ihead.info1) {
                                /* its the end of input (flush) */
                                PICODBG_INFO(("PARSE forwarding input end (flush)"));
                                /* copy item unmodified */
                                picodata_put_itemparts(&ihead,
                                         icontent,
                                         ihead.len,
                                         spho->outBuf, spho->outBufSize,
                                         &clen);

                                spho->headxReadPos++;
                                spho->activeEndPos = spho->headxReadPos;
                                spho->penultima = SPHO_POS_INVALID;
                                spho->feedFollowState = SPHO_STEPSTATE_SHIFT;
                                spho->procState = SPHO_STEPSTATE_FEED;
                                break;
                            } else {
                                /* this should never happen */
                                /* eliminate bound */
                                spho->headxReadPos++;
                                spho->activeEndPos = spho->headxReadPos;
                                spho->penultima = SPHO_POS_INVALID;
                                PICODBG_ERROR(("PARSE found a sentence end without a sentence start; eliminated"));
                            }
                        }
                    } else if (PICODATA_ITEMINFO1_BOUND_SBEG == ihead.info1) {
                            /* its the start of the sentence */
                            PICODBG_INFO(("PARSE found sentence start"));
                            /* add sentence starting phoneme */
                            sphoAddStartPhoneme(spho);

                            spho->sentenceStarted = 1;
                    }
                }

                if ((PICODATA_ITEM_WORDPHON == ihead.type)
                        || (PICODATA_ITEM_BOUND == ihead.type)) {
                    /* if it is a word or a bound try to extract phonemes */
                    PICODBG_INFO(("PARSE found WORD phon or phrase BOUND"));
                    rv = sphoExtractPhonemes(this, spho, spho->headxReadPos,
                            TRUE /* convertAccents */,
                            &spho->suppressParseWordBound);
                    if (PICO_OK == rv) {
                        PICODBG_INFO(("PARSE successfully returned from phoneme extraction"));
                        /* replace activeEndPos if the new item is a word, or activeEndPos was not set yet, or
                         * activeEndPos was a bound */
                        if ((spho->activeStartPos <= spho->headxReadPos) && ((PICODATA_ITEM_WORDPHON == ihead.type)
                                || (SPHO_POS_INVALID == spho->activeEndPos)
                                || (PICODATA_ITEM_BOUND == spho->headx[spho->activeEndPos].head.type))) {
                            PICODBG_INFO(("PARSE found new activeEndPos: %i,%i -> %i,%i",
                                            spho->penultima,spho->activeEndPos,spho->activeEndPos,spho->headxReadPos));
                            spho->penultima = spho->activeEndPos;
                            spho->activeEndPos = spho->headxReadPos;
                        }

                    } else if (PICO_EXC_BUF_OVERFLOW == rv) {
                        /* phoneme buffer cannot take this item anymore;
                           if the phoneme buffer has some contents, we are forced to transduce before reaching the sentence end
                           else we skip the (too long word) */
                        PICODBG_INFO(("PARSE returned from phoneme extraction with overflow, number of phonemes in phonBuf: %i; forced to TRANSDUCE", spho->phonWritePos));
                        if ((SPHO_POS_INVALID == spho->activeEndPos) || (spho->activeStartPos == spho->activeEndPos)) {
                            spho->activeEndPos = spho->headxReadPos;
                        }
                        spho->procState = SPHO_STEPSTATE_PROCESS_TRANSDUCE;
                        break;
                    } else {
                        PICODBG_ERROR(("PARSE returned from phoneme extraction with exception %i",rv));
                        return (picodata_step_result_t)picoos_emRaiseException(this->common->em,
                        PICO_ERR_OTHER, NULL, NULL);
                    }
                } else {
                    PICODBG_INFO(("PARSE found other item, passing over"));
                    /* it is "other" item, ignore */
                }
                /* set pos at next item */
                PICODBG_INFO(("PARSE going to next item: %i -> %i",spho->headxReadPos, spho->headxReadPos + 1));
                spho->headxReadPos++;
                break;

            case SPHO_STEPSTATE_PROCESS_TRANSDUCE:

                /* **********************************************************************/
                /* TRANSDUCE: transduction input pos/phon pairs to output pos/phon pairs */
                /* **********************************************************************/
                PICODBG_DEBUG(("TRANSDUCE (%i-th of %i fsts",spho->curFst+1, spho->numFsts));

                /* termination condition first */
                if (spho->curFst >= spho->numFsts) {

#if defined(PICO_DEBUG)
                    {
                        PICODBG_INFO_CTX();
                        PICODBG_INFO_MSG(("result of all transductions: "));
                        PICOTRNS_PRINTSYMSEQ(this->voice->kbArray[PICOKNOW_KBID_DBG], spho->phonBufOut, spho->phonWritePos);
                        PICODBG_INFO_MSG(("\n"));
                    }
#endif

                    /* reset for next transduction */
                    spho->curFst = 0;
                    /* prepare BOUNDS */
                    spho->outReadPos = 0;
                    spho->phonReadPos = 0;

                    spho->procState = SPHO_STEPSTATE_PROCESS_BOUNDS;
                    break;
                }

                /* transduce from phonBufIn to PhonBufOut */
                {

                    picoos_uint32 nrSteps;
#if defined(PICO_DEBUG)
                    {
                        PICODBG_INFO_CTX();
                        PICODBG_INFO_MSG(("spho trying to transduce: "));
                        PICOTRNS_PRINTSYMSEQ(this->voice->kbArray[PICOKNOW_KBID_DBG], spho->phonBuf, spho->phonWritePos);
                        PICODBG_INFO_MSG(("\n"));
                    }
#endif
                    rv = picotrns_transduce(spho->fst[spho->curFst], FALSE,
                    picotrns_printSolution, spho->phonBuf, spho->phonWritePos, spho->phonBufOut,
                            &spho->phonWritePos,
                            4*PICOTRNS_MAX_NUM_POSSYM, spho->altDescBuf,
                            spho->maxAltDescLen, &nrSteps);
                    if (PICO_OK == rv) {
#if defined(PICO_DEBUG)
                    {
                        PICODBG_INFO_CTX();
                        PICODBG_INFO_MSG(("result of transduction: (output symbols: %i)", spho->phonWritePos));
                        PICOTRNS_PRINTSYMSEQ(this->voice->kbArray[PICOKNOW_KBID_DBG], spho->phonBufOut, spho->phonWritePos);
                        PICODBG_INFO_MSG(("\n"));
                    }
#endif
                        PICODBG_TRACE(("number of steps done in tranduction: %i", nrSteps));
                    } else {
                        picoos_emRaiseWarning(this->common->em, PICO_WARN_FALLBACK,NULL,(picoos_char *)"phon buffer full");
                    }
                }
                /* eliminate deep epsilons */
                picotrns_eliminate_epsilons(spho->phonBufOut, spho->phonWritePos, spho->phonBuf,
                        &spho->phonWritePos,4*PICOTRNS_MAX_NUM_POSSYM);

                spho->curFst++;

                /* return PICODATA_PU_ATOMIC */
                break;


            case SPHO_STEPSTATE_PROCESS_BOUNDS:
                /* ************************************************************************/
                /* BOUNDS: combine input item with pos/phon pairs to insert/modify bounds */
                /* ************************************************************************/

                PICODBG_INFO(("BOUNDS"));

                /* get the suppressRecombWordBound in the left context */
                spho->suppressRecombWordBound = FALSE;
                while (spho->outReadPos < spho->activeStartPos) {
                    /* look at the current item */
                    ihead = spho->headx[spho->outReadPos].head;
                    /* icontent = spho->cbuf + spho->headx[spho->outReadPos].cind; */
                    PICODBG_INFO(("in position %i, looking at item %s",spho->outReadPos,picodata_head_to_string(&ihead,msgstr,SPHO_MSGSTR_SIZE)));
                    if (PICODATA_ITEM_BOUND == ihead.type) {
                        spho->suppressRecombWordBound = TRUE;
                    } else if (PICODATA_ITEM_WORDPHON == ihead.type) {
                        spho->suppressRecombWordBound = FALSE;
                    }
                    spho->outReadPos++;
                }
                /* spho->outReadPos point now to the active region */

                /* advance the phone reading pos to the active range */
                spho->phonReadPos = 0;
                while (SPHO_POSSYM_OK == (rv = getNextPosSym(spho, &pos, &sym,
                        spho->activeStartPos))) {
                    /* ignore */
                }
                PICODBG_INFO(("skipping left context phones results in %s", (SPHO_POSSYM_OUT_OF_RANGE==rv) ? "OUT_OF_RANGE" : (SPHO_POSSYM_END ==rv) ? "END" : "OTHER"));

                /*
                 * Align input items with transduced phones and note bound stregth changes and break commands
                 */

                while (spho->outReadPos < spho->activeEndPos) {

                    /* look at the current item */
                    ihead = spho->headx[spho->outReadPos].head;
                    icontent = spho->cbuf + spho->headx[spho->outReadPos].cind;
                    nextInPos = spho->outReadPos + 1;
                    /*  */
                    PICODBG_INFO(("in position %i, looking at item %s",spho->outReadPos,picodata_head_to_string(&ihead,msgstr,SPHO_MSGSTR_SIZE)));

                    if ((PICODATA_ITEM_BOUND == ihead.type)
                            || ((PICODATA_ITEM_WORDPHON == ihead.type)
                                    && (!spho->suppressRecombWordBound))) {
                        /* there was a boundary originally */
                        picoos_uint8 orig_strength, orig_type;
                        if (PICODATA_ITEM_BOUND == ihead.type) {
                            orig_strength = ihead.info1;
                            orig_type = ihead.info2;
                            spho->suppressRecombWordBound = TRUE;
                        } else {
                            orig_strength = PICODATA_ITEMINFO1_BOUND_PHR0;
                            orig_type = PICODATA_ITEMINFO2_NA;
                        }
                        /* i expect a boundary phone here */
                        /* consume FST bound phones, consider pending break and set the side-bound */
                        PICODBG_INFO(("got BOUND or WORDPHON item and expects corresponding phone"));
                        rv = getNextPosSym(spho, &pos, &sym, nextInPos);
                        if (SPHO_POSSYM_OK != rv) {
                            PICODBG_ERROR(("unexpected symbol or unexpected end of phoneme list (%s)", (SPHO_POSSYM_OUT_OF_RANGE==rv) ? "OUT_OF_RANGE" : (SPHO_POSSYM_END ==rv) ? "END" :"OTHER"));
                            return (picodata_step_result_t)picoos_emRaiseException(this->common->em,
                                    PICO_ERR_OTHER, NULL, NULL);
                        }
                        sym = picotrns_unplane(sym, &plane);
                        /*   */
                        PICODBG_ASSERT((PICOKFST_PLANE_PB_STRENGTHS == plane));

                        /* insert modified bound according to transduction and possibly pending break */
                        setSideBound(spho, orig_strength, orig_type,
                                (picoos_uint8) sym);
                    } else if ((PICODATA_ITEM_CMD == ihead.type)
                            && (PICODATA_ITEMINFO1_CMD_SIL == ihead.info1)) {
                        /* it's a SIL (break) command */
                        picoos_uint16 time;
                        picoos_uint32 pos = 0;
                        picoos_read_mem_pi_uint16(icontent, &pos, &time);
                        if (spho->breakPending) {
                            spho->breakTime += time;
                        } else {
                            spho->breakTime = time;
                            spho->breakPending = TRUE;
                        }
                    } else if ((PICODATA_ITEM_CMD == ihead.type) && (PICODATA_ITEMINFO1_CMD_PLAY == ihead.info1)) {
                        /* insert break of at least one ms */
                        if (!spho->breakPending || (spho->breakTime <= 0)) {
                            spho->breakTime = SPHO_SMALLEST_SIL_DUR;
                            spho->breakPending = TRUE;
                        }
                        setSideBound(spho, PICODATA_ITEMINFO1_NA,
                                PICODATA_ITEMINFO2_NA, PICODATA_ITEMINFO1_NA);
                        /* force following break to be at least one ms */
                        spho->breakTime = SPHO_SMALLEST_SIL_DUR;
                        spho->breakPending = TRUE;
                    } else if (breakStateInterrupting(&ihead, &breakBefore, &breakAfter)) {

                        if (breakBefore &&(!spho->breakPending || (spho->breakTime <= 0))) {
                            spho->breakTime = SPHO_SMALLEST_SIL_DUR;
                            spho->breakPending = TRUE;
                        }
                        setSideBound(spho, PICODATA_ITEMINFO1_NA,
                                PICODATA_ITEMINFO2_NA, PICODATA_ITEMINFO1_NA);

                        if (breakAfter) {
                            spho->breakTime = SPHO_SMALLEST_SIL_DUR;
                            spho->breakPending = TRUE;
                        }
                        if (PICODATA_ITEM_WORDPHON == ihead.type) {
                            spho->suppressRecombWordBound = FALSE;
                        }
                    }

                    /* skip phones of that item */
                    while (SPHO_POSSYM_OK == (rv = getNextPosSym(spho, &pos,
                            &sym, nextInPos))) {
                        /* ignore */
                    }
                    spho->outReadPos++;
                }

                /* reset for RECOMB */
                spho->outReadPos = 0;
                spho->phonReadPos = 0;
                spho->suppressRecombWordBound = FALSE;

                spho->procState = SPHO_STEPSTATE_PROCESS_RECOMB;
                return PICODATA_PU_ATOMIC;

                break;

           case SPHO_STEPSTATE_PROCESS_RECOMB:
                /* **********************************************************************/
                /* RECOMB: combine input item with pos/phon pairs to output item */
                /* **********************************************************************/

                PICODBG_TRACE(("RECOMB"));

                /* default place to come after feed: here */
                spho->feedFollowState = SPHO_STEPSTATE_PROCESS_RECOMB;

                /* check termination condition first */
                if (spho->outReadPos >= spho->activeEndPos) {
                    PICODBG_DEBUG(("RECOMB reached active region's end at %i",spho->outReadPos));
                    spho->procState = SPHO_STEPSTATE_SHIFT;
                    break;
                }

                /* look at the current item */
                ihead = spho->headx[spho->outReadPos].head;
                icontent = spho->cbuf + spho->headx[spho->outReadPos].cind;

                PICODBG_DEBUG(("RECOMB looking at item %s",picodata_head_to_string(&ihead,msgstr,SPHO_MSGSTR_SIZE)));

                nextInPos = spho->outReadPos + 1;

                PICODBG_DEBUG(("RECOMB treating item in headx at pos %i",spho->outReadPos));
                if (nextInPos <= spho->activeStartPos) { /* we're in the (passive) left context. Just skip it */
                    PICODBG_DEBUG(("RECOMB skipping item in the left context (%i <= %i)",nextInPos, spho->activeStartPos));
                    if (PICODATA_ITEM_BOUND == ihead.type) {
                        spho->suppressRecombWordBound = 1;
                    } else if (PICODATA_ITEM_WORDPHON == ihead.type) {
                        spho->suppressRecombWordBound = 0;
                    }

                    /* consume possyms */
                    while (SPHO_POSSYM_OK == (rv = getNextPosSym(spho,&pos,&sym,nextInPos))) {
                        /* ignore */
                    }
                    if (rv == SPHO_POSSYM_INVALID) {
                        return (picodata_step_result_t)picoos_emRaiseException(this->common->em,
                        PICO_ERR_OTHER, NULL, NULL);
                    }
                    spho->outReadPos = nextInPos;
                } else { /* active region */
                    if (spho->headx[spho->outReadPos].boundstrength) {
/* ***************** "side-bound" *********************/
                        /* copy to outbuf */
                        putSideBoundToOutput(spho);
                        /* mark as processed */
                        spho->headx[spho->outReadPos].boundstrength = 0;
                        /* output it */
                        spho->procState = SPHO_STEPSTATE_FEED;
                    } else if (PICODATA_ITEM_BOUND == ihead.type) {
/* ***************** BOUND *********************/
                        /* expect a boundary phone here */
                        PICODBG_DEBUG(("RECOMB got BOUND item and expects corresponding phone"));
                        rv = getNextPosSym(spho, &pos, &sym, nextInPos);
                        if (SPHO_POSSYM_OK != rv) {
                            PICODBG_ERROR(("unexpected symbol or unexpected end of phoneme list"));
                            return (picodata_step_result_t)picoos_emRaiseException(
                                    this->common->em, PICO_ERR_OTHER, NULL,
                                    NULL);
                        }
                        sym = picotrns_unplane(sym, &plane);
                        /*   */
                        PICODBG_ASSERT((PICOKFST_PLANE_PB_STRENGTHS == plane));

                        spho->suppressRecombWordBound = TRUE; /* if word following, don't need word boundary */
                        /* just consume item and come back here*/
                        spho->outReadPos = nextInPos;

                    } else if (PICODATA_ITEM_WORDPHON == ihead.type) {
/* ***************** WORDPHON *********************/
                        spho->wordStarted = TRUE;
                        /* i expect a word boundary symbol in this range unless a phrase boundary was encountered before */
                        if (spho->suppressRecombWordBound) {
                            PICODBG_DEBUG(("RECOMB got WORDPHON item but skips expecting BOUND"));
                            spho->suppressRecombWordBound = FALSE;
                        } else {
                            PICODBG_DEBUG(("RECOMB got WORDPHON item and expects corresponding bound phone"));
                            rv = getNextPosSym(spho, &pos, &sym, nextInPos);
                            if (SPHO_POSSYM_OK != rv) {
                                PICODBG_ERROR(("unexpected symbol or unexpected end of phoneme list"));
                                return (picodata_step_result_t)picoos_emRaiseException(this->common->em,
                                PICO_ERR_OTHER, NULL, NULL);
                            }
                        }
                        spho->procState = SPHO_STEPSTATE_PROCESS_SYL;
                    } else if ((PICODATA_ITEM_CMD == ihead.type) && (PICODATA_ITEMINFO1_CMD_SIL == ihead.info1)) {
/* ***************** BREAK COMMAND *********************/
                        /* just consume and come back here */
                        PICODBG_DEBUG(("RECOMB consuming item from inBuf %i -> %i",spho->outReadPos, nextInPos));
                        spho->outReadPos = nextInPos;
                    } else {
/* ***************** OTHER *********************/
                        /* just copy item */
                        PICODBG_DEBUG(("RECOMB found other item, just copying"));
                        picodata_put_itemparts(&ihead, icontent, ihead.len,
                                spho->outBuf, spho->outBufSize, &clen);
                        PICODBG_DEBUG(("RECOMB consuming item from inBuf %i -> %i",spho->outReadPos, nextInPos));
                        spho->outReadPos = nextInPos;
                        /* and output it */
                        spho->procState = SPHO_STEPSTATE_FEED;
                    } /* if (ihead.type) */

                }

                /* return PICODATA_PU_BUSY; */
                break;

            case SPHO_STEPSTATE_PROCESS_SYL:
                /* **********************************************************************/
                /* SYL: combine input word item with pos/phon pairs to syl output item */
                /* **********************************************************************/

                /* consume all transduced phonemes with pos in in the range [spho->outReadPos,nextInPos[ */
               PICODBG_DEBUG(("SYL"));

               spho->feedFollowState = SPHO_STEPSTATE_PROCESS_SYL;

               /* look at the current item */
               ihead = spho->headx[spho->outReadPos].head;
               icontent = spho->cbuf + spho->headx[spho->outReadPos].cind;
                nextInPos = spho->outReadPos + 1;
                PICODBG_DEBUG(("SYL (1) treating item in headx at pos %i",spho->outReadPos));
                /* create syllable item in ohead (head) and sylBuf (contents) */
                ohead.type = PICODATA_ITEM_SYLLPHON;

                PICODBG_TRACE(("SYL expects accent at phonBuf[%i] = (%i,%i) (outReadPos=%i)", spho->phonReadPos, spho->phonBuf[spho->phonReadPos].pos, spho->phonBuf[spho->phonReadPos].sym,spho->outReadPos));
                rv = getNextPosSym(spho,&pos,&sym,nextInPos);
                if (SPHO_POSSYM_OK != rv) {
                    PICODBG_ERROR(("unexpected symbol or unexpected end of phoneme list (%i)",rv));
                    return (picodata_step_result_t)picoos_emRaiseException(this->common->em, PICO_ERR_OTHER, NULL, NULL);
                }
                ohead.info2 = picotrns_unplane(sym, &plane);
                PICODBG_ASSERT((PICOKFST_PLANE_ACCENTS == plane));
                PICODBG_DEBUG(("SYL sets accent to %c", sym));

                /* for the time being, we force to use POS so we can transduce all fsts in a row without reconsulting the items */
                PICODBG_TRACE(("SYL expects POS"));
                PICODBG_DEBUG(("SYL (2) treating item in inBuf range [%i,%i[",spho->outReadPos,nextInPos));
                rv = getNextPosSym(spho,&pos,&sym,nextInPos);
                if (SPHO_POSSYM_OK != rv) {
                    PICODBG_ERROR(("unexpected symbol or unexpected end of phoneme list"));
                    return (picodata_step_result_t)picoos_emRaiseException(this->common->em, PICO_ERR_OTHER, NULL, NULL);
                }
                if (spho->wordStarted) {
                    spho->wordStarted = FALSE;
                    ohead.info1 = picotrns_unplane(sym, &plane);
                    /*  */
                    PICODBG_ASSERT(PICOKFST_PLANE_POS == plane);
                    /*  */
                    PICODBG_DEBUG(("SYL setting POS to %c", ohead.info1));
                } else {
                    ohead.info1 = PICODATA_ITEMINFO1_NA;
                }

                PICODBG_DEBUG(("SYL (3) treating item in inBuf range [%i,%i[",spho->outReadPos,nextInPos));
                /* get phonemes of that syllable; stop if syllable boundary or outside word */
                sylsym = (PICOKFST_PLANE_PHONEMES << 8)
                        + spho->syllSepId;
                PICODBG_DEBUG(("collecting syllable phonemes before headx position %i",nextInPos));
                spho->sylWritePos = 0;
                while (SPHO_POSSYM_OK == (rv = getNextPosSym(spho,&pos,&sym,nextInPos)) && (sym != sylsym)) {
                    spho->sylBuf[spho->sylWritePos++] = picotrns_unplane(sym, &plane);
                    /*  */
                   PICODBG_TRACE(("SYL adding phoneme to syllable: (pos %i,sym %i)[plane %i,sym %c]",pos,sym,plane,sym  & 0xFF));
                    PICODBG_ASSERT((PICOKFST_PLANE_PHONEMES == plane));
                }
                PICODBG_DEBUG(("SYL (4) treating item in inBuf range [%i,%i[",spho->outReadPos,nextInPos));
                ohead.len = spho->sylWritePos;
                if (SPHO_POS_INVALID == rv) {
                    PICODBG_ERROR(("unexpected symbol or unexpected end of phoneme list"));
                    return (picodata_step_result_t)picoos_emRaiseException(this->common->em, PICO_WARN_INCOMPLETE, NULL, NULL);
                } else if ((SPHO_POSSYM_OUT_OF_RANGE == rv) || (SPHO_POSSYM_END == rv)) {
                    PICODBG_DEBUG(("SYL arrived at end of word and/or end of phon buffer, go to next word"));
                    spho->outReadPos = nextInPos; /* advance to next item */
                    spho->feedFollowState = SPHO_STEPSTATE_PROCESS_RECOMB; /* go to RECOMB after feed */
                 } else {
                    PICODBG_ASSERT((sym == sylsym));
                }
                PICODBG_DEBUG(("SYL (5) treating item in inBuf range [%i,%i[",spho->outReadPos,nextInPos));

                if (ohead.len > 0) {
                    /* prepare syllable output */
                    picodata_put_itemparts(&ohead, spho->sylBuf,
                            PICODATA_BUFSIZE_DEFAULT, spho->outBuf,
                            spho->outBufSize, &clen);

                    spho->procState = SPHO_STEPSTATE_FEED;
                } else { /* skip feeding output of empty syllable */
                    spho->procState = spho->feedFollowState;
                }
                break;

             case SPHO_STEPSTATE_FEED:
                /* **********************************************************************/
                /* FEED: output output item and proceed to feedFollowState */
                /* **********************************************************************/

                PICODBG_DEBUG(("FEED"));

                PICODBG_DEBUG(("FEED putting outBuf item into cb"));

                /*feeding items to PU output buffer*/
                rv = picodata_cbPutItem(this->cbOut, spho->outBuf,
                        spho->outBufSize, &clen);

                PICODATA_INFO_ITEM(this->voice->kbArray[PICOKNOW_KBID_DBG],
                        (picoos_uint8 *)"spho: ",
                        spho->outBuf, spho->outBufSize);

                if (PICO_EXC_BUF_OVERFLOW == rv) {
                    /* we have to redo this item */
                    PICODBG_DEBUG(("FEED got overflow, returning ICODATA_PU_OUT_FULL"));
                    return PICODATA_PU_OUT_FULL;
                } else if (PICO_OK == rv) {
                    *numBytesOutput += clen;
                    spho->procState = spho->feedFollowState;
                    PICODBG_DEBUG(("FEED ok, going back to procState %i", spho->procState));
                    return PICODATA_PU_BUSY;
                } else {
                    PICODBG_DEBUG(("FEED got exception %i when trying to output item",rv));
                    spho->procState = spho->feedFollowState;
                    return (picodata_step_result_t)rv;
                }
                break;

            case SPHO_STEPSTATE_SHIFT:
                /* **********************************************************************/
                /* SHIFT                                                              */
                /* **********************************************************************/
                /* If there exists a valid penultima, it should replace any left context (from 0 to activeStartPos)
                 * else discard the current active range (from activeStartPos to activeEndPos), leaving the current
                 * left context intact. Often, PARSE would move activeStartPos to 0, so that there is no left context
                 * after the shift.
                 */

                PICODBG_DEBUG(("SHIFT"));

                if (spho->penultima != SPHO_POS_INVALID) {
                    picoos_int16 shift;
                    /* set penultima as new left context and set activeStartPos to the shifted activeEndPos */
                    PICODBG_DEBUG((
                                    "SHIFT shifting penultima from %i to 0",
                                    spho->penultima));
                    shift = shift_range_left_1(spho, &spho->penultima, 0);
                    if (shift < 0) {
                        picoos_emRaiseException(this->common->em,PICO_ERR_OTHER,NULL,NULL);
                        return PICODATA_PU_ERROR;
                    }
                    spho->activeStartPos = spho->activeEndPos
                            - shift;
                    spho->lastPhraseBoundPos -= shift;
                    spho->suppressParseWordBound = FALSE;
                    spho->suppressRecombWordBound = FALSE;

                } else {
                    picoos_int16 shift;
                    picoos_bool lastPhraseBoundActive;
                    if (spho->activeStartPos == spho->activeEndPos) {
                        /* no items consumed; we have to abandon left context */
                        spho->activeStartPos = 0;
                    }
                    lastPhraseBoundActive = (spho->lastPhraseBoundPos >= spho->activeStartPos);
                    /* dummy comment */
                    PICODBG_DEBUG(("SHIFT shift active end from %i to %i",
                                    spho->activeEndPos, spho->activeStartPos));
                    shift = shift_range_left_1(spho, &spho->activeEndPos, spho->activeStartPos);
                    if (shift < 0) {
                        picoos_emRaiseException(this->common->em,PICO_ERR_OTHER,NULL,NULL);
                        return PICODATA_PU_ERROR;
                    }
                    if (lastPhraseBoundActive) {
                        spho->lastPhraseBoundPos -= shift;
                    }
                }

                spho->procState = SPHO_STEPSTATE_INIT;
                break;

            default:
                picoos_emRaiseException(this->common->em, PICO_ERR_OTHER, NULL, NULL);
                return PICODATA_PU_ERROR;
                break;

        } /* switch (spho->procState) */

    } /* while (1) */

    /* should be never reached */
    picoos_emRaiseException(this->common->em, PICO_ERR_OTHER, NULL, NULL);
    return PICODATA_PU_ERROR;
}

#ifdef __cplusplus
}
#endif

/* end picospho.c */