diff options
Diffstat (limited to 'lib/picopam.c')
| -rw-r--r-- | lib/picopam.c | 4803 |
1 files changed, 4803 insertions, 0 deletions
diff --git a/lib/picopam.c b/lib/picopam.c new file mode 100644 index 0000000..02e5cc2 --- /dev/null +++ b/lib/picopam.c @@ -0,0 +1,4803 @@ +/* + * 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 picopam.c + * + * Phonetic to Acoustic Mapping PU - Implementation + * + * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland + * All rights reserved. + * + * History: + * - 2009-04-20 -- initial version + * + */ + +#include "picodefs.h" +#include "picoos.h" +#include "picodbg.h" +#include "picodata.h" +#include "picopam.h" +#include "picokdt.h" +#include "picokpdf.h" +#include "picoktab.h" +#include "picokdbg.h" +#include "picodsp.h" + +#ifdef __cplusplus +extern "C" { +#endif +#if 0 +} +#endif + +#define PICOPAM_IN_BUFF_SIZE PICODATA_BUFSIZE_PAM /*input buffer size for PAM */ +#define PICOPAM_OUT_PAM_SIZE PICODATA_BUFSIZE_PAM /*output buffer size for PAM*/ +#define PICOPAM_DT_NRLFZ 5 /* nr of lfz decision trees per phoneme */ +#define PICOPAM_DT_NRMGC 5 /* nr of mgc decision trees per phoneme */ +#define PICOPAM_NRSTPF 5 /* nr of states per phone */ + +#define PICOPAM_COLLECT 0 +#define PICOPAM_SCHEDULE 1 +#define PICOPAM_IMMEDIATE 2 +#define PICOPAM_FORWARD 3 +#define PICOPAM_FORWARD_FORCE_TERM 4 +#define PICOPAM_PROCESS 5 +#define PICOPAM_PLAY 6 +#define PICOPAM_FEED 7 + +#define PICOPAM_CONTINUE 100 +#define PICOPAM_GOTO_SCHEDULE 1 +#define PICOPAM_FLUSH_RECEIVED 6 +#define PICOPAM_GOTO_FEED 7 +#define PICOPAM_PRE_SYLL_ENDED 10 + +#define PICOPAM_BREAK_ADD_SIZE 4 /*syllable feature vector increment dued to BREAK and SILENCE*/ +#define PICOPAM_VECT_SIZE 64+PICOPAM_BREAK_ADD_SIZE /*syllable feature vector size (bytes)*/ +#define PICOPAM_INVEC_SIZE 60 /*phone feature vector size */ +#define PICOPAM_MAX_SYLL_PER_SENT 100 /*maximum number of syllables per sentece*/ +#define PICOPAM_MAX_PH_PER_SENT 400 /*maximum number of phonemes per sentece*/ +#define PICOPAM_MAX_ITEM_PER_SENT 255 /*maximum number of attached items per sentence*/ +#define PICOPAM_MAX_ITEM_SIZE_PER_SENT 4096 /*maximum size of attached items per sentence*/ + +#define PICOPAM_READY 20 /*PAM could start backward processing*/ +#define PICOPAM_MORE 21 /*PAM has still to collect */ +#define PICOPAM_NA 22 /*PAM has not to deal with this item*/ +#define PICOPAM_ERR 23 /*input item is not a valid item*/ + +/*sentence types:cfr pam_map_sentence_type*/ +#define PICOPAM_DECLARATIVE 0 +#define PICOPAM_INTERROGATIVE 1 +#define PICOPAM_EXCLAMATIVE 2 + +#define PICOPAM_T 0 +#define PICOPAM_P 1 +#define PICOPAM_p 2 +#define PICOPAM_Y 3 + +#if 1 +#define PAM_PHR2_WITH_PR1 1 /*deal with PHR2 boundaries as with PHR1*/ +#else +#define PAM_PHR2_WITH_PR3 1 /*deal with PHR2 boundaries as with PHR3*/ +#endif + +#define PICOPAM_DONT_CARE_VALUE 250 /*don't care value for tree printout */ +#define PICOPAM_DONT_CARE_VAL 10 /*don't care value for tree feeding */ +#define PICOPAM_PH_DONT_CARE_VAL 7 /*don't care value for tree feeding (phonetic)*/ + +#define PICOPAM_MAX_STATES_PER_PHONE 5 /*number of states per phone */ +#define PICOPAM_STATE_SIZE_IN_ITEM 6 /*size of a state in frame item */ +#define PICOPAM_FRAME_ITEM_SIZE 4+PICOPAM_MAX_STATES_PER_PHONE*PICOPAM_STATE_SIZE_IN_ITEM + +#define PICOPAM_DIR_FORW 0 /*forward adapter processing*/ +#define PICOPAM_DIR_BACK 1 /*backward adapter processing*/ +#define PICOPAM_DIR_SIL 2 /*final silence attributes*/ + +#define PICOPAM_SYLL_PAUSE 0 /*syllable but containing a pause phone*/ +#define PICOPAM_SYLL_SYLL 1 /*a real syllable with phonemes*/ + +#define PICOPAM_EVENT_P_BOUND 0 /*primary boundary*/ +#define PICOPAM_EVENT_S_BOUND 1 /*secondary boundary*/ +#define PICOPAM_EVENT_W_BOUND 3 /*word boundary*/ +#define PICOPAM_EVENT_SYLL 4 /*syllable*/ + +/* ----- CONSTANTS FOR BREAK COMMAND SUPPORT ----- */ +#define PICOPAM_PWIDX_SBEG 0 +#define PICOPAM_PWIDX_PHR1 1 +#define PICOPAM_PWIDX_PHR2 2 +#define PICOPAM_PWIDX_SEND 3 +#define PICOPAM_PWIDX_DEFA 4 +#define PICOPAM_PWIDX_SIZE 5 + +/*----------------------------------------------------------------*/ +/*structure related to the feature vectors for feeding the trees */ +/*NOTE : the same data structure is used to manage the syllables */ +/* Using the first 8 fields for marking the boundaries */ +/* and using the last 4 bytes as follows */ +/* byte 61 : 1st attached non PAM item id(0=no item attached) */ +/* in the "sSyllItemOffs" data structure */ +/* byte 62 : last attached non PAM item id(0=no item attached)*/ +/* in the "sSyllItemOffs" data structure */ +/* byte 63..64 : offset of the start of the syllable in */ +/* the "sPhIds" data structure */ +typedef struct +{ + picopal_uint8 phoneV[PICOPAM_VECT_SIZE]; +} sFtVect, *pSftVect; + +/*---------------------------------------------------------- + Name : pam_subobj + Function: subobject definition for the pam processing + Shortcut: pam + ---------------------------------------------------------*/ +typedef struct pam_subobj +{ + /*----------------------PU voice management------------------------------*/ + /* picorsrc_Voice voice; */ + /*----------------------PU state management------------------------------*/ + picoos_uint8 procState; /* where to take up work at next processing step */ + picoos_uint8 retState; /* where to go back from feed state at next p.s. */ + picoos_uint8 needMoreInput; /* more data necessary to start processing */ + /*----------------------PU input management------------------------------*/ + picoos_uint8 inBuf[PICOPAM_IN_BUFF_SIZE]; /* internal input buffer */ + picoos_uint16 inBufSize; /* actually allocated size */ + picoos_uint16 inReadPos, inWritePos; /* next pos to read/write from/to inBuf*/ + /*----------------------PU output management-----------------------------*/ + picoos_uint8 outBuf[PICOPAM_OUT_PAM_SIZE]; /* internal output buffer */ + picoos_uint16 outBufSize; /* actually allocated size */ + picoos_uint16 outReadPos, outWritePos; /* next pos to read/write from/to outBuf*/ + /*---------------------- adapter working buffers --------------------*/ + picoos_uint8 *sPhFeats; /*feature vector for a single phone */ + sFtVect *sSyllFeats; /*Syllable feature vector set for the + full sentence */ + picoos_uint8 *sPhIds; /*phone ids for the full sentence */ + picoos_uint8 *sSyllItems; /*items attached to the syllable */ + picoos_int16 *sSyllItemOffs;/*offset of items attached to the syllable*/ + /*---------------------- adapter general variables ---------------------*/ + picoos_int16 nTotalPhonemes; /*number of phonemes in the sentence*/ + picoos_int16 nCurrPhoneme; /*current phoneme in the sentence */ + picoos_int16 nSyllPhoneme; /*current phoneme in the syllable */ + picoos_int16 nCurrSyllable; /*current syllable in the sentence */ + picoos_int16 nTotalSyllables; /*number of syllables in the sentence -> J1*/ + picoos_uint8 nLastAttachedItemId;/*last attached item id*/ + picoos_uint8 nCurrAttachedItem; /*current attached item*/ + picoos_int16 nAttachedItemsSize; /*total size of the attached items*/ + picoos_uint8 sType; /*Sentence type*/ + picoos_uint8 pType; /*Phrase type*/ + picoos_single pMod; /*pitch modifier*/ + picoos_single dMod; /*Duration modifier*/ + picoos_single dRest; /*Duration modifier rest*/ + /*---------------------- adapter specific component variables ----------*/ + picoos_uint8 a3_overall_syllable; /* A3 */ + picoos_uint8 a3_primary_phrase_syllable; + picoos_uint8 b4_b5_syllable; /* B4,B5 */ + picoos_uint8 b6_b7_syllable; /* B6,B7 */ + picoos_uint8 b6_b7_state; + picoos_uint8 b8_b9_stressed_syllable; /* B8,B9 */ + picoos_uint8 b10_b11_accented_syllable; /* B10,B11 */ + picoos_uint8 b12_b13_syllable; /* B12,B13 */ + picoos_uint8 b12_b13_state; + picoos_uint8 b14_b15_syllable; /* B14,B15 */ + picoos_uint8 b14_b15_state; + picoos_uint8 b17_b19_syllable; /* B17,B19 */ + picoos_uint8 b17_b19_state; + picoos_uint8 b18_b20_b21_syllable; /* B18,B20,B21 */ + picoos_uint8 b18_b20_b21_state; + picoos_uint8 c3_overall_syllable; /* C3 */ + picoos_uint8 c3_primary_phrase_syllable; + picoos_uint8 d2_syllable_in_word; /* D2 */ + picoos_uint8 d2_prev_syllable_in_word; + picoos_uint8 d2_current_primary_phrase_word; + picoos_int8 e1_syllable_word_start; /* E1 */ + picoos_int8 e1_syllable_word_end; + picoos_uint8 e1_content; + picoos_int8 e2_syllable_word_start; /* E2 */ + picoos_int8 e2_syllable_word_end; + picoos_uint8 e3_e4_word; /* E3,E4 */ + picoos_uint8 e3_e4_state; + picoos_uint8 e5_e6_content_word; /* E5,E6 */ + picoos_uint8 e5_e6_content; + picoos_uint8 e7_e8_word; /* E7,E8 */ + picoos_uint8 e7_e8_content; + picoos_uint8 e7_e8_state; + picoos_uint8 e9_e11_word; /* E9,E11 */ + picoos_uint8 e9_e11_saw_word; + picoos_uint8 e9_e11_state; + picoos_uint8 e10_e12_e13_word; /* E10,E12,E13 */ + picoos_uint8 e10_e12_e13_state; + picoos_uint8 e10_e12_e13_saw_word; + picoos_uint8 f2_overall_word; /* F2 */ + picoos_uint8 f2_word_syllable; + picoos_uint8 f2_next_word_syllable; + picoos_uint8 f2_current_primary_phrase_word; + picoos_int8 g1_current_secondary_phrase_syllable; /*G1 */ + picoos_int8 g1_current_syllable; + picoos_int8 g2_current_secondary_phrase_word; /*G2 */ + picoos_int8 g2_current_word; + picoos_uint8 h1_current_secondary_phrase_syll; /*H1 */ + picoos_uint8 h2_current_secondary_phrase_word; /*H2 */ + picoos_uint8 h3_h4_current_secondary_phrase_word; /*H3,H4 */ + picoos_uint8 h5_current_phrase_type; /*H5 */ + + picoos_uint8 h5_syllable; /* H5 */ + picoos_uint8 h5_state; + + picoos_uint8 i1_secondary_phrase_syllable; /*I1 */ + picoos_uint8 i1_next_secondary_phrase_syllable; + picoos_uint8 i2_secondary_phrase_word; /*I2 */ + picoos_uint8 i2_next_secondary_phrase_word; + picoos_uint8 j1_utterance_syllable; /*J1 */ + picoos_uint8 j2_utterance_word; /*J2 */ + picoos_uint8 j3_utterance_sec_phrases; /*J3 */ + /*---------------------- constant data -------------------*/ + picoos_uint16 sil_weights[PICOPAM_PWIDX_SIZE][PICOPAM_MAX_STATES_PER_PHONE]; + /*---------------------- LINGWARE related data -------------------*/ + picokdt_DtPAM dtdur; /* dtdur knowledge base */ + picokdt_DtPAM dtlfz[PICOPAM_DT_NRLFZ]; /* dtlfz knowledge bases */ + picokdt_DtPAM dtmgc[PICOPAM_DT_NRMGC]; /* dtmgc knowledge bases */ + /*---------------------- Pdfs related data -------------------*/ + picokpdf_PdfDUR pdfdur; /* pdfdur knowledge base */ + picokpdf_PdfMUL pdflfz; /* pdflfz knowledge base */ + /*---------------------- Tree traversal related data -------------------*/ + picoos_uint16 durIndex; + picoos_uint8 numFramesState[PICOPAM_DT_NRLFZ]; + picoos_uint16 lf0Index[PICOPAM_DT_NRLFZ]; + picoos_uint16 mgcIndex[PICOPAM_DT_NRMGC]; + /*---------------------- temps for updating the feature vector ---------*/ + picoos_uint16 phonDur; + picoos_single phonF0[PICOPAM_DT_NRLFZ]; + /*---------------------- Phones related data -------------------*/ + picoktab_Phones tabphones; +} pam_subobj_t; + + +/* ----- CONSTANTS FOR FEATURE VECTOR BUILDING (NOT PREFIXED WITH "PICOPAM_" FOR BREVITY) ----- */ +#define P1 0 /*field 1 of the input vector*/ +#define P2 1 +#define P3 2 +#define P4 3 +#define P5 4 +#define P6 5 +#define P7 6 +#define bnd 6 /*boundary type item associated to the syllable = P7 */ +#define P8 7 +#define A3 8 +#define B1 9 +#define B2 10 +#define B3 11 +#define B4 12 +#define B5 13 +#define B6 14 +#define B7 15 +#define B8 16 +#define B9 17 +#define B10 18 +#define B11 19 +#define B12 20 +#define B13 21 +#define B14 22 +#define B15 23 +#define B16 24 +#define B17 25 +#define B18 26 +#define B19 27 +#define B20 28 +#define B21 29 +#define C3 30 +#define D2 31 +#define E1 32 +#define E2 33 +#define E3 34 +#define E4 35 +#define E5 36 +#define E6 37 +#define E7 38 +#define E8 39 +#define E9 40 +#define E10 41 +#define E11 42 +#define E12 43 +#define E13 44 +#define F2 45 +#define G1 46 +#define G2 47 +#define H1 48 +#define H2 49 +#define H3 50 +#define H4 51 +#define H5 52 +#define I1 53 +#define I2 54 +#define J1 55 +#define J2 56 +#define J3 57 +#define DUR 58 /*duration component*/ +#define F0 59 /*F0 component*/ +#define ITM 60 /*Item Offset into sSyllItems item list*/ +#define itm 61 /*second byte of the Item Offset */ +#define FID 62 /*Phoneme offset in the sPhIds phoneme list*/ +#define fid 63 /*second byte of the Phoneme offset */ +#define Min 64 /*offset to min syllable duration (uint 16,pauses)*/ +#define Max 66 /*offset to max syllable duration (uint 16,pauses)*/ +/* ------------------------------------------------------------------- + PAM feature vector indices position changes, + ------------------------------------------------------------------- */ +#define T_B1 8 +#define T_B2 9 +#define T_B3 10 +#define T_B4 11 +#define T_B5 12 +#define T_B6 13 +#define T_B7 14 +#define T_B8 15 +#define T_B9 16 +#define T_B10 17 +#define T_B11 18 +#define T_B12 19 +#define T_B13 20 +#define T_B14 21 +#define T_B15 22 +#define T_B16 23 +#define T_B17 24 +#define T_B18 25 +#define T_B19 26 +#define T_B20 27 +#define T_B21 28 +#define T_E1 29 +#define T_E2 30 +#define T_E3 31 +#define T_E4 32 +#define T_E5 33 +#define T_E6 34 +#define T_E7 35 +#define T_E8 36 +#define T_E9 37 +#define T_E10 38 +#define T_E11 39 +#define T_E12 40 +#define T_E13 41 +#define T_A3 42 +#define T_C3 43 +#define T_D2 44 +#define T_F2 45 +#define T_G1 46 +#define T_I1 47 +#define T_G2 48 +#define T_I2 49 +#define T_H1 50 +#define T_H2 51 +#define T_H3 52 +#define T_H4 53 +#define T_H5 54 + +/*------------------------------------------------------------------ + Service routines : + ------------------------------------------------------------------*/ +static pico_status_t pam_initialize(register picodata_ProcessingUnit this); +static pico_status_t pam_terminate(register picodata_ProcessingUnit this); +static pico_status_t pam_allocate(picoos_MemoryManager mm, pam_subobj_t *pam); +static void pam_deallocate(picoos_MemoryManager mm, pam_subobj_t *pam); +static pico_status_t pam_subobj_deallocate(register picodata_ProcessingUnit this, + picoos_MemoryManager mm); +/*------------------------------------------------------------------ + Processing routines : + ------------------------------------------------------------------*/ +static picodata_step_result_t pam_step(register picodata_ProcessingUnit this, + picoos_int16 mode, picoos_uint16 * numBytesOutput); +static pico_status_t pam_deal_with(const picoos_uint8 *item); +/*Utility*/ +static picoos_uint8 pam_get_vowel_name(register picodata_ProcessingUnit this, + picoos_uint8 *item, picoos_uint8 *pos); +static picoos_uint8 pam_get_pause_id(register picodata_ProcessingUnit this); + +static picoos_uint8 pam_map_sentence_type(picoos_uint8 iteminfo1, + picoos_uint8 iteminfo2); +static picoos_uint8 pam_map_phrase_type(picoos_uint8 iteminfo1, + picoos_uint8 iteminfo2); + +/*Adapter*/ +static pico_status_t pam_reset_processors(register picodata_ProcessingUnit this); +static pico_status_t pam_reset_processors_back( + register picodata_ProcessingUnit this); +static pico_status_t pam_create_syllable(register picodata_ProcessingUnit this, + picoos_uint8 syllType, picoos_uint8 *sContent, picoos_uint8 sentType, + picoos_uint8 phType, picoos_uint8 uBoundType, picoos_uint16 uMin, + picoos_uint16 uMax); +static pico_status_t pam_process_event_feature( + register picodata_ProcessingUnit this, picoos_uint8 nFeat, + picoos_uint8 event_type, picoos_uint8 direction); +static pico_status_t pam_process_event(register picodata_ProcessingUnit this, + picoos_uint8 event_type, picoos_uint8 direction); +static pico_status_t pam_adapter_forward_step( + register picodata_ProcessingUnit this, picoos_uint8 *itemBase); +static pico_status_t pam_adapter_backward_step( + register picodata_ProcessingUnit this); +static pico_status_t pam_do_pause(register picodata_ProcessingUnit this); +static pico_status_t pam_adapter_do_pauses(register picodata_ProcessingUnit this); +/*-------------- tree traversal ---------------------------------------*/ +static pico_status_t pam_expand_vector(register picodata_ProcessingUnit this); +static picoos_uint8 pam_do_tree(register picodata_ProcessingUnit this, + const picokdt_DtPAM dtpam, const picoos_uint8 *invec, + const picoos_uint8 inveclen, picokdt_classify_result_t *dtres); +static pico_status_t pam_get_f0(register picodata_ProcessingUnit this, + picoos_uint16 *lf0Index, picoos_uint8 nState, picoos_single *phonF0); +static pico_status_t pam_get_duration(register picodata_ProcessingUnit this, + picoos_uint16 durIndex, picoos_uint16 *phonDur, + picoos_uint8 *numFramesState); +static pico_status_t pam_update_vector(register picodata_ProcessingUnit this); +/*-------------- FINAL ITEM FEEDING -----------------------------------------*/ +static pico_status_t pam_put_item(register picodata_ProcessingUnit this, + picoos_uint8 *outBuff, picoos_uint16 outWritePos, + picoos_uint8 *bytesWr); + +static pico_status_t pam_put_term(picoos_uint8 *outBuff, + picoos_uint16 outWritePos, picoos_uint8 *bytesWr); + +static pico_status_t is_pam_command(const picoos_uint8 *qItem); + +static void get_default_boundary_limit(picoos_uint8 uBoundType, + picoos_uint16 *uMinDur, picoos_uint16 *uMaxDur); + +/* ------------------------------------------------------------- + * Pico System functions + * ------------------------------------------------------------- + */ + +/** + * allocation for PAM memory on pam PU + * @param mm : handle to engine memory manager + * @param pam : handle to a pam struct + * @return PICO_OK : allocation successful + * @return PICO_ERR_OTHER : allocation errors + * @callgraph + * @callergraph + */ +static pico_status_t pam_allocate(picoos_MemoryManager mm, pam_subobj_t *pam) +{ + picoos_uint8 *data; + picoos_int16 *dataI; + + pam->sSyllFeats = NULL; + pam->sPhIds = NULL; + pam->sPhFeats = NULL; + pam->sSyllItems = NULL; + pam->sSyllItemOffs = NULL; + + /*----------------------------------------------------------------- + * PAM Local buffers ALLOCATION + ------------------------------------------------------------------*/ + /*PAM Local buffers*/ + data = (picopal_uint8 *) picoos_allocate(mm, sizeof(sFtVect) + * PICOPAM_MAX_SYLL_PER_SENT); + if (data == NULL) + return PICO_ERR_OTHER; + pam->sSyllFeats = (sFtVect*) data; + + data = (picopal_uint8 *) picoos_allocate(mm, sizeof(picopal_uint8) + * PICOPAM_MAX_PH_PER_SENT); + if (data == NULL) { + pam_deallocate(mm, pam); + return PICO_ERR_OTHER; + } + pam->sPhIds = (picopal_uint8*) data; + + data = (picopal_uint8 *) picoos_allocate(mm, sizeof(picopal_uint8) + * PICOPAM_VECT_SIZE); + if (data == NULL) { + pam_deallocate(mm, pam); + return PICO_ERR_OTHER; + } + pam->sPhFeats = (picopal_uint8*) data; + + data = (picopal_uint8 *) picoos_allocate(mm, sizeof(picopal_uint8) + * PICOPAM_MAX_ITEM_SIZE_PER_SENT); + if (data == NULL) { + pam_deallocate(mm, pam); + return PICO_ERR_OTHER; + } + pam->sSyllItems = (picopal_uint8*) data; + + dataI = (picoos_int16 *) picoos_allocate(mm, sizeof(picoos_int16) + * PICOPAM_MAX_ITEM_PER_SENT); + if (data == NULL) { + pam_deallocate(mm, pam); + return PICO_ERR_OTHER; + } + pam->sSyllItemOffs = (picoos_int16*) dataI; + + return PICO_OK; +}/*pam_allocate*/ + +/** + * frees allocation for DSP memory on PAM PU + * @param mm : memory manager + * @param pam : pam PU internal sub-object + * @return void + * @remarks modified and inserted in sub obj removal PP 15.09.08 + * @callgraph + * @callergraph + */ +static void pam_deallocate(picoos_MemoryManager mm, pam_subobj_t *pam) +{ + /*----------------------------------------------------------------- + * Memory de-allocations + * ------------------------------------------------------------------*/ + if (pam->sSyllFeats != NULL) + picoos_deallocate(mm, (void *) &pam->sSyllFeats); + if (pam->sPhIds != NULL) + picoos_deallocate(mm, (void *) &pam->sPhIds); + if (pam->sPhFeats != NULL) + picoos_deallocate(mm, (void *) &pam->sPhFeats); + if (pam->sSyllItems != NULL) + picoos_deallocate(mm, (void *) &pam->sSyllItems); + if (pam->sSyllItemOffs != NULL) + picoos_deallocate(mm, (void *) &pam->sSyllItemOffs); + +}/*pam_deallocate*/ + +/** + * initialization of a pam PU + * @param this : handle to a PU struct + * @return PICO_OK : init OK + * @return PICO_ERR_OTHER : error on getting pkbs addresses + * @callgraph + * @callergraph + */ +static pico_status_t pam_initialize(register picodata_ProcessingUnit this) +{ + pico_status_t nI, nJ; + pam_subobj_t *pam; + + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + pam->inBufSize = PICOPAM_IN_BUFF_SIZE; + pam->outBufSize = PICOPAM_OUT_PAM_SIZE; + pam->inReadPos = 0; + pam->inWritePos = 0; + pam->outReadPos = 0; + pam->outWritePos = 0; + pam->needMoreInput = 0; + pam->procState = 0; + + /*----------------------------------------------------------------- + * MANAGE INTERNAL INITIALIZATION + ------------------------------------------------------------------*/ + /*init the syllable structure*/ + for (nI = 0; nI < PICOPAM_MAX_SYLL_PER_SENT; nI++) + for (nJ = 0; nJ < PICOPAM_VECT_SIZE; nJ++) + pam->sSyllFeats[nI].phoneV[nJ] = 0; + + for (nI = 0; nI < PICOPAM_MAX_PH_PER_SENT; nI++) + pam->sPhIds[nI] = 0; + + for (nI = 0; nI < PICOPAM_VECT_SIZE; nI++) + pam->sPhFeats[nI] = 0; + + for (nI = 0; nI < PICOPAM_MAX_ITEM_SIZE_PER_SENT; nI++) + pam->sSyllItems[nI] = 0; + + for (nI = 0; nI < PICOPAM_MAX_ITEM_PER_SENT; nI++) + pam->sSyllItemOffs[nI] = 0; + + /*Other variables*/ + pam_reset_processors(this); + pam->nLastAttachedItemId = pam->nCurrAttachedItem = 0; + pam->nAttachedItemsSize = 0; + + /*pitch and duration modifiers*/ + pam->pMod = 1.0f; + pam->dMod = 1.0f; + pam->dRest = 0.0f; + + + /* constant tables */ + { + picoos_uint8 i, j; + picoos_uint16 tmp_weights[PICOPAM_PWIDX_SIZE][PICOPAM_MAX_STATES_PER_PHONE] = { + {10, 10, 10, 10, 1 }, /*SBEG*/ + { 1, 4, 8, 4, 1 }, /*PHR1*/ + { 1, 4, 8, 4, 1 }, /*PHR2*/ + { 1, 10, 10, 10, 10 },/*SEND*/ + { 1, 1, 1, 1, 1 } /*DEFAULT*/ + }; + for (i = 0; i < PICOPAM_PWIDX_SIZE; i++) { + for (j = 0; j < PICOPAM_PWIDX_SIZE; j++) { + pam->sil_weights[j][j] = tmp_weights[i][j]; + } + } + } +/*----------------------------------------------------------------- + * MANAGE LINGWARE INITIALIZATION IF NEEDED + ------------------------------------------------------------------*/ + /* kb dtdur */ + pam->dtdur = picokdt_getDtPAM(this->voice->kbArray[PICOKNOW_KBID_DT_DUR]); + if (pam->dtdur == NULL) { + picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING, NULL, + NULL); + return PICO_ERR_OTHER; + }PICODBG_DEBUG(("got dtdur")); + + /* kb dtlfz* */ + pam->dtlfz[0] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_LFZ1]); + pam->dtlfz[1] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_LFZ2]); + pam->dtlfz[2] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_LFZ3]); + pam->dtlfz[3] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_LFZ4]); + pam->dtlfz[4] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_LFZ5]); + for (nI = 0; nI < PICOPAM_DT_NRLFZ; nI++) { + if (pam->dtlfz[nI] == NULL) { + picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING, + NULL, NULL); + return PICO_ERR_OTHER; + }PICODBG_DEBUG(("got dtlfz%d", nI+1)); + } + + /* kb dtmgc* */ + pam->dtmgc[0] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_MGC1]); + pam->dtmgc[1] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_MGC2]); + pam->dtmgc[2] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_MGC3]); + pam->dtmgc[3] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_MGC4]); + pam->dtmgc[4] = picokdt_getDtPAM( + this->voice->kbArray[PICOKNOW_KBID_DT_MGC5]); + for (nI = 0; nI < PICOPAM_DT_NRMGC; nI++) { + if (pam->dtmgc[nI] == NULL) { + picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING, + NULL, NULL); + return PICO_ERR_OTHER; + }PICODBG_DEBUG(("got dtmgc%d", nI+1)); + } + + /* kb pdfdur* */ + pam->pdfdur = picokpdf_getPdfDUR( + this->voice->kbArray[PICOKNOW_KBID_PDF_DUR]); + if (pam->pdfdur == NULL) { + picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING, NULL, + NULL); + return PICO_ERR_OTHER; + }PICODBG_DEBUG(("got pdfdur")); + + /* kb pdflfz* */ + pam->pdflfz = picokpdf_getPdfMUL( + this->voice->kbArray[PICOKNOW_KBID_PDF_LFZ]); + if (pam->pdflfz == NULL) { + picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING, NULL, + NULL); + return PICO_ERR_OTHER; + }PICODBG_DEBUG(("got pdflfz")); + + /* kb tabphones */ + pam->tabphones = picoktab_getPhones( + this->voice->kbArray[PICOKNOW_KBID_TAB_PHONES]); + if (pam->tabphones == NULL) { + picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING, NULL, + NULL); + return PICO_ERR_OTHER; + }PICODBG_DEBUG(("got tabphones")); + + return PICO_OK; +}/*pam_initialize*/ + +/** + * termination of a pam PU + * @param this : handle to a pam PU struct + * @return PICO_OK + * @callgraph + * @callergraph + */ +static pico_status_t pam_terminate(register picodata_ProcessingUnit this) +{ + + pam_subobj_t *pam; + + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + + return PICO_OK; +}/*pam_terminate*/ + +/** + * deallocaton of a pam PU + * @param this : handle to a pam PU struct + * @param mm : engine memory manager + * @return PICO_OK + * @callgraph + * @callergraph + */ +static pico_status_t pam_subobj_deallocate(register picodata_ProcessingUnit this, + picoos_MemoryManager mm) +{ + + pam_subobj_t* pam; + + if (NULL != this) { + pam = (pam_subobj_t *) this->subObj; + mm = mm; /* avoid warning "var not used in this function"*/ + /*----------------------------------------------------------------- + * Memory de-allocations + * ------------------------------------------------------------------*/ + if (pam->sSyllFeats != NULL) { + picoos_deallocate(this->common->mm, (void *) &pam->sSyllFeats); + } + if (pam->sPhIds != NULL) { + picoos_deallocate(this->common->mm, (void *) &pam->sPhIds); + } + if (pam->sPhFeats != NULL) { + picoos_deallocate(this->common->mm, (void *) &pam->sPhFeats); + } + if (pam->sSyllItems != NULL) { + picoos_deallocate(this->common->mm, (void *) &pam->sSyllItems); + } + if (pam->sSyllItemOffs != NULL) { + picoos_deallocate(this->common->mm, (void *) &pam->sSyllItemOffs); + } + picoos_deallocate(this->common->mm, (void *) &this->subObj); + } + + return PICO_OK; +}/*pam_subobj_deallocate*/ + +/** + * creates a new pam processing unit + * @param mm : engine memory manager + * @param common : engine common object pointer + * @param cbIn : pointer to input buffer + * @param cbOut : pointer to output buffer + * @param voice : pointer to voice structure + * @return this : pam PU handle if success + * @return NULL : if error + * @callgraph + * @callergraph + */ +picodata_ProcessingUnit picopam_newPamUnit(picoos_MemoryManager mm, + picoos_Common common, picodata_CharBuffer cbIn, + picodata_CharBuffer cbOut, picorsrc_Voice voice) +{ + + register pam_subobj_t * pam; + + picodata_ProcessingUnit this = picodata_newProcessingUnit(mm, common, cbIn, + cbOut, voice); + if (this == NULL) { + return NULL; + } + this->initialize = pam_initialize; + + PICODBG_DEBUG(("picotok_newPamUnit -- set this->step to pam_step")); + + this->step = pam_step; + this->terminate = pam_terminate; + this->subDeallocate = pam_subobj_deallocate; + this->subObj = picoos_allocate(mm, sizeof(pam_subobj_t)); + if (this->subObj == NULL) { + PICODBG_ERROR(("Error in Pam Object allocation")); + picoos_deallocate(mm, (void*) &this); + return NULL; + }; + + /*----------------------------------------------------------------- + * Allocate internal memory for PAM (only at PU creation time) + * ------------------------------------------------------------------*/ + pam = (pam_subobj_t *) this->subObj; + if (PICO_OK != pam_allocate(mm, pam)) { + PICODBG_ERROR(("Error in Pam buffers Allocation")); + picoos_deallocate(mm, (void *) &this->subObj); + picoos_deallocate(mm, (void *) &this); + return NULL; + } + + /*----------------------------------------------------------------- + * Initialize memory for PAM (this may be re-used elsewhere, e.g.Reset) + * ------------------------------------------------------------------*/ + if (PICO_OK != pam_initialize(this)) { + PICODBG_ERROR(("problem initializing the pam sub-object")); + } + return this; +}/*picopam_newPamUnit*/ + +/*------------------------------------------------------------------------------- + PROCESSING AND INTERNAL FUNCTIONS + --------------------------------------------------------------------------------*/ + +/** + * initializes default duration limits for boundary items + * @param uBoundType : type of input boundary type + * @param *uMinDur, *uMaxDur : addresses of values to initialize + * @return void + * @remarks so far initializes to 0 both values; this will leave the values given by tree prediction + * @callgraph + * @callergraph + */ +static void get_default_boundary_limit(picoos_uint8 uBoundType, + picoos_uint16 *uMinDur, picoos_uint16 *uMaxDur) +{ + switch (uBoundType) { + case PICODATA_ITEMINFO1_BOUND_SBEG: + *uMinDur = 0; + *uMaxDur = 20; + break; + case PICODATA_ITEMINFO1_BOUND_SEND: + *uMinDur = 550; + *uMaxDur = 650; + break; + case PICODATA_ITEMINFO1_BOUND_TERM: + *uMinDur = 0; + *uMaxDur = 0; + break; + case PICODATA_ITEMINFO1_BOUND_PHR0: + *uMinDur = 0; + *uMaxDur = 0; + break; + case PICODATA_ITEMINFO1_BOUND_PHR1: + *uMinDur = 275; + *uMaxDur = 325; + break; + case PICODATA_ITEMINFO1_BOUND_PHR2: + *uMinDur = 4; + *uMaxDur = 60; + break; + case PICODATA_ITEMINFO1_BOUND_PHR3: + *uMinDur = 0; + *uMaxDur = 0; + break; + default: + break; + } + +}/*get_default_boundary_limit*/ + +/** + * checks if "neededSize" is available on "nCurrPhoneme" + * @param pam : pam subobj + * @param neededSize : the requested size + * @return PICO_OK : size is available + * @return !=PICO_OK : size not available + * @callgraph + * @callergraph + */ +static pico_status_t check_phones_size(pam_subobj_t *pam, + picoos_int16 neededSize) +{ + if ((pam->nCurrPhoneme + neededSize) > PICOPAM_MAX_PH_PER_SENT - 1) { + return PICO_ERR_OTHER; + } + return PICO_OK; +}/*check_phones_size*/ + +/** + * checks if neededSize is available on "nCurrSyllable" + * @param pam : pam subobj + * @param neededSize : the requested size + * @return PICO_OK : size is available + * @return !=PICO_OK : size not available + * @callgraph + * @callergraph + */ +static pico_status_t check_syllables_size(pam_subobj_t *pam, + picoos_int16 neededSize) +{ + if ((pam->nCurrSyllable + neededSize) > PICOPAM_MAX_SYLL_PER_SENT - 1) { + return PICO_ERR_OTHER; + } + return PICO_OK; +}/*check_syllables_size*/ + +/** + * verifies that local storage has enough space to receive 1 item + * @param this : pointer to current PU struct + * @param item : pointer to current item head + * @return TRUE : resource limits would be reached during processing of input item + * @return FALSE : item could be processed normally + * @remarks item pointed to by *item should be already valid + * @callgraph + * @callergraph + */ +static pico_status_t pamCheckResourceLimits( + register picodata_ProcessingUnit this, const picoos_uint8 *item) +{ + register pam_subobj_t * pam; + picodata_itemhead_t head; + pico_status_t sResult; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pam = (pam_subobj_t *) this->subObj; + sResult = TRUE; /*default : resource limits reached*/ + head.type = item[0]; + head.info1 = item[1]; + head.info2 = item[2]; + head.len = item[3]; + + switch (head.type) { + /*commands that generate syllables/phonemes*/ + case PICODATA_ITEM_SYLLPHON: + if (pam->nCurrSyllable >= PICOPAM_MAX_SYLL_PER_SENT - 2) { + return sResult; /*no room for more syllables*/ + } + if ((pam->nCurrPhoneme + head.len) >= PICOPAM_MAX_PH_PER_SENT - 2) { + return sResult; /*no room for more phoneme*/ + } + break; + case PICODATA_ITEM_BOUND: + if ((head.info1 == PICODATA_ITEMINFO1_BOUND_SBEG) || (head.info1 + == PICODATA_ITEMINFO1_BOUND_SEND) || (head.info1 + == PICODATA_ITEMINFO1_BOUND_TERM) || (head.info1 + == PICODATA_ITEMINFO1_BOUND_PHR1) +#ifdef PAM_PHR2_WITH_PR1 + || (head.info1 == PICODATA_ITEMINFO1_BOUND_PHR2) +#endif + ) { + + if (pam->nCurrSyllable >= PICOPAM_MAX_SYLL_PER_SENT - 2) { + return sResult; /*no room for more syllables*/ + } + if ((pam->nCurrPhoneme + 1) >= PICOPAM_MAX_PH_PER_SENT - 2) { + return sResult; /*no room for more phoneme*/ + } + } + break; + + default: + /*all other commands has to be queued*/ + if ((pam->nAttachedItemsSize + head.len) + >= PICOPAM_MAX_ITEM_SIZE_PER_SENT - 1) { + return sResult; /*no room for more items*/ + } + break; + } + return FALSE; /*no resource limits apply to current item*/ +} /*pamCheckResourceLimits*/ + +/** + * selects items to be sent to next PU immedately + * @param this : pointer to current PU struct + * @param item : pointer to current item head + * @return TRUE : item should be passed on next PU NOW + * @return FALSE : item should not be passed on next PU now but should be processed + * @remarks item pointed to by *item should be already valid + * @callgraph + * @callergraph + */ +static pico_status_t pam_check_immediate(register picodata_ProcessingUnit this, + const picoos_uint8 *item) +{ + register pam_subobj_t * pam; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pam = (pam_subobj_t *) this->subObj; + + if (pam->nCurrSyllable <= -1) { + if (item[0] == PICODATA_ITEM_SYLLPHON) + return FALSE; + if ((item[0] == PICODATA_ITEM_BOUND) && (item[1] + == PICODATA_ITEMINFO1_BOUND_SBEG)) + return FALSE; + if (is_pam_command((picoos_uint8 *) item) == TRUE) + return FALSE; + return TRUE; /*no need to process data : send it*/ + } + return FALSE; /*syllable struct not void : do standard processing*/ + +} /*pam_check_immediate*/ + +/** + * checks if the input item has to be queued in local storage for later resynch + * @param this : pointer to current PU struct + * @param item : pointer to current item head + * @return TRUE : item should be queued + * @return FALSE : item should not be queued + * @remarks item pointed to by *item should be already valid + * @callgraph + * @callergraph + */ +static pico_status_t pam_hastobe_queued(register picodata_ProcessingUnit this, + const picoos_uint8 *item) +{ + register pam_subobj_t * pam; + picodata_itemhead_t head; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pam = (pam_subobj_t *) this->subObj; + head.type = item[0]; + head.info1 = item[1]; + + switch (head.type) { + /*commands that generate syllables/phonemes*/ + case PICODATA_ITEM_SYLLPHON: + return FALSE; /*no queue needed*/ + break; + case PICODATA_ITEM_BOUND: + if ((head.info1 == PICODATA_ITEMINFO1_BOUND_PHR3) +#ifdef PAM_PHR2_WITH_PR3 + ||(head.info1==PICODATA_ITEMINFO1_BOUND_PHR2) +#endif + || (head.info1 == PICODATA_ITEMINFO1_BOUND_PHR0)) { + return FALSE; /*no queue needed*/ + } + break; + + default: + /*all other items has to be queued*/ + break; + } + return TRUE; /*item has to be queued*/ +} /*pam_hastobe_queued*/ + +/** + * queue item in local storage for later resynch + * @param this : pointer to current PU struct + * @param item : pointer to current item head + * @return TRUE : item queued + * @return FALSE : item not queued because of errors + * @remarks item pointed to by *item should be already valid + * @callgraph + * @callergraph + */ +static pico_status_t pam_queue(register picodata_ProcessingUnit this, + const picoos_uint8 *item) +{ + register pam_subobj_t * pam; + picodata_itemhead_t head; + picoos_uint8 nI; + pico_status_t sResult; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pam = (pam_subobj_t *) this->subObj; + sResult = TRUE; /*default : item queued*/ + head.type = item[0]; + head.info1 = item[1]; + head.info2 = item[2]; + head.len = item[3]; + + /*test condition on enough room to store current item in the "sSyllItems" area*/ + if ((pam->nAttachedItemsSize + head.len + sizeof(picodata_itemhead_t)) + >= PICOPAM_MAX_ITEM_SIZE_PER_SENT - 1) { + return FALSE; /*resource limit reached*/ + } + /*store current offset*/ + pam->sSyllItemOffs[pam->nLastAttachedItemId] = pam->nAttachedItemsSize; + /*store the item to the "sSyllItems" area*/ + for (nI = 0; nI < (head.len + sizeof(picodata_itemhead_t)); nI++) { + pam->sSyllItems[pam->nAttachedItemsSize + nI] = item[nI]; + } + /*increment the attached items area*/ + pam->nAttachedItemsSize += nI; + + /*increment id*/ + pam->nLastAttachedItemId++; + /*set start(if not initialized) and end ids of queued items in sSyllFeats*/ + if (pam->nCurrSyllable > -1) { + /*normal case : the item is attached to current syllable*/ + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[ITM] == 0) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[ITM] + = pam->nLastAttachedItemId; + } + pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm] + = pam->nLastAttachedItemId; + } else { + /*special case : an item is requested to be queued even if no + syllables has been assigned to the sentence structure : + -->> use syll 0*/ + if (pam->sSyllFeats[0].phoneV[ITM] == 0) { + pam->sSyllFeats[0].phoneV[ITM] = pam->nLastAttachedItemId; + } + pam->sSyllFeats[0].phoneV[itm] = pam->nLastAttachedItemId; + } + return TRUE; /*item queued successfully*/ +} /*pam_queue*/ + +/** + * selects items to be dealth with by the PU processing + * @param item : pointer to current item head + * @return TRUE : item should be processed + * @return FALSE : item should not be processed (maybe it ontains commands or items for other PUs) + * @remarks item pointed to by *item should be already valid + * @callgraph + * @callergraph + */ +static pico_status_t pam_deal_with(const picoos_uint8 *item) +{ + picodata_itemhead_t head; + pico_status_t sResult; + sResult = FALSE; + head.type = item[0]; + head.info1 = item[1]; + head.info2 = item[2]; + head.len = item[3]; + switch (head.type) { + case PICODATA_ITEM_SYLLPHON: + case PICODATA_ITEM_BOUND: + sResult = TRUE; + break; + default: + break; + } + return sResult; +} /*pam_deal_with*/ + +/** + * returns true if more items has to be produced for current syllable + * @param this : Pam object pointer + * @return TRUE : item is to be produced + * @return FALSE : item is not to be produced + * @remarks item pointed to by *item should be already valid + * @callgraph + * @callergraph + */ +static picoos_uint8 pamHasToProcess(register picodata_ProcessingUnit this) +{ + register pam_subobj_t * pam; + picoos_uint8 nCond1, nCond2, nCond3; + + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pam = (pam_subobj_t *) this->subObj; + /*conditions originating a "NOT to be processed" result */ + nCond1 = pam->nCurrSyllable <= -1; + nCond2 = pam->nCurrSyllable >= pam->nTotalSyllables; + nCond3 = pam->nSyllPhoneme + >= pam->sSyllFeats[pam->nCurrSyllable].phoneV[B3]; + + if ((nCond1) || (nCond2) || (nCond3)) + return FALSE; + + return TRUE; +} /*pamHasToProcess*/ + +/** + * modifies the process flags in order to point to next valid syllable phone or item to be produced + * @param this : Pam object pointer + * @return TRUE : item has to be produced + * @return FALSE : item has not to be produced + * @callgraph + * @callergraph + */ +static pico_status_t pamUpdateProcess(register picodata_ProcessingUnit this) +{ + register pam_subobj_t * pam; + + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pam = (pam_subobj_t *) this->subObj; + + if (pam->nCurrSyllable == -1) { + /*this to be able to manage sudden PU cleanup after FLUSH CMD*/ + return PICO_OK; + } + /*check number of phonemes for current syllable*/ + if (pam->nSyllPhoneme < pam->sSyllFeats[pam->nCurrSyllable].phoneV[B3] - 1) { + pam->nSyllPhoneme++; + return PICO_OK; + } + if (pam->nSyllPhoneme == pam->sSyllFeats[pam->nCurrSyllable].phoneV[B3] - 1) { + /*this helps in identifyng the end of syllable condition in PamHasToProcess*/ + pam->nSyllPhoneme++; + } + /*previous syllable phonemes are complete: test if any items are tied to this syllable*/ + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[ITM] > 0) { + /*there are items tied to this syllable*/ + if (pam->nCurrAttachedItem == 0) { + /*if it is the first item to be regenerated initialize it*/ + pam->nCurrAttachedItem + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[ITM]; + return PICO_OK; + } else { + /*not the first item : check if more*/ + if (pam->nCurrAttachedItem + < pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm]) { + /*more tied items to be regenerated*/ + pam->nCurrAttachedItem++; + return PICO_OK; + } + } + } + /*previous syllable phonemes and items are complete: switch to next syllable*/ + if (pam->nCurrSyllable < pam->nTotalSyllables - 1) { + pam->nCurrSyllable++; + pam->nSyllPhoneme = 0; + pam->nCurrAttachedItem = 0; + return PICO_OK; + } + /*no more phonemes or items to be produced*/ + pam->nCurrSyllable++; + pam->nSyllPhoneme = 0; + return PICO_ERR_OTHER; + +} /*pamUpdateProcess*/ + +/** + * returns true if more items has to be popped for current syllable + * @param this : Pam object pointer + * @return TRUE : item has to be popped + * @return FALSE : item has not to be popped + * @callgraph + * @callergraph + */ +static picoos_uint8 pamHasToPop(register picodata_ProcessingUnit this) +{ + register pam_subobj_t * pam; + + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pam = (pam_subobj_t *) this->subObj; + + /*Preliminary condition : at least 1 syllable*/ + if (pam->nCurrSyllable <= -1) + return FALSE; + + /*Preliminary condition : not maximum number of syllables*/ + if (pam->nCurrSyllable >= pam->nTotalSyllables) + return FALSE; + + /*Preliminary condition : start and end offset in current item > 0 */ + if ((pam->sSyllFeats[pam->nCurrSyllable].phoneV[ITM] <= 0) + || (pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm] <= 0)) + return FALSE; + + /*Final condition : current popped item less or eq to maximum*/ + if (pam->nCurrAttachedItem + > pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm]) + return FALSE; + + return TRUE; +} /*pamHasToPop*/ + +/** + * returns the address of an item to be popped from the current syllable queue + * @param this : Pam object pointer + * @return pop_address : item address + * @return NULL : item not poppable + * @callgraph + * @callergraph + */ +static picoos_uint8 *pamPopItem(register picodata_ProcessingUnit this) +{ + register pam_subobj_t * pam; + picoos_uint8 nItem; + if (NULL == this || NULL == this->subObj) { + return NULL; + } + pam = (pam_subobj_t *) this->subObj; + + /*Preliminary condition : at least 1 syllable*/ + if (pam->nCurrSyllable <= -1) + return NULL; + + /*Preliminary condition : not maximum number of syllables*/ + if (pam->nCurrSyllable >= pam->nTotalSyllables) + return NULL; + + /*Preliminary condition : start and end offset in current item > 0 */ + if ((pam->sSyllFeats[pam->nCurrSyllable].phoneV[ITM] <= 0) + || (pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm] <= 0)) + return NULL; + + /*Final condition : current popped item less than maximum*/ + if (pam->nCurrAttachedItem + > pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm]) + return NULL; + + nItem = pam->nCurrAttachedItem; + /*please note : nItem-1 should match with actions performed in function "pam_queue(..)" */ + return &(pam->sSyllItems[pam->sSyllItemOffs[nItem - 1]]); + +} /*pamPopItem*/ + +/** + * returns the address of an item popped from the syllable 0 queue + * @param this : Pam object pointer + * @return pop_address : item address + * @return NULL : item not poppable + * @remarks the item is popped only if it has been inserted in the queue before the first + * @remarks item assigned to the syllable 0 i.e. + * @remarks AttachedItem<=pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm]-1 + * @callgraph + * @callergraph + */ +static picoos_uint8 *pamPopAttachedSy0(register picodata_ProcessingUnit this) +{ + register pam_subobj_t * pam; + picoos_uint8 nItem; + if (NULL == this || NULL == this->subObj) { + return NULL; + } + pam = (pam_subobj_t *) this->subObj; + + /*should be syllable 0*/ + if (pam->nCurrSyllable != 0) + return NULL; + + /*start and end offset in current item > 0 */ + if ((pam->sSyllFeats[pam->nCurrSyllable].phoneV[ITM] <= 0) + || (pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm] <= 0)) + return NULL; + + /*if current popped item is > 0 test end condition*/ + if (pam->nCurrAttachedItem > 0) { + /*Other condition : current popped item less than maximum*/ + if (pam->nCurrAttachedItem + > pam->sSyllFeats[pam->nCurrSyllable].phoneV[itm] - 1) + return NULL; + } + nItem = pam->nCurrAttachedItem; + return &(pam->sSyllItems[pam->sSyllItemOffs[nItem]]); + +} /*pamPopAttachedSy0*/ + +/** + * pdf access for duration + * @param this : Pam object pointer + * @param durIndex : index of duration in the pdf + * @param phonDur : pointer to base of array where to store the duration values + * @param numFramesState : pointer to base of array where to store the number of frames per state + * @return PICO_OK : pdf retrieved + * @return PICO_ERR_OTHER : pdf not retrieved + * @remarks Modifies phonDur (the requested duration value) + * @remarks Modifies numFramesState (the requested number of frames per state (vector)) + * @callgraph + * @callergraph + */ +static pico_status_t pam_get_duration(register picodata_ProcessingUnit this, + picoos_uint16 durIndex, picoos_uint16 *phonDur, + picoos_uint8 *numFramesState) +{ + pam_subobj_t *pam; + picokpdf_PdfDUR pdf; + picoos_uint8 *durItem; + picoos_uint16 nFrameSize, nI; + picoos_single fValue; + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pdf = pam->pdfdur; + /*make the index 0 based*/ + if (durIndex > 0) + durIndex--; + + /* check */ + if (durIndex > pdf->numframes - 1) { + PICODBG_ERROR(("PAM durPdf access error, index overflow -> index: %d , numframes: %d", durIndex, pdf->numframes)); + return PICO_ERR_OTHER; + } + /* base pointer */ + durItem = &(pdf->content[durIndex * pdf->vecsize]); + if (durItem == NULL) { + PICODBG_ERROR(("PAM durPdf access error , frame pointer = NULL")); + return PICO_ERR_OTHER; + } + nFrameSize = pdf->sampperframe / 16; + *phonDur = ((pdf->phonquant[((*durItem) & 0xF0) >> 4]) * nFrameSize); + numFramesState[0] = pdf->statequant[((*durItem) & 0x0F)]; + durItem++; + numFramesState[1] = pdf->statequant[((*durItem) & 0xF0) >> 4]; + numFramesState[2] = pdf->statequant[((*durItem) & 0x0F)]; + durItem++; + numFramesState[3] = pdf->statequant[((*durItem) & 0xF0) >> 4]; + numFramesState[4] = pdf->statequant[((*durItem) & 0x0F)]; + + /*modification of the duration information based on the duration modifier*/ + *phonDur = (picoos_uint16) (((picoos_single) * phonDur) * pam->dMod); + for (nI = 0; nI < 5; nI++) { + fValue = pam->dRest + (picoos_single) numFramesState[nI] * pam->dMod; + numFramesState[nI] = (picoos_uint8) (fValue); + pam->dRest = fValue - (picoos_single) numFramesState[nI]; + } + return PICO_OK; +}/*pam_get_duration*/ + +/** + * pdf access for pitch + * @param this : Pam object pointer + * @param lf0Index : pointer to variable to receive index of pitch in the pdf + * @param nI : number of the phone's state + * @param phonF0 : pointer to variable to receive the pitch value + * @return PICO_OK : pdf retrieved + * @return PICO_ERR_OTHER : pdf not retrieved + * @remarks Modifies phonDur (the requested duration value) + * @remarks Modifies phonF0 (the requested pitch value (scalar)) + * @callgraph + * @callergraph + */ +static pico_status_t pam_get_f0(register picodata_ProcessingUnit this, + picoos_uint16 *lf0Index, picoos_uint8 nI, picoos_single *phonF0) +{ + pam_subobj_t *pam; + picoos_uint8 *lfItem, numstreams; + picoos_uint16 lf0IndexOffset, sTemp; + picoos_single lfum, lfivar, lfz; + + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + lf0IndexOffset = lf0Index[nI]; + + /*make the index 0 based*/ + if (lf0IndexOffset > 0) + lf0IndexOffset--; + + lf0IndexOffset += pam->pdflfz->stateoffset[nI]; + if (lf0IndexOffset > pam->pdflfz->numframes - 1) { + PICODBG_ERROR(("PAM flfzPdf access error, index overflow -> index: %d , numframes: %d", lf0Index, pam->pdflfz->numframes)); + return PICO_ERR_OTHER; + } + /* base pointer */ + lf0IndexOffset *= pam->pdflfz->vecsize; + + lfItem = &(pam->pdflfz->content[lf0IndexOffset]); + sTemp = (picoos_uint16) (((lfItem[1] << 8)) | lfItem[0]); + + lfum = (picoos_single) (sTemp << (pam->pdflfz->meanpowUm[0])); + numstreams = 3; + lfivar = (picoos_single) (((picoos_uint16) lfItem[numstreams * 2]) + << pam->pdflfz->ivarpow[0]); + lfz = (picoos_single) lfum / (picoos_single) lfivar; + lfz = (picoos_single) exp((double) lfz); + phonF0[nI] = (picoos_single) lfz; + + /*pitch modoification*/ + phonF0[nI] *= pam->pMod; + return PICO_OK; +}/*pam_get_f0*/ + +/** + * elementary rounding function + * @param fIn : (real) input value + * @return the rounded value + * @callgraph + * @callergraph + */ +static picoos_single f_round(picoos_single fIn) +{ + picoos_int32 iVal; + picoos_single fVal; + + iVal = (picoos_int32) fIn; + fVal = (picoos_single) iVal; + + if (fIn > (picoos_single) 0.0f) { + if ((fIn - fVal) < (picoos_single) 0.5f) + return fVal; + else + return fVal + (picoos_single) 1.0f; + } else { + if ((fVal - fIn) < (picoos_single) 0.5f) + return fVal; + else + return fVal - (picoos_single) 1.0f; + } +}/*f_round*/ + +/** + * updates the input vector for PAM + * @param this : Pam object pointer + * @return PICO_OK : update successful + * @return PICO_ERR_OTHER : errors on retrieving the PU pointer + * @remarks Modifies pam->sPhFeats[] + * @callgraph + * @callergraph + */ +static pico_status_t pam_update_vector(register picodata_ProcessingUnit this) +{ + pam_subobj_t *pam; + picoos_uint8 numstates, nI; + picoos_single fDur, f0avg, f0quant, minf0, maxf0, durquant1, durquant2, + mindur, maxdur1, maxdur2; + + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + /*default init*/ + pam->sPhFeats[DUR] = 0; + pam->sPhFeats[F0] = 0; + /* + Hard coded parameters for quantization + */ + numstates = PICOPAM_NRSTPF; + f0quant = 30.0f; + minf0 = 90.0f; + maxf0 = 360.0f; + + durquant1 = 20.0f; + durquant2 = 100.0f; + mindur = 40.0f; + maxdur1 = 160.0f; + maxdur2 = 600.0f; + f0avg = 0.0f; + for (nI = 0; nI < numstates; nI++) + f0avg += pam->phonF0[nI]; + f0avg /= (picoos_single) numstates; + + f0avg = f_round(f0avg / f0quant) * f0quant; + if (f0avg < minf0) + f0avg = minf0; + if (f0avg > maxf0) + f0avg = maxf0; + + /*make initial silence of sentence shorter (see also pam_put_item)*/ + if ((pam->nCurrSyllable == 0) && (pam->nSyllPhoneme == 0)) { + pam->phonDur = 2 * 4; + } + + fDur = (picoos_single) pam->phonDur; + fDur = f_round(fDur / durquant1) * durquant1; + if (fDur < mindur) + fDur = mindur; + if (fDur > maxdur1) { + fDur = f_round(fDur / durquant2) * durquant2; + if (fDur > maxdur2) + fDur = maxdur2; + } + pam->sPhFeats[DUR] = (picoos_uint8) (fDur / (picoos_single) 10.0f); + pam->sPhFeats[F0] = (picoos_uint8) (f0avg / (picoos_single) 10.0f); + + return PICO_OK; +}/*pam_update_vector*/ + +/** + * compress a single feature in the range 0..9 + * @param inVal : the value to be compressed + * @return compVal : the compressed value + * @callgraph + * @callergraph + */ +static picoos_uint8 pamCompressComponent(picoos_uint8 inVal) +{ + if (inVal <= 5) + return inVal; + if ((5 < inVal) && (inVal <= 10)) + return 6; + if ((10 < inVal) && (inVal <= 20)) + return 7; + if ((20 < inVal) && (inVal <= 30)) + return 8; + return 9; +}/*pamCompressComponent*/ + +/** + * prepares the input vector for tree feeding + * @param this : Pam object pointer + * @return PICO_OK : vector expanded + * @return PICO_ERR_OTHER : errors on expansion or retrieving the PU pointer + * @remarks Modifies pam->sPhFeats[] + * @callgraph + * @callergraph + */ +static pico_status_t pam_expand_vector(register picodata_ProcessingUnit this) +{ + pam_subobj_t *pam; + picoos_uint8 *inVect, *phonVect, *outVect, nI; + picoos_int16 nOffs, nOffs1, nLen; + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + inVect = &(pam->sSyllFeats[pam->nCurrSyllable].phoneV[0]); + phonVect = &(pam->sPhIds[0]); + outVect = &(pam->sPhFeats[0]); + /*just copy back*/ + for (nI = 0; nI < PICOPAM_INVEC_SIZE; nI++) + outVect[nI] = inVect[nI]; + /*now fill missing fields*/ + picoos_mem_copy((void*) &(inVect[FID]), &nOffs, sizeof(nOffs)); + /*offset to first phone of current syllable*/ + nOffs = nOffs + pam->nSyllPhoneme; /*offset to current phone of current syllable*/ + nLen = inVect[B3]; /*len of current syllable*/ + if (pam->nSyllPhoneme >= nLen) { + /*error on addressing current phone*/ + return PICO_ERR_OTHER; + } + /*previous of the previous phone*/ + nOffs1 = nOffs - 2; + if (nOffs1 >= 0) + outVect[P1] = phonVect[nOffs1]; + else + outVect[P1] = PICOPAM_PH_DONT_CARE_VAL; + /*previous phone*/ + nOffs1 = nOffs - 1; + if (nOffs1 >= 0) + outVect[P2] = phonVect[nOffs1]; + else + outVect[P2] = PICOPAM_PH_DONT_CARE_VAL; + /*^current phone*/ + outVect[P3] = phonVect[nOffs]; + + /*next phone*/ + nOffs1 = nOffs + 1; + if (nOffs1 < pam->nTotalPhonemes) + outVect[P4] = phonVect[nOffs1]; + else + outVect[P4] = PICOPAM_PH_DONT_CARE_VAL; + /*next of the next phone*/ + nOffs1 = nOffs + 2; + if (nOffs1 < pam->nTotalPhonemes) + outVect[P5] = phonVect[nOffs1]; + else + outVect[P5] = PICOPAM_PH_DONT_CARE_VAL; + /*pos of curr phone with respect to left syllable boundary*/ + outVect[P6] = pam->nSyllPhoneme + 1; + /*pos of curr phone with respect to right syllable boundary*/ + outVect[P7] = nLen - pam->nSyllPhoneme; + /*is current phone in consonant syllable boundary? (1:yes)*/ + if (pam->nSyllPhoneme < inVect[P8]) + outVect[P8] = 1; + else + outVect[P8] = 0; + return PICO_OK; +}/*pam_expand_vector*/ + +/** + * compresses the input vector for PAM + * @param this : Pam object pointer + * @return PICO_OK : compression successful + * @return PICO_ERR_OTHER : errors on retrieving the PU pointer + * @remarks Modifies pam->sPhFeats[] + * @callgraph + * @callergraph + */ +static pico_status_t pamCompressVector(register picodata_ProcessingUnit this) +{ + pam_subobj_t *pam; + picoos_uint8 *outVect, nI; + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + outVect = &(pam->sPhFeats[0]); + for (nI = 0; nI < PICOPAM_INVEC_SIZE; nI++) { + switch (nI) { + case P1: + case P2: + case P3: + case P4: + case P5: + case B1: + case B2: + case B16: + case E1: + case H5: + /*don't do any compression*/ + break; + default: + /*do compression*/ + if (outVect[nI] != PICOPAM_DONT_CARE_VALUE) + outVect[nI] = pamCompressComponent(outVect[nI]); + else + outVect[nI] = PICOPAM_DONT_CARE_VAL; + break; + } + } + return PICO_OK; +}/*pamCompressVector*/ + +/** + * reorganizes the input vector for PAM + * @param this : Pam object pointer + * @return PICO_OK : reorganization successful + * @return PICO_ERR_OTHER : errors on retrieving the PU pointer + * @remarks Modifies pam->sPhFeats[] + * @callgraph + * @callergraph + */ +static pico_status_t pamReorgVector(register picodata_ProcessingUnit this) +{ + pam_subobj_t *pam; + picoos_uint8 *outVect, inVect[60], nI; + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + outVect = &(pam->sPhFeats[0]); + for (nI = 0; nI < PICOPAM_INVEC_SIZE; nI++) inVect[nI] = outVect[nI]; + /*reorganize*/ + for (nI = T_B1; nI <= T_H5; nI++) { + switch (nI) { + case T_B1: + outVect[T_B1] = inVect[B1]; + break; + case T_B2: + outVect[T_B2] = inVect[B2]; + break; + case T_B3: + outVect[T_B3] = inVect[B3]; + break; + case T_B4: + outVect[T_B4] = inVect[B4]; + break; + case T_B5: + outVect[T_B5] = inVect[B5]; + break; + case T_B6: + outVect[T_B6] = inVect[B6]; + break; + case T_B7: + outVect[T_B7] = inVect[B7]; + break; + case T_B8: + outVect[T_B8] = inVect[B8]; + break; + case T_B9: + outVect[T_B9] = inVect[B9]; + break; + case T_B10: + outVect[T_B10] = inVect[B10]; + break; + case T_B11: + outVect[T_B11] = inVect[B11]; + break; + case T_B12: + outVect[T_B12] = inVect[B12]; + break; + case T_B13: + outVect[T_B13] = inVect[B13]; + break; + case T_B14: + outVect[T_B14] = inVect[B14]; + break; + case T_B15: + outVect[T_B15] = inVect[B15]; + break; + case T_B16: + outVect[T_B16] = inVect[B16]; + break; + case T_B17: + outVect[T_B17] = inVect[B17]; + break; + case T_B18: + outVect[T_B18] = inVect[B18]; + break; + case T_B19: + outVect[T_B19] = inVect[B19]; + break; + case T_B20: + outVect[T_B20] = inVect[B20]; + break; + case T_B21: + outVect[T_B21] = inVect[B21]; + break; + + case T_E1: + outVect[T_E1] = inVect[E1]; + break; + case T_E2: + outVect[T_E2] = inVect[E2]; + break; + case T_E3: + outVect[T_E3] = inVect[E3]; + break; + case T_E4: + outVect[T_E4] = inVect[E4]; + break; + case T_E5: + outVect[T_E5] = inVect[E5]; + break; + case T_E6: + outVect[T_E6] = inVect[E6]; + break; + case T_E7: + outVect[T_E7] = inVect[E7]; + break; + case T_E8: + outVect[T_E8] = inVect[E8]; + break; + case T_E9: + outVect[T_E9] = inVect[E9]; + break; + case T_E10: + outVect[T_E10] = inVect[E10]; + break; + case T_E11: + outVect[T_E11] = inVect[E11]; + break; + case T_E12: + outVect[T_E12] = inVect[E12]; + break; + case T_E13: + outVect[T_E13] = inVect[E13]; + break; + + case T_A3: + outVect[T_A3] = inVect[A3]; + break; + case T_C3: + outVect[T_C3] = inVect[C3]; + break; + case T_D2: + outVect[T_D2] = inVect[D2]; + break; + case T_F2: + outVect[T_F2] = inVect[F2]; + break; + + case T_G1: + outVect[T_G1] = inVect[G1]; + break; + case T_I1: + outVect[T_I1] = inVect[I1]; + break; + + case T_G2: + outVect[T_G2] = inVect[G2]; + break; + case T_I2: + outVect[T_I2] = inVect[I2]; + break; + + case T_H1: + outVect[T_H1] = inVect[H1]; + break; + case T_H2: + outVect[T_H2] = inVect[H2]; + break; + case T_H3: + outVect[T_H3] = inVect[H3]; + break; + case T_H4: + outVect[T_H4] = inVect[H4]; + break; + case T_H5: + outVect[T_H5] = inVect[H5]; + break; + } + } + return PICO_OK; +}/*pamReorgVector*/ + +/** + * puts a PAM item into PU output buffer + * @param this : Pam object pointer + * @param outBuff : output buffer base pointer + * @param outWritePos : offset in output buffer + * @param *bytesWr : actual bytes written + * @return PICO_OK : put successful + * @return PICO_ERR_OTHER : errors on retrieving the PU pointer + * @callgraph + * @callergraph + */ +static pico_status_t pam_put_item(register picodata_ProcessingUnit this, + picoos_uint8 *outBuff, picoos_uint16 outWritePos, picoos_uint8 *bytesWr) +{ + pam_subobj_t *pam; + picoos_uint8 *sDest, nI, nType, nIdx, fde; + picoos_uint32 pos, pos32; + picoos_int16 ft, dt; + picoos_uint16 uMinDur, uMaxDur; + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + sDest = &(outBuff[outWritePos]); + sDest[0] = PICODATA_ITEM_PHONE; /*Item type*/ + sDest[1] = pam->sPhFeats[P3]; /*phonetic id*/ + sDest[2] = PICOPAM_NRSTPF; /*number of states per phone*/ + sDest[3] = sizeof(picoos_uint16) * PICOPAM_NRSTPF * 3; /*size of the item*/ + pos = 4; + /*make initial silence of sentence shorter (see also UpdateVector)*/ + if ((pam->nCurrSyllable == 0) && (pam->nSyllPhoneme == 0)) { + for (nI = 0; nI < PICOPAM_NRSTPF - 1; nI++) + pam->numFramesState[nI] = 0; + pam->numFramesState[nI] = 2; + } else { + /*manage silence syllables with prescribed durations*/ + pos32 = Min; + picoos_read_mem_pi_uint16(pam->sSyllFeats[pam->nCurrSyllable].phoneV, + &pos32, &uMinDur); + pos32 = Max; + picoos_read_mem_pi_uint16(pam->sSyllFeats[pam->nCurrSyllable].phoneV, + &pos32, &uMaxDur); + + if (uMaxDur > 0) { + /* Select weights*/ + nType = pam->sSyllFeats[pam->nCurrSyllable].phoneV[bnd]; + switch (nType) { + case PICODATA_ITEMINFO1_BOUND_SBEG: + nIdx = PICOPAM_PWIDX_SBEG; + break; + case PICODATA_ITEMINFO1_BOUND_PHR1: + nIdx = PICOPAM_PWIDX_PHR1; + break; + case PICODATA_ITEMINFO1_BOUND_PHR2: + nIdx = PICOPAM_PWIDX_PHR2; + break; + case PICODATA_ITEMINFO1_BOUND_SEND: + case PICODATA_ITEMINFO1_BOUND_TERM: + nIdx = PICOPAM_PWIDX_SEND; + break; + default: + nIdx = PICOPAM_PWIDX_DEFA; + break; + } + fde = 2; + ft = 0; + dt = 0; + picodata_transformDurations( + fde, /* 2's exponent of frame duration in ms, e.g. 2 for 4ms, 3 for 8ms */ + PICOPAM_NRSTPF, /* number of states per phone */ + &(pam->numFramesState[0]), /* estimated durations */ + pam->sil_weights[nIdx], /* integer weights */ + uMinDur, /* minimum target duration in ms */ + uMaxDur, /* maximum target duration in ms */ + ft, /* factor to be multiplied to get the target */ + &dt /* in/out, rest in ms */ + ); + } + } + /*put data*/ + for (nI = 0; nI < PICOPAM_NRSTPF; nI++) { + picoos_write_mem_pi_uint16(sDest, &pos, + (picoos_uint16) pam->numFramesState[nI]); + picoos_write_mem_pi_uint16(sDest, &pos, + (picoos_uint16) pam->lf0Index[nI]); + picoos_write_mem_pi_uint16(sDest, &pos, + (picoos_uint16) pam->mgcIndex[nI]); + } + *bytesWr = sizeof(picodata_itemhead_t) + sizeof(picoos_uint16) + * PICOPAM_NRSTPF * 3; + return PICO_OK; +}/*pam_put_item*/ + +/** + * puts a non PAM (queued) item into PU output buffer + * @param qItem : pointer to item to put + * @param outBuff : output buffer base pointer + * @param outWritePos : offset in output buffer + * @param *bytesWr : actual bytes written + * @return PICO_OK : put successful + * @return PICO_ERR_OTHER : errors on retrieving the PU pointer + * @callgraph + * @callergraph + */ +static pico_status_t pam_put_qItem(picoos_uint8 *qItem, picoos_uint8 *outBuff, + picoos_uint16 outWritePos, picoos_uint8 *bytesWr) +{ + picoos_uint8 *sDest, nI; + sDest = &(outBuff[outWritePos]); + *bytesWr = sizeof(picodata_itemhead_t); + for (nI = 0; nI < (sizeof(picodata_itemhead_t) + qItem[3]); nI++) { + sDest[nI] = qItem[nI]; + } + *bytesWr = nI; + return PICO_OK; +}/*pam_put_qItem*/ + +/** + * tells if an item is a PAM command (except play) + * @param qItem : input item to test + * @return TRUE : qItem is a PAM command (except play) + * @return FALSE : qItem not a PAM command + * @callgraph + * @callergraph + */ +static pico_status_t is_pam_command(const picoos_uint8 * qItem) +{ + switch (qItem[0]) { + + case PICODATA_ITEM_CMD: + switch (qItem[1]) { + case PICODATA_ITEMINFO1_CMD_FLUSH: + /* flush is for all PU's and as such it is also for PAM*/ + case PICODATA_ITEMINFO1_CMD_PITCH: + case PICODATA_ITEMINFO1_CMD_SPEED: + return TRUE; + break; + default: + break; + } + } + return FALSE; +}/*is_pam_command*/ + +/** + * tells if an item is a PAM PLAY command + * @param qItem : input item to test + * @return TRUE : qItem is a PAM PLAY command + * @return FALSE : qItem not a PAM PLAY command + * @callgraph + * @callergraph + */ +static pico_status_t is_pam_play_command(picoos_uint8 *qItem) +{ + switch (qItem[0]) { + + case PICODATA_ITEM_CMD: + switch (qItem[1]) { + case PICODATA_ITEMINFO1_CMD_PLAY: + if (qItem[2] == PICODATA_ITEMINFO2_CMD_TO_PAM) + return TRUE; + break; + default: + break; + } + } + return FALSE; +}/*is_pam_play_command*/ + +/** + * command processor for PAM pu + * @param this : Pam item subobject + * @param qItem : input item pointer + * @return PICOPAM_FLUSH_RECEIVED : when a FLUSH is received + * @return PICOPAM_CONTINUE : normal command processing + * @return PICODATA_PU_ERROR : errors in accessing data + * @callgraph + * @callergraph + */ +static pico_status_t pamDoCommand(register picodata_ProcessingUnit this, + picoos_uint8 *qItem) +{ + pam_subobj_t *pam; + picoos_single fValue; + picoos_uint16 nValue; + picoos_uint32 nPos; + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + if (qItem[0] == PICODATA_ITEM_CMD) { + switch (qItem[1]) { + case PICODATA_ITEMINFO1_CMD_FLUSH: + /* flush is for all PU's and as such it is also for PAM : implement the flush!!*/ + pam_reset_processors(this); + pam->nLastAttachedItemId = pam->nCurrAttachedItem = 0; + pam->nAttachedItemsSize = 0; + return PICOPAM_FLUSH_RECEIVED; + break; + + case PICODATA_ITEMINFO1_CMD_PITCH: + case PICODATA_ITEMINFO1_CMD_SPEED: + nPos = 4; + picoos_read_mem_pi_uint16(qItem, &nPos, &nValue); + if (qItem[2] == 'a') { + /*absloute modifier*/ + fValue = (picoos_single) nValue / (picoos_single) 100.0f; + if (qItem[1] == PICODATA_ITEMINFO1_CMD_PITCH) + pam->pMod = fValue; + if (qItem[1] == PICODATA_ITEMINFO1_CMD_SPEED) + pam->dMod = (1.0f / fValue); + } + if (qItem[2] == 'r') { + /*relative modifier*/ + fValue = (picoos_single) nValue / (picoos_single) 1000.0f; + if (qItem[1] == PICODATA_ITEMINFO1_CMD_PITCH) + pam->pMod *= (1.0f / fValue); + if (qItem[1] == PICODATA_ITEMINFO1_CMD_SPEED) + pam->dMod *= (1.0f / fValue); + } + return PICOPAM_CONTINUE; + break; + + default: + break; + }/*end switch switch (qItem[1])*/ + }/*end if (qItem[0]==PICODATA_ITEM_CMD)*/ + return PICOPAM_CONTINUE; +}/*pamDoCommand*/ + +/** + * defines if an item has to be sent to following PUs + * @param qItem : input item pointer + * @return TRUE : item has to be transmitted to following PUs + * @return FALSE : item has to be consumed internallz on PAM + * @callgraph + * @callergraph + */ +static pico_status_t isItemToPut(picoos_uint8 *qItem) +{ + switch (qItem[0]) { + case PICODATA_ITEM_CMD: + /* is a command*/ + if (PICODATA_ITEMINFO1_CMD_SPEED == qItem[1]) { + /* SPEED consumed here*/ + return FALSE; + } + break; + case PICODATA_ITEM_BOUND: + switch (qItem[1]) { + case PICODATA_ITEMINFO1_BOUND_SBEG: + case PICODATA_ITEMINFO1_BOUND_PHR0: + case PICODATA_ITEMINFO1_BOUND_PHR1: + case PICODATA_ITEMINFO1_BOUND_PHR2: + case PICODATA_ITEMINFO1_BOUND_PHR3: + /*boudary items consumed here except SEND,TERM*/ + return FALSE; + break; + default: + break; + } + break; + default: + break; + } + /*all other items not explicitly mentioned here + are transmitted to next PUs*/ + return TRUE; +}/*isItemToPut*/ + +/** + * pushes a boundary TERM item into some buffer + * @param outBuff : output buffer base pointer + * @param outWritePos : offset in output buffer + * @param *bytesWr : actual bytes written + * @return PICO_OK + * @remarks used while forcing TERM input items in forward processing + * @callgraph + * @callergraph + */ +static pico_status_t pam_put_term(picoos_uint8 *outBuff, + picoos_uint16 outWritePos, picoos_uint8 *bytesWr) +{ + picoos_uint8 *sDest; + sDest = &(outBuff[outWritePos]); + sDest[0] = PICODATA_ITEM_BOUND; /*Item type*/ + sDest[1] = PICODATA_ITEMINFO1_BOUND_TERM; + sDest[2] = PICODATA_ITEMINFO2_BOUNDTYPE_T; + sDest[3] = 0; /*item size*/ + *bytesWr = 4; + return PICO_OK; +}/*pam_put_term*/ + +/** + * translates one full phone into a PHONE Item including DT Dur, F0 and CEP trees feature generation and traversal + * @param this : Pam item subobject pointer + * @return PICO_OK : processing successful + * @return PICODATA_PU_ERROR : error accessing PAM object + * @return !=PICO_OK : processing errors + * @callgraph + * @callergraph + */ +static pico_status_t pamPhoneProcess(register picodata_ProcessingUnit this) +{ + pam_subobj_t *pam; + pico_status_t sResult; + picokdt_classify_result_t dTreeResult; + picoos_uint8 nI, bWr; + + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + /*expands current phone in current syllable in the corresponding vector pam->sPhFeats[]*/ + sResult = pam_expand_vector(this); + sResult = pamCompressVector(this); + sResult = pamReorgVector(this); + + /*tree traversal for duration*/ + if (!pam_do_tree(this, pam->dtdur, &(pam->sPhFeats[0]), PICOPAM_INVEC_SIZE, + &dTreeResult)) { + PICODBG_WARN(("problem using pam tree dtdur, using fallback value")); + dTreeResult.class = 0; + } + pam->durIndex = dTreeResult.class; + sResult = pam_get_duration(this, pam->durIndex, &(pam->phonDur), + &(pam->numFramesState[0])); + + /*tree traversal for pitch*/ + for (nI = 0; nI < PICOPAM_MAX_STATES_PER_PHONE; nI++) { + if (!pam_do_tree(this, pam->dtlfz[nI], &(pam->sPhFeats[0]), + PICOPAM_INVEC_SIZE, &dTreeResult)) { + PICODBG_WARN(("problem using pam tree lf0Tree, using fallback value")); + dTreeResult.class = 0; + } + pam->lf0Index[nI] = dTreeResult.class; + } + + /*pdf access for pitch*/ + for (nI = 0; nI < PICOPAM_MAX_STATES_PER_PHONE; nI++) { + sResult = pam_get_f0(this, &(pam->lf0Index[0]), nI, &(pam->phonF0[0])); + } + + /*update vector with duration and pitch for cep tree traversal*/ + sResult = pam_update_vector(this); + /*cep tree traversal*/ + for (nI = 0; nI < PICOPAM_MAX_STATES_PER_PHONE; nI++) { + + if (!pam_do_tree(this, pam->dtmgc[nI], &(pam->sPhFeats[0]), + PICOPAM_INVEC_SIZE, &dTreeResult)) { + PICODBG_WARN(("problem using pam tree lf0Tree, using fallback value")); + dTreeResult.class = 0; + } + pam->mgcIndex[nI] = dTreeResult.class; + } + /*put item to output buffer*/ + sResult = pam_put_item(this, pam->outBuf, pam->outWritePos, &bWr); + if (sResult == PICO_OK) + pam->outWritePos += bWr; + else + return sResult; + return PICO_OK; +}/*pamPhoneProcess*/ + +/** + * manages first syllable attached items when seen before SBEG + * @param this : Pam item subobject pointer + * @return PICO_OK (0) : default return code --> means no more items to be processed before 1st syllable + * @return PICOPAM_GOTO_FEED : go to feed state after this + * @return PICOPAM_GOTO_SCHEDULE : flush received + * @return PICODATA_PU_ERROR : errors + * @callgraph + * @callergraph + */ +static pico_status_t pamDoPreSyll(register picodata_ProcessingUnit this) +{ + pam_subobj_t *pam; + pico_status_t sResult; + picoos_uint8 bWr, nRc; + picoos_uint8 *qItem; + nRc = PICOPAM_PRE_SYLL_ENDED; + pam = (pam_subobj_t *) this->subObj; + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + /*regenerate initial items before the phonemes*/ + if (((qItem = pamPopAttachedSy0(this)) != NULL) && !((qItem[0] + == PICODATA_ITEM_BOUND) && (qItem[1] + == PICODATA_ITEMINFO1_BOUND_SBEG))) { + if (isItemToPut(qItem)) { + pam_put_qItem(qItem, pam->outBuf, pam->outWritePos, &bWr);/*popped item has to be sent to next PU*/ + pam->outWritePos += bWr; + nRc = PICOPAM_GOTO_FEED; + } + + if (is_pam_command(qItem) == TRUE) { + nRc = pamDoCommand(this, qItem); /*popped item is a PAM command : do it NOW!!*/ + if ((nRc == PICOPAM_FLUSH_RECEIVED) || (nRc == PICODATA_PU_ERROR)) { + /*FLUSH command RECEIVED or errors: stop ALL PROCESSING*/ + return nRc; + } + } + pam->nCurrAttachedItem++; + if (nRc == 0) + return PICOPAM_CONTINUE; + else + return nRc; + } + /*SBEG item management*/ + if ((qItem != NULL) && (qItem[0] == PICODATA_ITEM_BOUND) && (qItem[1] + == PICODATA_ITEMINFO1_BOUND_SBEG)) { + sResult = pam_put_qItem(qItem, pam->outBuf, pam->outWritePos, &bWr); + pam->outWritePos += bWr; + pam->nCurrAttachedItem++; + nRc = PICOPAM_GOTO_FEED; + } + return nRc; +}/*pamDoPreSyll*/ + +/** + * performs a step of the pam processing + * @param this : Pam item subobject pointer + * @param mode : mode for the PU + * @param *numBytesOutput : pointer to output number fo bytes produced + * @return PICODATA_PU_IDLE : nothing to do + * @return PICODATA_PU_BUSY : still tasks undergoing + * @return PICODATA_PU_ERROR : errors on processing + * @callgraph + * @callergraph + */ +static picodata_step_result_t pam_step(register picodata_ProcessingUnit this, + picoos_int16 mode, picoos_uint16 * numBytesOutput) +{ + + register pam_subobj_t * pam; + + pico_status_t sResult; + picoos_uint16 blen, numinb, numoutb; + pico_status_t rv; + picoos_uint8 bWr; + picoos_uint8 bForcedItem[4]; + picoos_uint8 *qItem; + + numinb = 0; + numoutb = 0; + rv = PICO_OK; + + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pam = (pam_subobj_t *) this->subObj; + mode = mode; /* avoid warning "var not used in this function"*/ + /*Init number of output bytes*/ + *numBytesOutput = 0; + + while (1) { /* exit via return */ + + PICODBG_DEBUG(("pam_step -- doing state %i",pam->procState)); + + switch (pam->procState) { + + case PICOPAM_COLLECT: + /* *************** item collector ***********************************/ + /*collecting items from the PU input buffer*/ + sResult = picodata_cbGetItem(this->cbIn, + &(pam->inBuf[pam->inWritePos]), pam->inBufSize + - pam->inWritePos, &blen); + if (sResult != PICO_OK) { + if (sResult == PICO_EOF) { + /*no items available : remain in state 0 and return idle*/ + return PICODATA_PU_IDLE; + } else { + /*errors : remain in state 0 and return error*/ + PICODBG_DEBUG(("pam_step(PICOPAM_COLLECT) -- Errors on item buffer input, status: %d",sResult)); + return PICODATA_PU_ERROR; + } + } + + PICODBG_DEBUG(("pam_step -- got item, status: %d",sResult)); + sResult = picodata_is_valid_item( + &(pam->inBuf[pam->inWritePos]), blen); + if (sResult != TRUE) { + /*input item is not valid : consume the input item and stay in COLLECT*/ + pam->inWritePos += blen; + pam->inReadPos += blen; + if (pam->inReadPos >= pam->inWritePos) { + pam->inReadPos = 0; + pam->inWritePos = 0; + }PICODBG_DEBUG(("pam_step -- item is not valid, type: %d",pam->inBuf[pam->inWritePos])); + return PICODATA_PU_BUSY; + } + + /*update input write pointer + move to "schedule" state*/ + pam->inWritePos += blen; + pam->procState = PICOPAM_SCHEDULE; + return PICODATA_PU_BUSY; + + case PICOPAM_SCHEDULE: + /* check out if more items are available */ + if (pam->inReadPos >= pam->inWritePos) { + /*no more items : back to collect state*/ + pam->procState = PICOPAM_COLLECT; + return PICODATA_PU_BUSY; + } + /* we have one full valid item, with len>0 starting at + pam->inBuf[pam->inReadPos]; here we decide how to elaborate it */ + + /* PLAY management */ + if (is_pam_play_command(&(pam->inBuf[pam->inReadPos])) == TRUE) { + /*consume the input item : it has been managed*/ + pam->inReadPos += pam->inBuf[pam->inReadPos + 3] + + sizeof(picodata_itemhead_t); + if (pam->inReadPos >= pam->inWritePos) { + pam->inReadPos = 0; + pam->inWritePos = 0; + } + /*stay in schedule*/ + return PICODATA_PU_BUSY; + } + + if (pam_check_immediate(this, &(pam->inBuf[pam->inReadPos]))) { + /* item has to be sent to next PU NOW : switch to "immediate" state */ + pam->procState = PICOPAM_IMMEDIATE; + return PICODATA_PU_BUSY; + } + if (pamCheckResourceLimits(this, &(pam->inBuf[pam->inReadPos]))) { + /* item would not fit into local buffers -->> free some space -->> + switch to "force term" state */ + pam->procState = PICOPAM_FORWARD_FORCE_TERM; + return PICODATA_PU_BUSY; + } + + if (pam_deal_with(&(pam->inBuf[pam->inReadPos]))) { + /* item has to be managed by the "forward" state : switch to forward state*/ + pam->procState = PICOPAM_FORWARD; + return PICODATA_PU_BUSY; + } + + if (pam_hastobe_queued(this, &(pam->inBuf[pam->inReadPos]))) { + /* item is not for PAM so it has to be queued internally */ + pam_queue(this, &(pam->inBuf[pam->inReadPos])); + /*consume the input item : it has been queued*/ + pam->inReadPos += pam->inBuf[pam->inReadPos + 3] + + sizeof(picodata_itemhead_t); + if (pam->inReadPos >= pam->inWritePos) { + pam->inReadPos = 0; + pam->inWritePos = 0; + } + return PICODATA_PU_BUSY; + } + /*if we get here something wrong happened. Being the the item valid, + switch to "immediate" state -> send it to next PU -> */ + PICODBG_DEBUG(("pam_step (PICOPAM_SCHEDULE) -- unexpected item is sent to next PU !!")); + pam->procState = PICOPAM_IMMEDIATE; + return PICODATA_PU_BUSY; + break; /*PICOPAM_SCHEDULE*/ + + case PICOPAM_FORWARD: + /*we have one full valid item, with len>0 starting at pam->inBuf[pam->inReadPos]. + furthermore this item should be in the set {BOUND,SYLL}. + No other items should arrive here*/ + sResult = pam_adapter_forward_step(this, + &(pam->inBuf[pam->inReadPos])); + /*decide if this item has to be queued for later re-synchronization + normally this is only done for SEND/TERM items*/ + if (pam_hastobe_queued(this, &(pam->inBuf[pam->inReadPos]))) { + /*item has to be queued iternally in local storage*/ + pam_queue(this, &(pam->inBuf[pam->inReadPos])); + } + /*now assign next state according to Forward results*/ + switch (sResult) { + case PICOPAM_READY: + pam->needMoreInput = FALSE; + /*consume the input item : it has already been stored*/ + pam->inReadPos += pam->inBuf[pam->inReadPos + 3] + + sizeof(picodata_itemhead_t); + if (pam->inReadPos >= pam->inWritePos) { + pam->inReadPos = 0; + pam->inWritePos = 0; + } + /*activate backward processing*/ + sResult = pam_adapter_backward_step(this); + if (sResult == PICO_OK) { + pam->procState = PICOPAM_PROCESS; + return PICODATA_PU_BUSY; + } else { + PICODBG_DEBUG(("pam_step (PICOPAM_FORWARD) -- wrong return from BackwardStep: %d -- Buffered sentence will be discarded",sResult)); + pam_reset_processors(this); + pam->nLastAttachedItemId = pam->nCurrAttachedItem + = 0; + pam->nAttachedItemsSize = 0; + + pam->procState = PICOPAM_SCHEDULE; + return PICODATA_PU_BUSY; + } + break; + + case PICOPAM_MORE: + pam->needMoreInput = TRUE; + /*consume the input item : it has already been stored*/ + pam->inReadPos += pam->inBuf[pam->inReadPos + 3] + + sizeof(picodata_itemhead_t); + if (pam->inReadPos >= pam->inWritePos) { + /*input is finished and PAM need more data : + clenaup input buffer + switch state back to "schedule state" + */ + pam->inReadPos = 0; + pam->inWritePos = 0; + pam->procState = PICOPAM_SCHEDULE; + return PICODATA_PU_ATOMIC; + } else { + /*input is not finished and need more data : + remain in state "PICOPAM_FORWARD" */ + return PICODATA_PU_ATOMIC; + } + break; + + case PICOPAM_NA: + default: + /*this item has not been stored in internal buffers: + assign this item to the management of + "immediate" state*/ + pam->procState = PICOPAM_IMMEDIATE; + return PICODATA_PU_BUSY; + break; + } /*end switch sResult*/ + break; /*PICOPAM_FORWARD*/ + + case PICOPAM_FORWARD_FORCE_TERM: + /*we have one full valid item, with len>0 + starting at pam->inBuf[pam->inReadPos] but we decided + to force a TERM item before, without losing the item in + inBuf[inReadPos] : --> generate a TERM item and do the + forward processing */ + pam_put_term(bForcedItem, 0, &bWr); + sResult = pam_adapter_forward_step(this, &(bForcedItem[0])); + switch (sResult) { + case PICOPAM_READY: + pam_queue(this, &(bForcedItem[0])); + /*activate backward processing*/ + sResult = pam_adapter_backward_step(this); + if (sResult == PICO_OK) { + pam->procState = PICOPAM_PROCESS; + return PICODATA_PU_BUSY; + } else { + PICODBG_DEBUG(("pam_step (PICOPAM_FORWARD_FORCE_TERM) -- wrong return from BackwardStep: %d -- Buffered sentence will be discarded",sResult)); + pam_reset_processors(this); + pam->nLastAttachedItemId = pam->nCurrAttachedItem + = 0; + pam->nAttachedItemsSize = 0; + + pam->procState = PICOPAM_SCHEDULE; + return PICODATA_PU_BUSY; + } + break; + + default: + PICODBG_DEBUG(("pam_step (PICOPAM_FORWARD_FORCE_TERM) -- Forced a TERM but processing do not appear to end -- Buffered sentence will be discarded",sResult)); + pam_reset_processors(this); + pam->nLastAttachedItemId = pam->nCurrAttachedItem = 0; + pam->nAttachedItemsSize = 0; + + pam->procState = PICOPAM_SCHEDULE; + return PICODATA_PU_BUSY; + break; + + } /*end switch sResult*/ + break; /*PICOPAM_FORWARD_FORCE_TERM*/ + + case PICOPAM_PROCESS: + + if ((PICOPAM_FRAME_ITEM_SIZE + 4) > (pam->outBufSize + - pam->outWritePos)) { + /*WARNING (buffer overflow): leave status unchanged until output buffer free */ + return PICODATA_PU_BUSY; + } + + if (pam->nCurrSyllable == 0) { + sResult = pamDoPreSyll(this); + if (sResult == PICOPAM_GOTO_FEED) { + /* + items pushed to output buffer : + switch to "feed" but then back + to "process" + */ + pam->retState = PICOPAM_PROCESS; + pam->procState = PICOPAM_FEED; + return PICODATA_PU_BUSY; + } + if (sResult == PICOPAM_CONTINUE) { + /* + items processed (maybe commands) : + return (maybe we need to process other + items in pre_syll) and then back to "process" + */ + pam->retState = PICOPAM_PROCESS; + pam->procState = PICOPAM_PROCESS; + return PICODATA_PU_BUSY; + } + + if ((sResult == PICOPAM_FLUSH_RECEIVED) || (sResult + == PICODATA_PU_ERROR)) { + /* + items processed were a flush or + problems found: switch to "schedule" + and abort all processing + */ + pam->retState = PICOPAM_SCHEDULE; + pam->procState = PICOPAM_SCHEDULE; + return PICODATA_PU_BUSY; + } + if (sResult == PICOPAM_PRE_SYLL_ENDED) { + /* + we get here when pam->nCurrSyllable==0 and + no more items to be processed before the syllable + */ + sResult = sResult; + } + } + + if (pamHasToProcess(this)) { + if (pamPhoneProcess(this) == PICO_OK) { + sResult = pamUpdateProcess(this); + pam->procState = PICOPAM_FEED; /*switch to feed*/ + return PICODATA_PU_BUSY; + } else { + PICODBG_DEBUG(("pam_step(PICOPAM_PROCESS) --- NULL return from pamPhoneProcess")); + return PICODATA_PU_ERROR; + } + } + + if (pamHasToPop(this) != FALSE) { + if ((qItem = pamPopItem(this)) == NULL) { + PICODBG_DEBUG(("pam_step(PICOPAM_PROCESS) --- NULL return from pamPopItem")); + return PICODATA_PU_ERROR; + } + + if (isItemToPut(qItem)) { + /*popped item has to be sent to next PU*/ + sResult = pam_put_qItem(qItem, pam->outBuf, + pam->outWritePos, &bWr); + if (sResult != PICO_OK) { + PICODBG_DEBUG(("pam_step(PICOPAM_PROCESS) --- Error on writing item to output buffer")); + return PICODATA_PU_ERROR; + } + pam->outWritePos += bWr; /*item write ok*/ + pam->procState = PICOPAM_FEED; /*switch to feed*/ + } + + /*moved command processing here (after pam_put_qItem) because of FLUSH command could erase + * the syllable structure and make it impossible to transmit the flush to other PUs*/ + if (is_pam_command(qItem) == TRUE) { + sResult = pamDoCommand(this, qItem); /*popped item is a PAM command : do it NOW!!*/ + if ((sResult == PICOPAM_FLUSH_RECEIVED) || (sResult + == PICODATA_PU_ERROR)) { + pam->retState = PICOPAM_SCHEDULE; + pam->procState = PICOPAM_SCHEDULE; /*switch to schedule */ + return PICODATA_PU_BUSY; + } + } + /*update PAM status: if more items attached to the current syllable + stay in current syllable, otherwise move to next syllable and switch + to processing phones */ + sResult = pamUpdateProcess(this); /*both "doCommand" or "put" : update PAM status*/ + return PICODATA_PU_BUSY; + } else { + pam->procState = PICOPAM_SCHEDULE; /*switch to schedule */ + return PICODATA_PU_BUSY; + } + + break; /*PICOPAM_PROCESS*/ + + case PICOPAM_IMMEDIATE: + /* *** item is output NOW!!! */ + /*context: full valid item, with len> starting at pam->inBuf[pam->inReadPos]*/ + numinb = PICODATA_ITEM_HEADSIZE + + pam->inBuf[pam->inReadPos + 3]; + sResult = picodata_copy_item(&(pam->inBuf[pam->inReadPos]), + numinb, &(pam->outBuf[pam->outWritePos]), + pam->outBufSize - pam->outWritePos, &numoutb); + + if (sResult == PICO_OK) { + pam->inReadPos += numinb; + if (pam->inReadPos >= pam->inWritePos) { + pam->inReadPos = 0; + pam->inWritePos = 0; + pam->needMoreInput = FALSE; + } + pam->outWritePos += numoutb; + pam->procState = PICOPAM_FEED; /*switch to FEED state*/ + pam->retState = PICOPAM_SCHEDULE; /*back to SCHEDULE after FEED*/ + } else { + /* + PICO_EXC_BUF_IGNORE + PICO_EXC_BUF_UNDERFLOW + PICO_EXC_BUF_OVERFLOW + */ + PICODBG_DEBUG(("pam_step(PICOPAM_IMMEDIATE) --- wrong return from picodata_copy_item:%d",sResult)); + return PICODATA_PU_ERROR; + } + return PICODATA_PU_BUSY; + break; /*PICOPAM_IMMEDIATE*/ + + case PICOPAM_FEED: + /* *************** item output/feeding ***********************************/ + /*feeding items to PU output buffer*/ + sResult = picodata_cbPutItem(this->cbOut, + &(pam->outBuf[pam->outReadPos]), pam->outWritePos + - pam->outReadPos, &numoutb); + PICODBG_DEBUG(("pam_step -- put item, status: %d",sResult)); + if (PICO_OK == sResult) { + + PICODATA_INFO_ITEM(this->voice->kbArray[PICOKNOW_KBID_DBG], + (picoos_uint8 *)"pam: ", + pam->outBuf + pam->outReadPos, pam->outBufSize); + + pam->outReadPos += numoutb; + *numBytesOutput = numoutb; + if (pam->outReadPos >= pam->outWritePos) { + /*reset the output pointers*/ + pam->outReadPos = 0; + pam->outWritePos = 0; + /*switch to appropriate state*/ + switch (pam->retState) { + case PICOPAM_IMMEDIATE: + pam->procState = PICOPAM_IMMEDIATE; + pam->retState = PICOPAM_SCHEDULE; + return PICODATA_PU_BUSY; + break; + case PICOPAM_PLAY: + pam->procState = PICOPAM_PLAY; + pam->retState = PICOPAM_SCHEDULE; + return PICODATA_PU_BUSY; + break; + default: + break; + } + /*Define next state + a)process (if current sentence has more data to process) + b)schedule (no more data to process in current sentence) + NOTE : case b)also happens when dealing with non BOUND/SYLL items*/ + if ((pamHasToProcess(this)) || (pamHasToPop(this))) { + pam->procState = PICOPAM_PROCESS; + } else { + pam->nCurrSyllable = -1; + pam_reset_processors(this); + pam->nLastAttachedItemId = pam->nCurrAttachedItem + = 0; + pam->nAttachedItemsSize = 0; + + pam->nSyllPhoneme = 0; + pam->procState = PICOPAM_SCHEDULE; + } + } + return PICODATA_PU_BUSY; + + } else if (PICO_EXC_BUF_OVERFLOW == sResult) { + + PICODBG_DEBUG(("pam_step ** feeding, overflow, PICODATA_PU_OUT_FULL")); + return PICODATA_PU_OUT_FULL; + + } else if ((PICO_EXC_BUF_UNDERFLOW == sResult) + || (PICO_ERR_OTHER == sResult)) { + + PICODBG_DEBUG(("pam_step ** feeding problem, discarding item")); + pam->outReadPos = 0; + pam->outWritePos = 0; + pam->procState = PICOPAM_COLLECT; + return PICODATA_PU_ERROR; + + } + break; /*PICOPAM_FEED*/ + + default: + /*NOT feeding items*/ + sResult = PICO_EXC_BUF_IGNORE; + break; + }/*end switch*/ + return PICODATA_PU_BUSY; /*check if there is more data to process after feeding*/ + + }/*end while*/ + return PICODATA_PU_IDLE; +}/*pam_step*/ + +/** + * performs one step of a PamTree + * @param this : Pam item subobject pointer + * @param dtpam : the Pam decision tree + * @param *invec : the input vector pointer + * @param inveclen : length of the input vector + * @param *dtres : the classification result + * @return dtres->set : the result of tree traversal + * @callgraph + * @callergraph + */ +static picoos_uint8 pam_do_tree(register picodata_ProcessingUnit this, + const picokdt_DtPAM dtpam, const picoos_uint8 *invec, + const picoos_uint8 inveclen, picokdt_classify_result_t *dtres) +{ + picoos_uint8 okay; + + okay = TRUE; + /* construct input vector, which is set in dtpam */ + if (!picokdt_dtPAMconstructInVec(dtpam, invec, inveclen)) { + /* error constructing invec */ + PICODBG_WARN(("problem with invec")); + picoos_emRaiseWarning(this->common->em, PICO_WARN_INVECTOR, NULL, NULL); + okay = FALSE; + } + /* classify */ + if (okay && (!picokdt_dtPAMclassify(dtpam))) { + /* error doing classification */ + PICODBG_WARN(("problem classifying")); + picoos_emRaiseWarning(this->common->em, PICO_WARN_CLASSIFICATION, NULL, + NULL); + okay = FALSE; + } + /* decompose */ + if (okay && (!picokdt_dtPAMdecomposeOutClass(dtpam, dtres))) { + /* error decomposing */ + PICODBG_WARN(("problem decomposing")); + picoos_emRaiseWarning(this->common->em, PICO_WARN_OUTVECTOR, NULL, NULL); + okay = FALSE; + } + + PICODBG_TRACE(("dtpam output class: %d", dtres->class)); + + return dtres->set; +}/*pam_do_tree*/ + +/** + * returns the carrier vowel id inside a syllable + * @param this : Pam item subobject pointer + * @param item : the full syllable item + * @param *pos : pointer to the variable to receive the position of the carrier vowel + * @return the phonetic id for the carrier vowel inside the syllable + * @callgraph + * @callergraph + */ +static picoos_uint8 pam_get_vowel_name(register picodata_ProcessingUnit this, + picoos_uint8 *item, picoos_uint8 *pos) +{ + pam_subobj_t *pam; + picoos_uint8 *phon, nI, nCond1; + if (NULL == this || NULL == this->subObj) { + return 0; + } + pam = (pam_subobj_t *) this->subObj; + + if (item == NULL) + return 0; + if (item[3] == 0) + return 0; + phon = &item[4]; + for (nI = 0; nI < item[3]; nI++) { + nCond1 = picoktab_isSyllCarrier(pam->tabphones, phon[nI]); + if (nCond1) { + *pos = nI; + return phon[nI]; + } + } + return 0; +}/*pam_get_vowel_name */ + +/** + * returns the pause phone id in the current ph.alphabet + * @param this : Pam sub object pointer + * @return the (numeric) phonetic id of the pause phone in current phonetic alphabet + * @return 0 : errors on getting the pam subobject pointer + * @callgraph + * @callergraph + */ +static picoos_uint8 pam_get_pause_id(register picodata_ProcessingUnit this) +{ + picoos_uint8 nVal1; + /*picoos_uint8 nVal2; */ + pam_subobj_t *pam; + if (NULL == this || NULL == this->subObj) { + return 0; + } + pam = (pam_subobj_t *) this->subObj; + nVal1 = picoktab_getPauseID(pam->tabphones); + return nVal1; +}/*pam_get_pause_id */ + +/** + * returns the pam sentence type (declarative, interrogative...) + * @param iteminfo1 : the boundary item info 1 + * @param iteminfo2 : the boundary item info 2 + * @return the sentence type suitably encoded for trees + * @callgraph + * @callergraph + */ +static picoos_uint8 pam_map_sentence_type(picoos_uint8 iteminfo1, + picoos_uint8 iteminfo2) +{ + switch (iteminfo2) { + case PICODATA_ITEMINFO2_BOUNDTYPE_P: + return PICOPAM_DECLARATIVE; + case PICODATA_ITEMINFO2_BOUNDTYPE_T: + return PICOPAM_DECLARATIVE; + case PICODATA_ITEMINFO2_BOUNDTYPE_Q: + return PICOPAM_INTERROGATIVE; + case PICODATA_ITEMINFO2_BOUNDTYPE_E: + return PICOPAM_DECLARATIVE; + default: + return PICOPAM_DECLARATIVE; + } + iteminfo1 = iteminfo1; /* avoid warning "var not used in this function"*/ + return PICOPAM_DECLARATIVE; +}/*pam_map_sentence_type */ + +/** + * returns the pam phrase type + * @param iteminfo1 : the boundary item info 1 + * @param iteminfo2 : the boundary item info 2 + * @return the phrase type suitably encoded for trees + * @callgraph + * @callergraph + */ +static picoos_uint8 pam_map_phrase_type(picoos_uint8 iteminfo1, + picoos_uint8 iteminfo2) +{ + + switch (iteminfo2) { + case PICODATA_ITEMINFO2_BOUNDTYPE_P: + switch (iteminfo1) { + case PICODATA_ITEMINFO1_BOUND_PHR1: +# ifdef PAM_PHR2_WITH_PR1 + case PICODATA_ITEMINFO1_BOUND_PHR2: +# endif + return PICOPAM_P; /*current_prhase type = "P" (encoded to 1) */ + break; + case PICODATA_ITEMINFO1_BOUND_PHR3: +# ifdef PAM_PHR2_WITH_PR3 + case PICODATA_ITEMINFO1_BOUND_PHR2 : +# endif + return PICOPAM_p; /*current_prhase type = "p" (encoded to 2) */ + break; + case PICODATA_ITEMINFO1_BOUND_SBEG: + return PICOPAM_P; /*current_prhase type = "P" (encoded to 1) */ + break; + default: + PICODBG_DEBUG(("Map pam_map_phrase_type : unexpected iteminfo1")); + return PICOPAM_P; /*current_prhase type = "P" (encoded to 1) */ + break; + } + case PICODATA_ITEMINFO2_BOUNDTYPE_T: + return PICOPAM_T; /*current_prhase type = "T" (encoded to 0) */ + break; + case PICODATA_ITEMINFO2_BOUNDTYPE_E: + return PICOPAM_T; /*current_prhase type = "T" (encoded to 0) */ + break; + case PICODATA_ITEMINFO2_BOUNDTYPE_Q: + return PICOPAM_Y; /*current_prhase type = "T" (encoded to 0) */ + break; + default: + PICODBG_DEBUG(("Map pam_map_phrase_type : unexpected iteminfo2")); + return PICOPAM_T; /*current_prhase type = "T" (encoded to 0) */ + break; + }PICODBG_DEBUG(("Map pam_map_phrase_type : unexpected iteminfo2")); + return PICOPAM_T; /*current_prhase type = "T" (encoded to 0) */ + +}/*pam_map_phrase_type */ + +/** + * does the cleanup of the sub object processors flags at sentence start + * @param this : pointer to PAM PU sub object pointer + * @return PICO_OK : reset OK + * @return PICO_ERR_OTHER : errors on getting pam sub obj pointer + * @callgraph + * @callergraph + */ +static pico_status_t pam_reset_processors(register picodata_ProcessingUnit this) +{ + pam_subobj_t *pam; + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + + pam->nCurrSyllable = -1; + pam->nTotalPhonemes = pam->nSyllPhoneme = pam->nCurrPhoneme + = pam->nTotalSyllables = pam->sType = pam->pType = 0; + pam->dRest = 0.0f; + /*set all to 0*/ + pam->a3_overall_syllable = pam->a3_primary_phrase_syllable = pam->b4_b5_syllable = + pam->b6_b7_syllable = pam->b6_b7_state = pam->b8_b9_stressed_syllable = + pam->b10_b11_accented_syllable = pam->b12_b13_syllable = pam->b12_b13_state = + pam->b14_b15_syllable = pam->b14_b15_state = pam->b17_b19_syllable = + pam->b17_b19_state = pam->b18_b20_b21_syllable = pam->b18_b20_b21_state = + pam->c3_overall_syllable= pam->c3_primary_phrase_syllable = pam->d2_syllable_in_word = + pam->d2_prev_syllable_in_word = pam->d2_current_primary_phrase_word = pam->e1_syllable_word_start = + pam->e1_syllable_word_end= pam->e1_content = pam->e2_syllable_word_start = + pam->e2_syllable_word_end= pam->e3_e4_word = pam->e3_e4_state = + pam->e5_e6_content_word = pam->e5_e6_content = pam->e7_e8_word = + pam->e7_e8_content = pam->e7_e8_state = pam->e9_e11_word = + pam->e9_e11_saw_word = pam->e9_e11_state = pam->e10_e12_e13_word = + pam->e10_e12_e13_state = pam->e10_e12_e13_saw_word = pam->f2_overall_word = + pam->f2_word_syllable = pam->f2_next_word_syllable = pam->f2_current_primary_phrase_word = + pam->g1_current_secondary_phrase_syllable = pam->g1_current_syllable = + pam->g2_current_secondary_phrase_word = pam->g2_current_word = + pam->h1_current_secondary_phrase_syll = pam->h2_current_secondary_phrase_word = + pam->h3_h4_current_secondary_phrase_word = pam->h5_current_phrase_type = + pam->h5_syllable = pam->h5_state = pam->i1_secondary_phrase_syllable = + pam->i1_next_secondary_phrase_syllable = pam->i2_secondary_phrase_word = + pam->i2_next_secondary_phrase_word = pam->j1_utterance_syllable = + pam->j2_utterance_word = pam->j3_utterance_sec_phrases = 0; + /*Override 0 with 1*/ + pam->b4_b5_syllable = pam->b17_b19_syllable = pam->b18_b20_b21_syllable = + pam->e9_e11_word = pam->e10_e12_e13_word = pam->e7_e8_word = + pam->h2_current_secondary_phrase_word = 1; + /*Override 0 with -1*/ + pam->e1_syllable_word_start = pam->e1_syllable_word_end = pam->e2_syllable_word_start = + pam->e2_syllable_word_end = -1; + + return PICO_OK; +}/*pam_reset_processors*/ + +/** + * does the cleanup of the sub object processors flags before the backward step + * @param this : pointer to PAM PU sub object pointer + * @return PICO_OK : reset OK + * @return PICO_ERR_OTHER : errors on getting pam sub obj pointer + * @callgraph + * @callergraph + */ +static pico_status_t pam_reset_processors_back( + register picodata_ProcessingUnit this) +{ + pam_subobj_t *pam; + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + + /*set all to 0*/ + pam->a3_overall_syllable + = pam->a3_primary_phrase_syllable + = pam->b4_b5_syllable + = pam->b6_b7_syllable + = pam->b6_b7_state + = pam->b8_b9_stressed_syllable + = pam->b10_b11_accented_syllable + = pam->b12_b13_syllable + = pam->b12_b13_state + = pam->b14_b15_syllable + = pam->b14_b15_state + = pam->b17_b19_syllable + = pam->b17_b19_state + = pam->b18_b20_b21_syllable + = pam->b18_b20_b21_state + = pam->c3_overall_syllable + = pam->c3_primary_phrase_syllable + = pam->d2_syllable_in_word + = pam->d2_prev_syllable_in_word + = pam->d2_current_primary_phrase_word + = pam->e1_syllable_word_start + = pam->e1_syllable_word_end + = pam->e1_content + = pam->e2_syllable_word_start + = pam->e2_syllable_word_end + = pam->e3_e4_word + = pam->e3_e4_state + = pam->e5_e6_content_word + = pam->e5_e6_content + = pam->e7_e8_word + = pam->e7_e8_content + = pam->e7_e8_state + = pam->e9_e11_word + = pam->e9_e11_saw_word + = pam->e9_e11_state + = pam->e10_e12_e13_word + = pam->e10_e12_e13_state + = pam->e10_e12_e13_saw_word + = pam->f2_overall_word + = pam->f2_word_syllable + = pam->f2_next_word_syllable + = pam->f2_current_primary_phrase_word + = pam->g1_current_secondary_phrase_syllable + = pam->g1_current_syllable + = pam->g2_current_secondary_phrase_word + = pam->g2_current_word + = pam->h1_current_secondary_phrase_syll + = pam->h2_current_secondary_phrase_word + = pam->h3_h4_current_secondary_phrase_word + = pam->h5_current_phrase_type + = pam->h5_state + = pam->i1_secondary_phrase_syllable + = pam->i1_next_secondary_phrase_syllable + = pam->i2_secondary_phrase_word + = pam->i2_next_secondary_phrase_word + = 0; + /*Override 0 with 1*/ + pam->b4_b5_syllable = pam->b17_b19_syllable = pam->b18_b20_b21_syllable + = pam->e9_e11_word = pam->e10_e12_e13_word = pam->e7_e8_word + = pam->h2_current_secondary_phrase_word = 1; + /*Override 0 with -1*/ + pam->e1_syllable_word_start = pam->e1_syllable_word_end + = pam->e2_syllable_word_start = pam->e2_syllable_word_end = -1; + + return PICO_OK; +}/*pam_reset_processors_back*/ + +/** + * processes an input event for a specific feature + * @param this : pointer to PAM PU sub object pointer + * @param nFeat : feature column to process + * @param event_type : event id among syll/boundprim/boundsec/boundword + * @param direction : forward(0)/backward(1) + * @return PICO_OK : process OK + * @return PICO_ERR_OTHER : errors on getting pam sub obj pointer + * @callgraph + * @callergraph + */ +static pico_status_t pam_process_event_feature( + register picodata_ProcessingUnit this, picoos_uint8 nFeat, + picoos_uint8 event_type, picoos_uint8 direction) +{ + picoos_uint8 sDest, nI; + picoos_uint16 syllCurr; + pam_subobj_t *pam; + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + syllCurr = pam->nCurrSyllable; + switch (nFeat) { + case A3: + /*processor for A3*/ + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + if ((pam->sSyllFeats[pam->nCurrSyllable].phoneV[P1] + == 1) || (pam->a3_primary_phrase_syllable >= 1)) { + if (pam->a3_overall_syllable < 1) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[A3] + = 0; + else + pam->sSyllFeats[pam->nCurrSyllable].phoneV[A3] + = pam->sSyllFeats[pam->nCurrSyllable + - 1].phoneV[B3]; + } else { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[A3] = 0; + } + pam->a3_primary_phrase_syllable++; + pam->a3_overall_syllable++; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->a3_primary_phrase_syllable = 0; + } + break; + case PICOPAM_DIR_BACK: + /*do nothing*/ + break; + } + break; + case B1: + case B2: + case B3: + /*done in createSyllable*/ + break; + case B4:/*processor for B4,B5*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = B4; + break; + case PICOPAM_DIR_BACK: + sDest = B5; + break; + default: + sDest = B4; + break; + } + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P1] == 0) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->b4_b5_syllable; + pam->b4_b5_syllable++; + } else { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] = 0; + } + } + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) { + pam->b4_b5_syllable = 1; + } + break; + case B5:/*processor for B5 : done in B4*/ + break; + case B6:/*processor for B6,B7*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = B6; + break; + case PICOPAM_DIR_BACK: + sDest = B7; + break; + default: + sDest = B6; + break; + } + switch (pam->b6_b7_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = PICOPAM_DONT_CARE_VALUE; + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->b6_b7_syllable = 1; + pam->b6_b7_state = 1; + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->b6_b7_syllable; + pam->b6_b7_syllable++; + } + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->b6_b7_syllable = 1; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->b6_b7_state = 0; + } + break; + default: + break; + } + break; + case B7:/*Done in B6*/ + break; + case B8:/*processor for B8,B9*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = B8; + break; + case PICOPAM_DIR_BACK: + sDest = B9; + break; + default: + sDest = B8; + break; + } + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->b8_b9_stressed_syllable; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[B1] == 1) + pam->b8_b9_stressed_syllable++; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->b8_b9_stressed_syllable = 0; + } + + break; + case B9:/*done in B8*/ + break; + case B10:/*processor for B10, B11*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = B10; + break; + case PICOPAM_DIR_BACK: + sDest = B11; + break; + default: + sDest = B10; + break; + } + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->b10_b11_accented_syllable; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[B2] == 1) + pam->b10_b11_accented_syllable++; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->b10_b11_accented_syllable = 0; + } + break; + case B11:/*done in B10*/ + break; + case B12:/*processor for B12,B13*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = B12; + break; + case PICOPAM_DIR_BACK: + sDest = B13; + break; + default: + sDest = B12; + break; + } + switch (pam->b12_b13_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[B1] == 0) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = PICOPAM_DONT_CARE_VALUE; + else { + pam->b12_b13_syllable = 0; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = PICOPAM_DONT_CARE_VALUE; + pam->b12_b13_state = 1; + } + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->b12_b13_syllable; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[B1] == 1) + pam->b12_b13_syllable = 0; + else + pam->b12_b13_syllable++; + pam->b12_b13_state = 2; + } + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->b12_b13_state = 0; + break; + case 2: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->b12_b13_syllable; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[B1] == 1) + pam->b12_b13_syllable = 0; + else + pam->b12_b13_syllable++; + } + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->b12_b13_state = 0; + + break; + default: + break; + } + break; + case B13:/*done in B12*/ + break; + + case B14:/*processor for B14, B15*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = B14; + break; + case PICOPAM_DIR_BACK: + sDest = B15; + break; + default: + sDest = B14; + break; + } + switch (pam->b14_b15_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[B2] == 0) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = PICOPAM_DONT_CARE_VALUE; + else { + pam->b14_b15_syllable = 0; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = PICOPAM_DONT_CARE_VALUE; + pam->b14_b15_state = 1; + } + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->b14_b15_syllable; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[B2] == 1) + pam->b14_b15_syllable = 0; + else + pam->b14_b15_syllable++; + pam->b14_b15_state = 2; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->b14_b15_state = 0; + } + break; + case 2: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->b14_b15_syllable; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[B2] == 1) + pam->b14_b15_syllable = 0; + else + pam->b14_b15_syllable++; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->b14_b15_state = 0; + } + break; + default: + break; + } + break; + case B15:/*Processor for B15 : done in B14*/ + break; + case B16:/*done in createSyllable*/ + break; + case B17:/*processor for B17, B19 unified */ + switch (direction) { + case PICOPAM_DIR_FORW: + switch (pam->b17_b19_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B17] + = PICOPAM_DONT_CARE_VALUE; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B19] + = pam->b17_b19_syllable; + pam->b17_b19_syllable++; + } + if (((event_type == PICOPAM_EVENT_P_BOUND) + || (event_type == PICOPAM_EVENT_S_BOUND)) + && (pam->b17_b19_syllable > 1)) { + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->b17_b19_syllable = 1; + pam->b17_b19_state = 1; + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B17] + = pam->b17_b19_syllable; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B19] + = PICOPAM_DONT_CARE_VALUE; + pam->b17_b19_syllable++; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->b17_b19_syllable = 1; + } + break; + default: + break; + } + break; + case PICOPAM_DIR_BACK: + /*do nothing*/ + break; + } + break; + case B18:/*processor for B18, B20, B21 unfied*/ + switch (direction) { + case PICOPAM_DIR_FORW:/*do nothing*/ + break; + case PICOPAM_DIR_BACK: + switch (pam->b18_b20_b21_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B18] + = PICOPAM_DONT_CARE_VALUE; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P6] + == PICOPAM_DECLARATIVE) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B20] + = pam->b18_b20_b21_syllable; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B21] + = PICOPAM_DONT_CARE_VALUE; + } else { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B20] + = PICOPAM_DONT_CARE_VALUE; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B21] + = pam->b18_b20_b21_syllable; + } + pam->b18_b20_b21_syllable++; + } + if (((event_type == PICOPAM_EVENT_P_BOUND) + || (event_type == PICOPAM_EVENT_S_BOUND)) + && (pam->b18_b20_b21_syllable > 1)) { + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->b18_b20_b21_syllable = 1; + pam->b18_b20_b21_state = 1; + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B18] + = pam->b18_b20_b21_syllable; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B20] + = PICOPAM_DONT_CARE_VALUE; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B21] + = PICOPAM_DONT_CARE_VALUE; + pam->b18_b20_b21_syllable++; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->b18_b20_b21_syllable = 1; + } + break; + default: + break; + } + break; + } + break; + case B19:/*processor for B19 : done in B17*/ + break; + case B20:/*processor for B20 : done in B18*/ + break; + case B21:/*processor for B21 : done in B18*/ + break; + case C3:/*processor for C3*/ + switch (direction) { + case PICOPAM_DIR_FORW: + /*do nothing*/ + break; + case PICOPAM_DIR_BACK: + if (event_type == PICOPAM_EVENT_SYLL) { + if ((pam->sSyllFeats[pam->nCurrSyllable].phoneV[P1] + == 1) || (pam->c3_primary_phrase_syllable >= 1)) { + if (pam->c3_overall_syllable < 1) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[C3] + = 0; + else + pam->sSyllFeats[pam->nCurrSyllable].phoneV[C3] + = pam->sSyllFeats[pam->nCurrSyllable + + 1].phoneV[B3]; + } else { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[C3] = 0; + } + pam->c3_primary_phrase_syllable++; + pam->c3_overall_syllable++; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->c3_primary_phrase_syllable = 0; + } + break; + } + break; + case D2:/*processor for D2*/ + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + if ((pam->sSyllFeats[pam->nCurrSyllable].phoneV[P1] + == 1) || (pam->d2_current_primary_phrase_word + >= 1)) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[D2] + = pam->d2_prev_syllable_in_word; + else + pam->sSyllFeats[pam->nCurrSyllable].phoneV[D2] = 0; + + pam->d2_syllable_in_word++; + } + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) { + pam->d2_current_primary_phrase_word = 1; + pam->d2_prev_syllable_in_word + = pam->d2_syllable_in_word; + pam->d2_syllable_in_word = 0; + /*pam->d2_current_primary_phrase_word++;*/ + } + if ((event_type == PICOPAM_EVENT_P_BOUND)) { + pam->d2_current_primary_phrase_word = 0; + } + break; + case PICOPAM_DIR_BACK: + /*do nothing*/ + break; + } + break; + case E1:/*processor for E1*/ + switch (direction) { + case PICOPAM_DIR_FORW: /*remember : content syllable indicator already on P5*/ + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->e1_syllable_word_start == -1) + pam->e1_syllable_word_start + = (picoos_int8) pam->nCurrSyllable; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P5] == 1) + pam->e1_content = 1; + pam->e1_syllable_word_end + = (picoos_int8) pam->nCurrSyllable; + } + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) { + if ((pam->e1_syllable_word_start != -1) + && (pam->e1_syllable_word_end != -1)) { + for (nI = pam->e1_syllable_word_start; nI + <= pam->e1_syllable_word_end; nI++) + pam->sSyllFeats[nI].phoneV[E1] + = pam->e1_content; + } + pam->e1_content = 0; + pam->e1_syllable_word_start = -1; + pam->e1_syllable_word_end = -1; + } + break; + case PICOPAM_DIR_BACK: + /*do nothing*/ + break; + } + break; + case E2:/*processor for E2*/ + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->e2_syllable_word_start == -1) + pam->e2_syllable_word_start + = (picoos_int8) pam->nCurrSyllable; + pam->e2_syllable_word_end + = (picoos_int8) pam->nCurrSyllable; + } + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) { + if ((pam->e2_syllable_word_start != -1) + && (pam->e2_syllable_word_end != -1)) { + for (nI = pam->e2_syllable_word_start; nI + <= pam->e2_syllable_word_end; nI++) + pam->sSyllFeats[nI].phoneV[E2] + = pam->e2_syllable_word_end + - pam->e2_syllable_word_start + + 1; + } + pam->e1_content = 0; + pam->e2_syllable_word_start = -1; + pam->e2_syllable_word_end = -1; + } + break; + case PICOPAM_DIR_BACK: + break; + } + break; + case E3:/*processor for E3,E4*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = E3; + break; + case PICOPAM_DIR_BACK: + sDest = E4; + break; + default: + sDest = E3; + break; + } + switch (pam->e3_e4_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = PICOPAM_DONT_CARE_VALUE; + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->e3_e4_word = 1; + pam->e3_e4_state = 1; + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->e3_e4_word; + if (event_type == PICOPAM_EVENT_S_BOUND) + pam->e3_e4_word = 1; + if (event_type == PICOPAM_EVENT_W_BOUND) + pam->e3_e4_word++; + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->e3_e4_state = 0; + break; + default: + break; + } + break; + case E4:/*processor for E4 : done in E3*/ + break; + case E5:/*processor for E5,E6*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = E5; + break; + case PICOPAM_DIR_BACK: + sDest = E6; + break; + default: + sDest = E5; + break; + } + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->e5_e6_content_word; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P5] == 1) + pam->e5_e6_content = 1; + } + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) { + if (pam->e5_e6_content == 1) + pam->e5_e6_content_word++; + pam->e5_e6_content = 0; + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->e5_e6_content_word = 0; + } + break; + case E6:/*processor for E6 : done in E5*/ + break; + case E7:/*processor for E7,E8*/ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = E7; + break; + case PICOPAM_DIR_BACK: + sDest = E8; + break; + default: + sDest = E7; + break; + } + switch (pam->e7_e8_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = PICOPAM_DONT_CARE_VALUE; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P5] == 1) + pam->e7_e8_content = 1; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->e7_e8_content = 0; + } + + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND)) { + if (pam->e7_e8_content == 1) { + pam->e7_e8_word = 0; + pam->e7_e8_content = 0; + pam->e7_e8_state = 1; + } + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->e7_e8_word; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P5] == 1) + pam->e7_e8_content = 1; + } + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND)) { + if (pam->e7_e8_content == 1) { + pam->e7_e8_word = 0; + pam->e7_e8_content = 0; + } else { + pam->e7_e8_word++; + } + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->e7_e8_state = 0; + pam->e7_e8_content = 0; /*<<<<<< added */ + } + + default: + break; + } + break; + case E8:/*processor for E8 : done in E7*/ + break; + case E9: + /*processor for E9, E11*/ + switch (direction) { + case PICOPAM_DIR_FORW: + switch (pam->e9_e11_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E9] + = PICOPAM_DONT_CARE_VALUE; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E11] + = pam->e9_e11_word; + pam->e9_e11_saw_word = 1; /*new variable, needs to be initialized to 0*/ + } + if (event_type == PICOPAM_EVENT_W_BOUND) + pam->e9_e11_word++; + if (((event_type == PICOPAM_EVENT_P_BOUND) + || (event_type == PICOPAM_EVENT_S_BOUND)) + && (pam->e9_e11_saw_word == 1)) { /* modified*/ + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->e9_e11_word = 1; + else + pam->e9_e11_word++; /*modified*/ + pam->e9_e11_state = 1; + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E9] + = pam->e9_e11_word; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E11] + = PICOPAM_DONT_CARE_VALUE; + } + if ((event_type == PICOPAM_EVENT_W_BOUND) + || (event_type == PICOPAM_EVENT_S_BOUND)) + pam->e9_e11_word++; + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->e9_e11_word = 1; + break; + default: + break; + } + break; + case PICOPAM_DIR_BACK: + /*do nothing*/ + break; + } + break; + case E10:/*processor for E10, E12, E13 unified*/ + switch (direction) { + case PICOPAM_DIR_FORW:/*do nothing*/ + break; + case PICOPAM_DIR_BACK: + switch (pam->e10_e12_e13_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E10] + = PICOPAM_DONT_CARE_VALUE; + pam->e10_e12_e13_saw_word = 1; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P6] + == PICOPAM_DECLARATIVE) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E12] + = pam->e10_e12_e13_word; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E13] + = PICOPAM_DONT_CARE_VALUE; + } else { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E12] + = PICOPAM_DONT_CARE_VALUE; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E13] + = pam->e10_e12_e13_word; + } + } + if (event_type == PICOPAM_EVENT_W_BOUND) + pam->e10_e12_e13_word++; + + /*if (((event_type==PICOPAM_EVENT_P_BOUND)||(event_type==PICOPAM_EVENT_S_BOUND))&&(pam->e10_e12_e13_word>1)) {*/ + if (((event_type == PICOPAM_EVENT_P_BOUND) + || (event_type == PICOPAM_EVENT_S_BOUND)) + && (pam->e10_e12_e13_saw_word > 0)) { + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->e10_e12_e13_word = 1; + else + pam->e10_e12_e13_word++; + pam->e10_e12_e13_state = 1; + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E10] + = pam->e10_e12_e13_word; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E12] + = PICOPAM_DONT_CARE_VALUE; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E13] + = PICOPAM_DONT_CARE_VALUE; + } + if ((event_type == PICOPAM_EVENT_W_BOUND) + || (event_type == PICOPAM_EVENT_S_BOUND)) + pam->e10_e12_e13_word++; + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->e10_e12_e13_word = 1; + break; + default: + break; + } + break; + } + break; + + case E11:/*processor for E11 : done in E9*/ + break; + case E12:/*processor for E12 : done in E10*/ + break; + case E13:/*processor for E13 : done in E10*/ + break; + + case F2: + switch (direction) { + case PICOPAM_DIR_FORW:/*do nothing*/ + break; + case PICOPAM_DIR_BACK: + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->f2_current_primary_phrase_word >= 1)/*at least second word in current primary phrase*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[F2] + = pam->f2_next_word_syllable; + else + /*first word in current primary phrase*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[F2] = 0; + pam->f2_word_syllable++; + } + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) {/*word - end : switch*/ + pam->f2_next_word_syllable = pam->f2_word_syllable; + pam->f2_word_syllable = 0; + } + if (event_type == PICOPAM_EVENT_P_BOUND)/*mark first word in current primary phrase*/ + pam->f2_current_primary_phrase_word = 0; + else /*mark next word in current primary phrase(enables output in PICOPAM_EVENT_SYLL)*/ + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND)) + pam->f2_current_primary_phrase_word++; + break; + } + break; + case G1: + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->g1_current_secondary_phrase_syllable > 0) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[G1] + = pam->g1_current_secondary_phrase_syllable; + else + pam->sSyllFeats[pam->nCurrSyllable].phoneV[G1] = 0; + pam->g1_current_syllable++; + } + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->g1_current_secondary_phrase_syllable + = pam->g1_current_syllable; + pam->g1_current_syllable = 0; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->g1_current_secondary_phrase_syllable = 0; + pam->g1_current_syllable = 0; + } + case PICOPAM_DIR_BACK: /*do nothing*/ + break; + } + break; + case G2: + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->g2_current_secondary_phrase_word > 0) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[G2] + = pam->g2_current_secondary_phrase_word; + else + pam->sSyllFeats[pam->nCurrSyllable].phoneV[G2] = 0; + } + if (event_type == PICOPAM_EVENT_W_BOUND) + pam->g2_current_word++; + + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->g2_current_secondary_phrase_word + = pam->g2_current_word + 1; + pam->g2_current_word = 0; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->g2_current_secondary_phrase_word = 0; + pam->g2_current_word = 0; + } + break; + case PICOPAM_DIR_BACK: /*do nothing*/ + break; + } + break; + case H1: + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->h1_current_secondary_phrase_syll++; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H1] + = pam->h1_current_secondary_phrase_syll; + } + if ((event_type == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) + pam->h1_current_secondary_phrase_syll = 0; + break; + case PICOPAM_DIR_BACK: + if (event_type == PICOPAM_EVENT_SYLL) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H1] + = pam->h1_current_secondary_phrase_syll; + if (event_type == PICOPAM_EVENT_S_BOUND) + pam->h1_current_secondary_phrase_syll + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[H1]; + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->h1_current_secondary_phrase_syll + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H1]; + break; + } + break; + case H2: + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H2] + = pam->h2_current_secondary_phrase_word; + } + if (event_type == PICOPAM_EVENT_W_BOUND) { + pam->h2_current_secondary_phrase_word++; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H2] + = pam->h2_current_secondary_phrase_word; + } + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H2] + = pam->h2_current_secondary_phrase_word + 1; + pam->h2_current_secondary_phrase_word = 0; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + if (pam->nCurrSyllable > 1) + pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H2] + = pam->h2_current_secondary_phrase_word + 1; + pam->h2_current_secondary_phrase_word = 0; + } + break; + case PICOPAM_DIR_BACK: + if (event_type == PICOPAM_EVENT_SYLL) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H2] + = pam->h2_current_secondary_phrase_word; + if (event_type == PICOPAM_EVENT_S_BOUND) + pam->h2_current_secondary_phrase_word + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[H2]; + if (event_type == PICOPAM_EVENT_P_BOUND) + pam->h2_current_secondary_phrase_word + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H2]; + break; + } + break; + case H3:/*processor for H3,H4 unified */ + switch (direction) { + case PICOPAM_DIR_FORW: + sDest = H3; + break; + case PICOPAM_DIR_BACK: + sDest = H4; + break; + default: + sDest = H3; + break; + } + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[sDest] + = pam->h3_h4_current_secondary_phrase_word; + } + if ((event_type == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) + pam->h3_h4_current_secondary_phrase_word++; + break; + case H4: /*processor for H4 : already in H3*/ + break; + + case H5:/*processor for H5*/ + switch (direction) { + case PICOPAM_DIR_FORW: + break; + case PICOPAM_DIR_BACK: + switch (pam->h5_state) { + case 0: + if (event_type == PICOPAM_EVENT_SYLL) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H5] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[H5]; + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->h5_state = 1; + } + break; + case 1: + if (event_type == PICOPAM_EVENT_SYLL) { + if ((pam->sSyllFeats[pam->nCurrSyllable].phoneV[H5] + == PICOPAM_P) + && (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P1] + == 0)) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H5] + = PICOPAM_p; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->h5_state = 0; + } + break; + default: + break; + } + break; + + default: + break; + } + break; + + case I1:/*processor for I1*/ + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->i1_secondary_phrase_syllable++; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[I1] + = pam->i1_secondary_phrase_syllable; + } + if ((event_type == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) + pam->i1_secondary_phrase_syllable = 0; + break; + case PICOPAM_DIR_BACK: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[I1] + = pam->i1_next_secondary_phrase_syllable; + } + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->i1_next_secondary_phrase_syllable + = pam->i1_secondary_phrase_syllable; + pam->i1_secondary_phrase_syllable + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[I1]; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->i1_next_secondary_phrase_syllable = 0; + pam->i1_secondary_phrase_syllable + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[I1]; + } + break; + } + break; + case I2: /*processor for I2*/ + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[I2] + = pam->i2_secondary_phrase_word; + } + if (event_type == PICOPAM_EVENT_W_BOUND) + pam->i2_secondary_phrase_word++; + + if ((event_type == PICOPAM_EVENT_P_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND)) + pam->i2_secondary_phrase_word = 1; + + break; + case PICOPAM_DIR_BACK: + if (event_type == PICOPAM_EVENT_SYLL) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[I2] + = pam->i2_next_secondary_phrase_word; + } + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->i2_next_secondary_phrase_word + = pam->i2_secondary_phrase_word; + pam->i2_secondary_phrase_word + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[I2]; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->i2_next_secondary_phrase_word = 0; + pam->i2_secondary_phrase_word + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[I2]; + } + break; + } + break; + case J1: /*processor for J1 */ + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_SYLL) { + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P1] != 1) + pam->j1_utterance_syllable++; + } + break; + case PICOPAM_DIR_BACK: + pam->sSyllFeats[pam->nCurrSyllable].phoneV[J1] + = pam->j1_utterance_syllable; + break; + } + break; + case J2: /*processor for J2*/ + switch (direction) { + case PICOPAM_DIR_FORW: + if ((event_type == PICOPAM_EVENT_W_BOUND) || (event_type + == PICOPAM_EVENT_S_BOUND) || (event_type + == PICOPAM_EVENT_P_BOUND)) + pam->j2_utterance_word++; + break; + case PICOPAM_DIR_BACK: + pam->sSyllFeats[pam->nCurrSyllable].phoneV[J2] + = pam->j2_utterance_word - 1; + break; + } + break; + case J3: /*processor for J3*/ + switch (direction) { + case PICOPAM_DIR_FORW: + if (event_type == PICOPAM_EVENT_S_BOUND) { + pam->j3_utterance_sec_phrases++; + break; + } + if (event_type == PICOPAM_EVENT_P_BOUND) { + pam->j3_utterance_sec_phrases++; + break; + } + break; + case PICOPAM_DIR_BACK: + pam->sSyllFeats[pam->nCurrSyllable].phoneV[J3] + = pam->j3_utterance_sec_phrases - 1; + break; + } + break; + } + return PICO_OK; +}/*pam_process_event_feature*/ + +/** + * processes an input event spanning it to all column features + * @param this : pointer to PAM PU sub object pointer + * @param event_type : event id among syll/boundprim/boundsec/boundword + * @param direction : forward(0)/backward(1) + * @return PICO_OK : process OK + * @return PICO_ERR_OTHER : errors on getting pam sub obj pointer + * @callgraph + * @callergraph + */ +static pico_status_t pam_process_event(register picodata_ProcessingUnit this, + picoos_uint8 event_type, picoos_uint8 direction) +{ + picoos_uint8 nFeat; + pico_status_t nResult; + + pam_subobj_t *pam; + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + + if (direction == PICOPAM_DIR_FORW) { + if (event_type == PICOPAM_EVENT_P_BOUND) + /*primary boundary*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P2] = 1; + if (event_type == PICOPAM_EVENT_S_BOUND) + /*secondary boundary*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P3] = 1; + if (event_type == PICOPAM_EVENT_W_BOUND) + /*word boundary*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P4] = 1; + } + for (nFeat = A3; nFeat <= J3; nFeat++) { + nResult = pam_process_event_feature(this, nFeat, event_type, direction); + if (nResult != PICO_OK) + return nResult; + } + return PICO_OK; +}/*pam_process_event*/ + +/** + * inserts a syllable inside the subobj sentence data struct. + * @param this : pointer to PAM PU sub object pointer + * @param syllType : the syllable type (pause/syllable) + * @param sContent : the item content + * @param sentType : the sentence type + * @param phType : the phrase type + * @param uBoundType : the boundary type (only for silence syllables) + * @param uMinDur, uMaxDur : the mimimum and maximum duration (only for silence syllables) + * @return PICO_OK : syllable creation successful + * @return PICO_ERR_OTHER : errors in one internal function (check_phones_size..) + * @callgraph + * @callergraph + */ +static pico_status_t pam_create_syllable(register picodata_ProcessingUnit this, + picoos_uint8 syllType, picoos_uint8 *sContent, picoos_uint8 sentType, + picoos_uint8 phType, picoos_uint8 uBoundType, picoos_uint16 uMinDur, + picoos_uint16 uMaxDur) +{ + pam_subobj_t *pam; + picoos_uint8 nI; + picoos_uint8 pos; + /* picoos_uint8 *npUi16; */ + picoos_uint32 pos32; + + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + pos = 0; + /*check buffer full condition on number of syllables*/ + if (check_syllables_size(pam, 1) != PICO_OK) { + return PICO_ERR_OTHER; + } + + if (syllType == PICOPAM_SYLL_PAUSE) { + /*check buffer full condition on number of phonemes*/ + if (check_phones_size(pam, 1) != PICO_OK) { + return PICO_ERR_OTHER; + } + } + if (syllType == PICOPAM_SYLL_SYLL) { + /*check item availability*/ + if (sContent == NULL) { + return PICO_ERR_OTHER; + } + /*check buffer full condition on number of phonemes*/ + if (check_phones_size(pam, sContent[3]) != PICO_OK) { + return PICO_ERR_OTHER; + } + } + + /*open new syllable*/ + pam->nCurrSyllable = pam->nCurrSyllable + 1; + /*cleanup*/ + for (nI = 0; nI < PICOPAM_VECT_SIZE; nI++) { + if (pam->nCurrSyllable > 0) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[nI] = 0; + } else { + if ((nI >= ITM) && (nI <= itm)) { + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[nI] > 0) { + /*do not cleanup "attached item offset" fields (ITM, itm): + an already existing attached item could be lost*/ + } else { + /*cleanup "attached item offset"*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[nI] = 0; + } + } else { + /*cleanup all fields except "attached item offset" (ITM, itm)*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[nI] = 0; + } + } + } + /*set minimum and maximum duration values*/ + if ((uMinDur == 0) && (uMaxDur == 0) && (syllType == PICOPAM_SYLL_PAUSE)) { + /*both 0 : use default duration limits for boundaries*/ + get_default_boundary_limit(uBoundType, &uMinDur, &uMaxDur); + } + if (uMinDur > 0) { + pos32 = Min; + picoos_write_mem_pi_uint16(pam->sSyllFeats[pam->nCurrSyllable].phoneV, + &pos32, uMinDur); + } + if (uMaxDur > 0) { + pos32 = Max; + picoos_write_mem_pi_uint16(pam->sSyllFeats[pam->nCurrSyllable].phoneV, + &pos32, uMaxDur); + } + /*END OF BREAK COMMAND SUPPORT*/ + + if (syllType == PICOPAM_SYLL_PAUSE) { + /*initialize a pause syllable*/ + if (sentType == PICOPAM_DECLARATIVE) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P6] + = PICOPAM_DECLARATIVE; + if (sentType == PICOPAM_INTERROGATIVE) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P6] + = PICOPAM_INTERROGATIVE; + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[bnd] = uBoundType; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P1] = 1; /*this means the syllable contains a pause-silence*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P8] = 1; + + /*b1,b2,b9,b11,b13,b15,e1,e6,e8,e10 already set to 0*/ + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B3] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B4] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B5] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B6] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B7] + = 1; + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B16] + = PICOPAM_PH_DONT_CARE_VAL; /*name of the vowel in the syllable = NONE */ + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E2] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[E3] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[E4] = 1; + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H5] = phType; + + /*Store current phonetic codes in input phonetic string*/ + pam->sPhIds[pam->nCurrPhoneme] = pam_get_pause_id(this); + picoos_mem_copy((void*) &pam->nCurrPhoneme, + &(pam->sSyllFeats[pam->nCurrSyllable].phoneV[FID]), + sizeof(pam->nCurrPhoneme)); + pam->nCurrPhoneme++; + pam->nTotalPhonemes++; + /*add 1 to total number of syllables*/ + pam->nTotalSyllables++; + + return PICO_OK; + } + if (syllType == PICOPAM_SYLL_SYLL) { + /*initialize a real syllable*/ + if (sContent[2] > PICODATA_ACC0) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P5] = 1; /*set content syllable indicator*/ + if (sentType == PICOPAM_DECLARATIVE) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P6] + = PICOPAM_DECLARATIVE; + if (sentType == PICOPAM_INTERROGATIVE) + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P6] + = PICOPAM_INTERROGATIVE; + + if ((sContent[2] >= PICODATA_ACC1) && (sContent[2] <= PICODATA_ACC4)) + /*stressed*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B1] = 1; + + if ((sContent[2] >= PICODATA_ACC1) && (sContent[2] <= PICODATA_ACC2)) + /*accented*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B2] = 1; + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B3] = sContent[3];/*len*/ + + if (pam->nCurrSyllable > 30) + pam->nCurrSyllable = pam->nCurrSyllable; + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B16] = pam_get_vowel_name(this, + sContent, &pos); /*name of the vowel in the syllable*/ + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[P8] = pos; /*temp for storing the position of the vowel*/ + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H5] = phType; + + /*Store current phonetic codes in input phonetic string*/ + picoos_mem_copy((void*) &pam->nCurrPhoneme, + &(pam->sSyllFeats[pam->nCurrSyllable].phoneV[FID]), + sizeof(pam->nCurrPhoneme)); + for (nI = 0; nI < sContent[3]; nI++) + pam->sPhIds[pam->nCurrPhoneme + nI] = sContent[4 + nI]; + pam->nCurrPhoneme += nI; + pam->nTotalPhonemes += nI; + /*add 1 to total number of syllables*/ + pam->nTotalSyllables++; + return PICO_OK; + } + /*if no SyllType has been identified -->> error*/ + return PICO_ERR_OTHER; +}/*pam_create_syllable*/ + +/** + * performs the forward step of the PAM adapter + * @param this : pointer to PAM PU sub object pointer + * @param itemBase : pointer to current item + * @return PICOPAM_READY : forward step ok, the sentence is complete + * @return PICOPAM_MORE : forward step ok, but more data needed to complete the sentence + * @return PICO_ERR_OTHER : errors in one internal function (CreateSyllable..) + * @callgraph + * @callergraph + */ +static pico_status_t pam_adapter_forward_step( + register picodata_ProcessingUnit this, picoos_uint8 *itemBase) +{ + register pam_subobj_t * pam; + pico_status_t sResult; + picoos_uint16 uMinDur, uMaxDur; + picoos_uint32 nPos; + + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + uMinDur = uMaxDur = 0; /*default 0 : not initialized*/ + switch (itemBase[0]) { + case PICODATA_ITEM_BOUND: + /*received a boundary item*/ + switch (itemBase[1]) { + case PICODATA_ITEMINFO1_BOUND_SBEG: + case PICODATA_ITEMINFO1_BOUND_PHR1: +#ifdef PAM_PHR2_WITH_PR1 + case PICODATA_ITEMINFO1_BOUND_PHR2: +#endif + case PICODATA_ITEMINFO1_BOUND_SEND: + case PICODATA_ITEMINFO1_BOUND_TERM: + if (itemBase[3] == 2 * sizeof(picoos_uint16)) { + /*only when the item len duration is equal to 2 int16 --> get the values*/ + nPos = 4; + picoos_read_mem_pi_uint16(itemBase, &nPos, &uMinDur); + picoos_read_mem_pi_uint16(itemBase, &nPos, &uMaxDur); + } + break; + default: + break; + } + switch (itemBase[1]) { + case PICODATA_ITEMINFO1_BOUND_SBEG: + /* received a sentence init boundary */ + pam_reset_processors(this); /*reset all processor variables*/ + pam->sType + = pam_map_sentence_type(itemBase[1], itemBase[2]); + pam->pType = pam_map_phrase_type(itemBase[1], itemBase[2]); + /*create silence syll and process P_BOUND event*/ + sResult = pam_create_syllable(this, PICOPAM_SYLL_PAUSE, NULL, + pam->sType, pam->pType, itemBase[1], uMinDur, + uMaxDur); + if (sResult != PICO_OK) + return sResult; + sResult = pam_process_event(this, PICOPAM_EVENT_P_BOUND, + PICOPAM_DIR_FORW); + if (sResult != PICO_OK) + return sResult; + return PICOPAM_MORE; + break; + + case PICODATA_ITEMINFO1_BOUND_PHR1: +#ifdef PAM_PHR2_WITH_PR1 + case PICODATA_ITEMINFO1_BOUND_PHR2: +#endif + /*received a primary boundary*/ + pam->sType + = pam_map_sentence_type(itemBase[1], itemBase[2]); + pam->pType = pam_map_phrase_type(itemBase[1], itemBase[2]); + /*create silence syll and process P_BOUND event*/ + sResult = pam_create_syllable(this, PICOPAM_SYLL_PAUSE, NULL, + pam->sType, pam->pType, itemBase[1], uMinDur, + uMaxDur); + if (sResult != PICO_OK) + return sResult; + sResult = pam_process_event(this, PICOPAM_EVENT_P_BOUND, + PICOPAM_DIR_FORW); + if (sResult != PICO_OK) + return sResult; + return PICOPAM_MORE; + break; + +#ifdef PAM_PHR2_WITH_PR3 + case PICODATA_ITEMINFO1_BOUND_PHR2 : +#endif + case PICODATA_ITEMINFO1_BOUND_PHR3: + /*received a secondary boundary*/ + /*process S_BOUND event*/ + sResult = pam_process_event(this, PICOPAM_EVENT_S_BOUND, + PICOPAM_DIR_FORW); + /*determine new sentence and Phrase types for following syllables*/ + pam->sType + = pam_map_sentence_type(itemBase[1], itemBase[2]); + pam->pType = pam_map_phrase_type(itemBase[1], itemBase[2]); + if (sResult != PICO_OK) + return sResult; + return PICOPAM_MORE; + break; + + case PICODATA_ITEMINFO1_BOUND_PHR0: + /*received a word end boundary*/ + /*process W_BOUND event*/ + sResult = pam_process_event(this, PICOPAM_EVENT_W_BOUND, + PICOPAM_DIR_FORW); + if (sResult != PICO_OK) + return sResult; + return PICOPAM_MORE; + break; + + case PICODATA_ITEMINFO1_BOUND_SEND: + /*received a SEND boundary*/ + /*insert a new silence syllable and process P_BOUND event*/ + /*create silence syll and process P_BOUND event*/ + sResult = pam_create_syllable(this, PICOPAM_SYLL_PAUSE, NULL, + pam->sType, pam->pType, itemBase[1], uMinDur, + uMaxDur); + if (sResult != PICO_OK) + return sResult; + sResult = pam_process_event(this, PICOPAM_EVENT_P_BOUND, + PICOPAM_DIR_FORW); + if (sResult != PICO_OK) + return sResult; + return PICOPAM_READY; + break; + + case PICODATA_ITEMINFO1_BOUND_TERM: + /* received a flush boundary*/ + if (pam->nCurrSyllable == -1) { + return PICOPAM_NA; + } + /*insert a new silence syllable and process P_BOUND event*/ + /*create silence syll and process P_BOUND event*/ + sResult = pam_create_syllable(this, PICOPAM_SYLL_PAUSE, NULL, + pam->sType, pam->pType, itemBase[1], uMinDur, + uMaxDur); + if (sResult != PICO_OK) + return sResult; + sResult = pam_process_event(this, PICOPAM_EVENT_P_BOUND, + PICOPAM_DIR_FORW); + if (sResult != PICO_OK) + return sResult; + return PICOPAM_READY; + break; + + default: + /*boundary type not known*/ + return PICOPAM_NA; + break; + }/*end switch (itemBase[1])*/ + break; /*end case PICODATA_ITEM_BOUND*/ + + case PICODATA_ITEM_SYLLPHON: + /*received a syllable item*/ + /* ------------------------------------------------------------------ + following code has to be used if we do expect + SYLL items arrive even without SBEG items starting the sentence. + this may happen after a term has been issued to make room in local storage. + */ + if (pam->nCurrSyllable == -1) { + pam_reset_processors(this); + /*insert an SBEG with sType and pType taken from previous sentence*/ + sResult = pam_create_syllable(this, PICOPAM_SYLL_PAUSE, NULL, + pam->sType, pam->pType, PICODATA_ITEMINFO1_BOUND_SBEG, + 0, 0); + if (sResult != PICO_OK) + return sResult; + sResult = pam_process_event(this, PICOPAM_EVENT_P_BOUND, + PICOPAM_DIR_FORW); + if (sResult != PICO_OK) + return sResult; + } + /* ------------------------------------------------------------------*/ + sResult = pam_create_syllable(this, PICOPAM_SYLL_SYLL, itemBase, + pam->sType, pam->pType, 0, 0, 0); + if (sResult != PICO_OK) + return sResult; + sResult = pam_process_event(this, PICOPAM_EVENT_SYLL, + PICOPAM_DIR_FORW); + if (sResult != PICO_OK) + return sResult; + return PICOPAM_MORE; + break; + + default: + return PICOPAM_NA; + break; + } + return PICO_ERR_OTHER; +}/*pam_adapter_forward_step*/ + +/** + * performs the backward step of the PAM adapter + * @param this : pointer to PAM PU sub object pointer + * @return PICO_OK : backward step complete + * @return PICO_ERR_OTHER : errors on retrieving the PU pointer + * @remarks derived in some parts from the pam forward code + * @callgraph + * @callergraph + */ +static pico_status_t pam_adapter_backward_step( + register picodata_ProcessingUnit this) +{ + register pam_subobj_t * pam; + picoos_uint8 nProcessed; + picoos_uint16 nSyll; + + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + + /*Resets the processors for the backward step*/ + pam_reset_processors_back(this); + /*Do the backward step*/ + nSyll = pam->nCurrSyllable; + while (pam->nCurrSyllable >= 0) { + nProcessed = 0; + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P2] == 1) { + /*primary boundary*/ + pam_process_event(this, PICOPAM_EVENT_P_BOUND, PICOPAM_DIR_BACK); + pam->nCurrSyllable--; + nProcessed = 1; + } + if ((nProcessed == 0) + && (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P3] == 1)) { + /*secondary boundary*/ + pam_process_event(this, PICOPAM_EVENT_S_BOUND, PICOPAM_DIR_BACK); + pam_process_event(this, PICOPAM_EVENT_SYLL, PICOPAM_DIR_BACK); + pam->nCurrSyllable--; + nProcessed = 1; + } + if ((nProcessed == 0) + && (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P4] == 1)) { + /*word boundary*/ + pam_process_event(this, PICOPAM_EVENT_W_BOUND, PICOPAM_DIR_BACK); + pam_process_event(this, PICOPAM_EVENT_SYLL, PICOPAM_DIR_BACK); + pam->nCurrSyllable--; + nProcessed = 1; + } + if (nProcessed == 0) { + /*non boundaried syllable*/ + pam_process_event(this, PICOPAM_EVENT_SYLL, PICOPAM_DIR_BACK); + pam->nCurrSyllable--; + nProcessed = 0; + } + }/*end while (pam->nCurrSyllable>=0)*/ + /*reset syllpointer to original value*/ + pam->nCurrSyllable = nSyll; + /*Perform pause processing*/ + pam_adapter_do_pauses(this); + pam->nCurrSyllable = 0; + pam->nSyllPhoneme = 0; + + return PICO_OK; +}/*pam_adapter_backward_step*/ + +/** + * processes a pause (silence) syllable after backward processing + * @param this : pointer to PAM PU sub object pointer : processes a pause (silence) syllable after backward processing + * @return PICO_OK : backward step complete + * @return PICO_ERR_OTHER : errors on retrieving the PU pointer + * @remarks pam->nCurrSyllable should point to a pause item + * @remarks this function should be called after backward processing + * @remarks this function corresponds to initializing silence phonemes with + * @remarks values derived from previous or following syllables + * @callgraph + * @callergraph + */ +static pico_status_t pam_do_pause(register picodata_ProcessingUnit this) +{ + picoos_uint16 syllCurr; + pam_subobj_t *pam; + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + syllCurr = pam->nCurrSyllable; + + /*processor for all features that can be inherited from previous syll (or word/phrase)*/ + if (pam->nCurrSyllable > 0) { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[A3] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B3]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B8] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B8]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B10] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B10]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B12] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B12]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B14] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B14]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B17] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B17]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B19] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B19]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B20] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B20]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B21] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[B21]; + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[D2] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[E2]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[G1] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H1]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[G2] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H2]; + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E5] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[E5]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E7] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[E7]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E9] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[E9]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E11] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[E11]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E12] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[E12]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E13] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[E13]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[E13] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[E13]; + + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H1] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H1]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H2] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H2]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H3] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H3]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H4] + = pam->sSyllFeats[pam->nCurrSyllable - 1].phoneV[H4]; + + } else { + pam->sSyllFeats[pam->nCurrSyllable].phoneV[A3] + =pam->sSyllFeats[pam->nCurrSyllable].phoneV[B8] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B10] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B12] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B14] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B17] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B19] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B20] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[B21] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[E5] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[E9] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[E11] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[E12] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[H1] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[H2] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[H3] + = 0; + + /*init values different from 0*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H4] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[J3]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[H5] = PICOPAM_p; + + } + + /*processor for all features that can be inherited from next syll (or word/phrase)*/ + if (pam->nCurrSyllable < pam->nTotalSyllables - 1) { + /*non last syllable*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[C3] + = pam->sSyllFeats[pam->nCurrSyllable + 1].phoneV[B3]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[F2] + = pam->sSyllFeats[pam->nCurrSyllable + 1].phoneV[E2]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[I1] + = pam->sSyllFeats[pam->nCurrSyllable + 1].phoneV[H1]; + pam->sSyllFeats[pam->nCurrSyllable].phoneV[I2] + = pam->sSyllFeats[pam->nCurrSyllable + 1].phoneV[H2]; + } else { + /*last syllable*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[C3] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[F2] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[I1] + = pam->sSyllFeats[pam->nCurrSyllable].phoneV[I2] + = 0; + } + + /*Other fixed values derived from de-facto standard*/ + pam->sSyllFeats[pam->nCurrSyllable].phoneV[B18] = 0; + + return PICO_OK; +}/*pam_do_pause*/ + +/** + * performs the initialization of pause "syllables" + * @param this : pointer to PAM PU sub object pointer : processes a pause (silence) syllable after backward processing + * @return PICO_OK : pause processing successful + * @return PICO_ERR_OTHER : errors on retrieving the PU pointer + * @callgraph + * @callergraph + */ +static pico_status_t pam_adapter_do_pauses(register picodata_ProcessingUnit this) +{ + register pam_subobj_t * pam; + picoos_uint16 nSyll; + + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pam = (pam_subobj_t *) this->subObj; + + /*Do the pause processing*/ + nSyll = pam->nCurrSyllable; + while (pam->nCurrSyllable >= 0) { + if (pam->sSyllFeats[pam->nCurrSyllable].phoneV[P2] == 1) { + /*pause processing*/ + pam_do_pause(this); + } + pam->nCurrSyllable--; + }/*end while (pam->nCurrSyllable>=0)*/ + /*reset syllpointer to original value*/ + pam->nCurrSyllable = nSyll; + return PICOPAM_READY; +}/*pam_adapter_do_pauses*/ + +#ifdef __cplusplus +} +#endif + +/* picopam.c end */ |