/*
* 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_int32 resetMode)
{
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, PICO_RESET_FULL);
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 */