cst_utterance *default_tokenization(cst_utterance *u)
{
const char *text,*token;
cst_tokenstream *fd;
cst_item *t;
cst_relation *r;
text = utt_input_text(u);
r = utt_relation_create(u,"Token");
fd = ts_open_string(text,
get_param_string(u->features,"text_whitespace",NULL),
get_param_string(u->features,"text_singlecharsymbols",NULL),
get_param_string(u->features,"text_prepunctuation",NULL),
get_param_string(u->features,"text_postpunctuation",NULL));
while(!ts_eof(fd))
{
token = ts_get(fd);
if (cst_strlen(token) > 0)
{
t = relation_append(r,NULL);
item_set_string(t,"name",token);
item_set_string(t,"whitespace",fd->whitespace);
item_set_string(t,"prepunctuation",fd->prepunctuation);
item_set_string(t,"punc",fd->postpunctuation);
item_set_int(t,"file_pos",fd->file_pos);
item_set_int(t,"line_number",fd->line_number);
}
}
ts_close(fd);
return u;
}
static void add_raw_data(cst_utterance *u, const char *raw_data,
cst_features *attributes)
{
/* Add all tokens in raw _data to u */
cst_tokenstream *ts;
cst_relation *r;
cst_item *t;
const char *token;
r = utt_relation_create(u,"Token");
ts =
ts_open_string(raw_data,
get_param_string(u->features,"text_whitespace",NULL),
get_param_string(u->features,"text_singlecharsymbols",NULL),
get_param_string(u->features,"text_prepunctuation",NULL),
get_param_string(u->features,"text_pospunctuation",NULL));
while (!(ts_eof(ts)))
{
t = relation_append(r,NULL);
feat_copy_into(item_feats(t),attributes);
token = ts_get(ts);
if (cst_strlen(token) > 0)
{
t = relation_append(r,NULL);
item_set_string(t,"name",token);
item_set_string(t,"whitespace",ts->whitespace);
item_set_string(t,"prepunctuation",ts->prepunctuation);
item_set_string(t,"punc",ts->postpunctuation);
}
}
}
cst_utterance *default_phrasing(cst_utterance *u)
{
cst_relation *r;
cst_item *w, *p, *lp=NULL;
const cst_val *v;
cst_cart *phrasing_cart;
r = utt_relation_create(u,"Phrase");
phrasing_cart = val_cart(feat_val(u->features,"phrasing_cart"));
for (p=NULL,w=relation_head(utt_relation(u,"Word")); w; w=item_next(w))
{
if (p == NULL)
{
p = relation_append(r,NULL);
lp = p;
#ifdef FLITE_PLUS_HTS_ENGINE
item_set_string(p,"name","BB");
#else
item_set_string(p,"name","B");
#endif /* FLITE_PLUS_HTS_ENGINE */
}
item_add_daughter(p,w);
v = cart_interpret(w,phrasing_cart);
if (cst_streq(val_string(v),"BB"))
p = NULL;
}
if (lp && item_prev(lp)) /* follow festival */
item_set_string(lp,"name","BB");
return u;
}
cst_utterance *default_pause_insertion(cst_utterance *u)
{
/* Add initial silences and silence at each phrase break */
const char *silence;
const cst_item *w;
cst_item *p, *s;
silence = val_string(feat_val(u->features,"silence"));
/* Insert initial silence */
s = relation_head(utt_relation(u,"Segment"));
if (s == NULL)
s = relation_append(utt_relation(u,"Segment"),NULL);
else
s = item_prepend(s,NULL);
item_set_string(s,"name",silence);
for (p=relation_head(utt_relation(u,"Phrase")); p; p=item_next(p))
{
for (w = item_last_daughter(p); w; w=item_prev(w))
{
s = path_to_item(w,"R:SylStructure.daughtern.daughtern.R:Segment");
if (s)
{
s = item_append(s,NULL);
item_set_string(s,"name",silence);
break;
}
}
}
return u;
}
static int bbb_relation_load(cst_relation *r,const char *filename)
{
const char *token;
cst_item *item;
cst_tokenstream *fd;
fd = ts_open(filename);
if (fd == 0)
return 0;
while (!ts_eof(fd))
{
token = ts_get(fd);
if (cst_streq(token,""))
continue;
item = relation_append(r,NULL);
item_set_string(item,"name",token);
item_set_string(item,"whitespace",fd->whitespace);
item_set_string(item,"prepunctuation",fd->prepunctuation);
item_set_string(item,"punc",fd->postpunctuation);
item_set_int(item,"file_pos",fd->file_pos);
item_set_int(item,"line_number",fd->line_number);
}
ts_close(fd);
return 1;
}
cst_utterance *cart_intonation(cst_utterance *u)
{
cst_cart *accents, *tones;
cst_item *s;
const cst_val *v;
if (feat_present(u->features,"no_intonation_accent_model"))
return u; /* not all languages have intonation models */
accents = val_cart(feat_val(u->features,"int_cart_accents"));
tones = val_cart(feat_val(u->features,"int_cart_tones"));
for (s=relation_head(utt_relation(u,"Syllable")); s; s=item_next(s))
{
v = cart_interpret(s,accents);
if (!cst_streq("NONE",val_string(v)))
item_set_string(s,"accent",val_string(v));
v = cart_interpret(s,tones);
if (!cst_streq("NONE",val_string(v)))
item_set_string(s,"endtone",val_string(v));
DPRINTF(0,("word %s gpos %s stress %s ssyl_in %s ssyl_out %s accent %s endtone %s\n",
ffeature_string(s,"R:SylStructure.parent.name"),
ffeature_string(s,"R:SylStructure.parent.gpos"),
ffeature_string(s,"stress"),
ffeature_string(s,"ssyl_in"),
ffeature_string(s,"ssyl_out"),
ffeature_string(s,"accent"),
ffeature_string(s,"endtone")));
}
return u;
}
void test_hrg(void)
{
cst_utterance *u;
cst_relation *r;
cst_item *item = 0;
int i;
u = new_utterance();
r = utt_relation_create(u, "Segment");
for (i = 0; i < 10; i++)
{
char buff[20];
sprintf(buff, "seg_%03d", i);
if (i == 0)
item = relation_append(r, NULL);
else
item = item_append(item, NULL);
item_set_string(item, "name", buff);
item_set_float(item, "duration", i * 0.20);
}
for (i = 0, item = relation_head(utt_relation(u, "Segment"));
item; item = item_next(item), i++)
{
TEST_CHECK(item_feat_float(item, "duration") == correct_list[i]);
}
delete_utterance(u);
}
int main(int argc, char **argv)
{
cst_utterance *u;
cst_relation *r;
cst_item *item=0;
int i;
u = new_utterance();
r = utt_relation_create(u,"Segment");
for (i=0; i<10; i++)
{
char buff[20];
sprintf(buff,"seg_%03d",i);
if (i==0)
item = relation_append(r,NULL);
else
item = item_append(item,NULL);
item_set_string(item,"name",buff);
item_set_float(item,"duration",i*0.20);
}
for (i=0,item=relation_head(utt_relation(u,"Segment"));
item; item=item_next(item),i++)
{
printf("Segment %d %s %f\n",
i,
item_feat_string(item,"name"),
item_feat_float(item,"duration"));
}
delete_utterance(u);
return 0;
}
cst_utterance *default_phrasing(cst_utterance *u)
{
cst_relation *r;
cst_item *w, *p;
const cst_val *v;
cst_cart *phrasing_cart;
r = utt_relation_create(u,"Phrase");
phrasing_cart = val_cart(feat_val(u->features,"phrasing_cart"));
for (p=NULL,w=relation_head(utt_relation(u,"Word")); w; w=item_next(w))
{
if (p == NULL)
{
p = relation_append(r,NULL);
item_set_string(p,"name","BB");
}
item_add_daughter(p,w);
v = cart_interpret(w,phrasing_cart);
if (cst_streq(val_string(v),"BB"))
p = NULL;
}
return u;
}
static cst_utterance *cg_make_hmmstates(cst_utterance *utt)
{
/* Build HMM state structure below the segment structure */
cst_cg_db *cg_db;
cst_relation *hmmstate, *segstate;
cst_item *seg, *s, *ss;
const char *segname;
int sp,p;
cg_db = val_cg_db(utt_feat_val(utt,"cg_db"));
hmmstate = utt_relation_create(utt,"HMMstate");
segstate = utt_relation_create(utt,"segstate");
for (seg = utt_rel_head(utt,"Segment"); seg; seg=item_next(seg))
{
ss = relation_append(segstate,seg);
segname = item_feat_string(seg,"name");
for (p=0; cg_db->phone_states[p]; p++)
if (cst_streq(segname,cg_db->phone_states[p][0]))
break;
if (cg_db->phone_states[p] == NULL)
p = 0; /* unknown phoneme */
for (sp=1; cg_db->phone_states[p][sp]; sp++)
{
s = relation_append(hmmstate,NULL);
item_add_daughter(ss,s);
item_set_string(s,"name",cg_db->phone_states[p][sp]);
item_set_int(s,"statepos",sp);
}
}
return utt;
}
cst_utterance *russian_postlex_function(cst_utterance *u)
{
const cst_item *word,*seg;
const char *answer,*name,*pair;
for(word=relation_head(utt_relation(u,"Transcription"));word;word=item_next(word))
{
if(item_feat_present(word,"no_pl")||item_feat_present(word,"no_vr"))
continue;
for(seg=item_daughter(word);seg;seg=item_next(seg))
{
name=item_feat_string(seg,"name");
if(cst_member_string(name,unstressed_vowels))
{
answer=val_string(cart_interpret(item_as(seg,"Segment"),&ru_vowel_reduction_cart));
if(!cst_streq(answer,"N"))
item_set_string(seg,"name",answer);
}
else
{
if(cst_streq(name,"ii")&&
cst_streq(ffeature_string(seg,"R:Segment.p.ph_csoft"),"-")&&
!(cst_streq(item_feat_string(word,"name"),"и")&&
cst_streq(ffeature_string(word,"gpos"),"content")))
{
item_set_string(seg,"name","yy");
}
}
}
}
for(word=relation_tail(utt_relation(u,"Transcription"));word;word=item_prev(word))
{
if(item_feat_present(word,"no_pl"))
continue;
for(seg=item_last_daughter(word);seg;seg=item_prev(seg))
{
name=item_feat_string(seg,"name");
pair=russian_vpair(name);
if(pair!=NULL)
{
answer=val_string(cart_interpret(item_as(seg,"Segment"),&ru_vpair_cart));
if(cst_streq(answer,"Y"))
item_set_string(seg,"name",pair);
}
}
}
return u;
}
int relation_load(cst_relation *r, const char *filename)
{
cst_tokenstream *fd;
cst_item *item;
const char *token=0;
if ((fd = ts_open(filename,NULL,";","","")) == 0)
{
cst_errmsg("relation_load: can't open file \"%s\" for reading\n",
filename);
return CST_ERROR_FORMAT;
}
for ( ; !ts_eof(fd); )
{
token = ts_get(fd);
if (cst_streq("#",token))
break;
}
#import "OpenEarsStaticAnalysisToggle.h"
#ifdef STATICANALYZEDEPENDENCIES
#define __clang_analyzer__ 1
#endif
#if !defined(__clang_analyzer__) || defined(STATICANALYZEDEPENDENCIES)
#undef __clang_analyzer__
if (!cst_streq("#",token))
#endif
{
cst_errmsg("relation_load: no end of header marker in \"%s\"\n",
filename);
ts_close(fd);
return CST_ERROR_FORMAT;
}
while (!ts_eof(fd))
{
token = ts_get(fd);
if (cst_streq(token,""))
continue;
item = relation_append(r,NULL);
item_set_float(item,"end",(float)cst_atof(token));
#import "OpenEarsStaticAnalysisToggle.h"
#ifdef STATICANALYZEDEPENDENCIES
#define __clang_analyzer__ 1
#endif
#if !defined(__clang_analyzer__) || defined(STATICANALYZEDEPENDENCIES)
#undef __clang_analyzer__
token = ts_get(fd);
#endif
token = ts_get(fd);
item_set_string(item,"name",token);
}
ts_close(fd);
return CST_OK_FORMAT;
}
static void fix_ah(cst_utterance *u)
{
/* This should really be done in the index itself */
const cst_item *s;
for (s=relation_head(utt_relation(u,"Segment")); s; s=item_next(s))
if (cst_streq(item_feat_string(s,"name"),"ah"))
item_set_string(s,"name","aa");
}
static void apostrophe_s(cst_utterance *u)
{
cst_item *s;
cst_item *schwa;
const cst_phoneset *ps = u->vox->phoneset;
const char *pname, *word;
for (s=item_next(UTT_REL_HEAD(u,SEGMENT));
s;
s=item_next(s))
{
word = val_string(ffeature(s, "R:"SYLSTRUCTURE".P.P.name"));
if (cst_streq("'s", word))
{
pname = item_feat_string(item_prev(s),"name");
if ((strchr("fa",*phone_feature_string(ps,pname,"ctype")) != NULL)
&& (strchr("dbg",
*phone_feature_string(ps,pname,"cplace")) == NULL))
/* needs a schwa */
{
schwa = item_prepend(s,NULL);
item_set_string(schwa,"name","ax");
item_prepend(item_as(s,SYLSTRUCTURE),schwa);
}
else if (cst_streq("-",phone_feature_string(ps,pname,"cvox")))
item_set_string(s,"name","s");
}
else if (cst_streq("'ve", word)
|| cst_streq("'ll", word)
|| cst_streq("'d", word))
{
if (cst_streq("-",ffeature_string(s,"p."PH_VC)))
{
schwa = item_prepend(s,NULL);
item_set_string(schwa,"name","ax");
item_prepend(item_as(s,SYLSTRUCTURE),schwa);
}
}
}
}
int relation_load(cst_relation *r, const char *filename)
{
cst_tokenstream *fd;
cst_item *item;
const char *token=0;
if ((fd = ts_open(filename,NULL,";","","")) == 0)
{
cst_errmsg("relation_load: can't open file \"%s\" for reading\n",
filename);
return CST_ERROR_FORMAT;
}
for ( ; !ts_eof(fd); )
{
token = ts_get(fd);
if (cst_streq("#",token))
break;
}
if (!cst_streq("#",token))
{
cst_errmsg("relation_load: no end of header marker in \"%s\"\n",
filename);
ts_close(fd);
return CST_ERROR_FORMAT;
}
while (!ts_eof(fd))
{
token = ts_get(fd);
if (cst_streq(token,""))
continue;
item = relation_append(r,NULL);
item_set_float(item,"end",(float)cst_atof(token));
token = ts_get(fd);
token = ts_get(fd);
item_set_string(item,"name",token);
}
ts_close(fd);
return CST_OK_FORMAT;
}
cst_utterance *default_textanalysis(cst_utterance *u)
{
cst_item *t,*word;
cst_relation *word_rel;
cst_val *words;
const cst_val *w;
const cst_val *ttwv;
word_rel = utt_relation_create(u,"Word");
ttwv = feat_val(u->features, "tokentowords_func");
for (t=relation_head(utt_relation(u,"Token")); t; t=item_next(t))
{
if (ttwv)
words = (cst_val *)(*val_itemfunc(ttwv))(t);
else
words = default_tokentowords(t);
for (w=words; w; w=val_cdr(w))
{
word = item_add_daughter(t,NULL);
if (cst_val_consp(val_car(w)))
{ /* Has extra features */
item_set_string(word,"name",val_string(val_car(val_car(w))));
feat_copy_into(val_features(val_cdr(val_car(w))),
item_feats(word));
}
else
item_set_string(word,"name",val_string(val_car(w)));
relation_append(word_rel,word);
}
delete_val(words);
}
return u;
}
static void the_iy_ax(cst_utterance *u)
{
const cst_item *i;
const char *word;
for (i = UTT_REL_HEAD(u, SEGMENT); i; i = item_next(i))
{
if (cst_streq("ax", ITEM_NAME(i)))
{
word = ffeature_string(i,"R:"SYLSTRUCTURE".P.P.name");
if (cst_streq("the", word)
&& cst_streq("+", ffeature_string(i,"n."PH_VC)))
item_set_string(i, "name", "iy");
}
}
}
cst_utterance *default_pos_tagger(cst_utterance *u)
{
cst_item *word;
const cst_val *p;
const cst_cart *tagger;
p = get_param_val(u->features,"pos_tagger_cart",NULL);
if (p == NULL)
return u;
tagger = val_cart(p);
for (word=relation_head(utt_relation(u,"Word"));
word; word=item_next(word))
{
p = cart_interpret(word,tagger);
item_set_string(word,"pos",val_string(p));
}
return u;
}
/**********************************
Show tiles types
**********************************/
static void compose_type(context_t * ctx,int layer_index)
{
int x = 0;
int y = 0;
item_t * item;
char * type;
static TTF_Font * font = NULL;
int w;
int h;
char layer_name[SMALL_BUF];
if( option->show_tile_type == false) {
return;
}
sprintf(layer_name,"%s%d",MAP_KEY_LAYER,layer_index);
if( entry_exist(MAP_TABLE, ctx->map, layer_name,MAP_KEY_TYPE,NULL) == false ) {
return;
}
font = font_get(ctx,ITEM_FONT, ITEM_FONT_SIZE);
for( x=0; x<default_layer->map_w; x++) {
for( y=0; y<default_layer->map_h; y++) {
if(entry_read_list_index(MAP_TABLE,ctx->map,&type,x + y * default_layer->map_w,layer_name,MAP_KEY_TYPE,NULL) == RET_NOK ) {
continue;
}
if( type[0] == 0 ) {
continue;
}
item = item_list_add(&item_list);
item_set_string(item,type);
item_set_font(item,font);
sdl_get_string_size(item->font,item->string,&w,&h);
item_set_anim_shape(item,map_t2p_x(x,y,default_layer),map_t2p_y(x,y,default_layer),w,h);
}
}
}
static void display_fps()
{
static Uint32 timer = 0;
Uint32 new_timer;
static char fps[64];
double sample;
option_t * option;
static int num_frame = 0;
if( frame_rate ) {
option = option_get();
if( option->show_fps ) {
num_frame++;
new_timer = SDL_GetTicks();
if( timer + 1000 < new_timer ) {
sample = (double)num_frame / ((double)new_timer - (double)timer ) * 1000.0;
num_frame = 0;
timer = new_timer;
sprintf(fps,"%f",sample);
}
item_set_string(frame_rate,fps);
}
}
}
float flite_file_to_speech(const char *filename,
cst_voice *voice,
const char *outtype)
{
cst_utterance *utt;
cst_tokenstream *ts;
const char *token;
cst_item *t;
cst_relation *tokrel;
float durs = 0;
int num_tokens;
cst_wave *w;
cst_breakfunc breakfunc = default_utt_break;
cst_uttfunc utt_user_callback = 0;
int fp;
if ((ts = ts_open(filename,
get_param_string(voice->features,"text_whitespace",NULL),
get_param_string(voice->features,"text_singlecharsymbols",NULL),
get_param_string(voice->features,"text_prepunctuation",NULL),
get_param_string(voice->features,"text_postpunctuation",NULL)))
== NULL)
{
cst_errmsg("failed to open file \"%s\" for reading\n",
filename);
return 1;
}
fp = get_param_int(voice->features,"file_start_position",0);
if (fp > 0)
ts_set_stream_pos(ts,fp);
if (feat_present(voice->features,"utt_break"))
breakfunc = val_breakfunc(feat_val(voice->features,"utt_break"));
if (feat_present(voice->features,"utt_user_callback"))
utt_user_callback = val_uttfunc(feat_val(voice->features,"utt_user_callback"));
/* If its a file to write to, create and save an empty wave file */
/* as we are going to incrementally append to it */
if (!cst_streq(outtype,"play") &&
!cst_streq(outtype,"none") &&
!cst_streq(outtype,"stream"))
{
w = new_wave();
cst_wave_resize(w,0,1);
cst_wave_set_sample_rate(w,16000);
cst_wave_save_riff(w,outtype); /* an empty wave */
delete_wave(w);
}
num_tokens = 0;
utt = new_utterance();
tokrel = utt_relation_create(utt, "Token");
while (!ts_eof(ts) || num_tokens > 0)
{
token = ts_get(ts);
if ((cst_strlen(token) == 0) ||
(num_tokens > 500) || /* need an upper bound */
(relation_head(tokrel) &&
breakfunc(ts,token,tokrel)))
{
/* An end of utt, so synthesize it */
if (utt_user_callback)
utt = (utt_user_callback)(utt);
if (utt)
{
utt = flite_do_synth(utt,voice,utt_synth_tokens);
durs += flite_process_output(utt,outtype,TRUE);
delete_utterance(utt); utt = NULL;
}
else
break;
if (ts_eof(ts)) break;
utt = new_utterance();
tokrel = utt_relation_create(utt, "Token");
num_tokens = 0;
}
num_tokens++;
t = relation_append(tokrel, NULL);
item_set_string(t,"name",token);
item_set_string(t,"whitespace",ts->whitespace);
item_set_string(t,"prepunctuation",ts->prepunctuation);
item_set_string(t,"punc",ts->postpunctuation);
/* Mark it at the beginning of the token */
item_set_int(t,"file_pos",
ts->file_pos-(1+ /* as we are already on the next char */
cst_strlen(token)+
cst_strlen(ts->prepunctuation)+
cst_strlen(ts->postpunctuation)));
item_set_int(t,"line_number",ts->line_number);
}
delete_utterance(utt);
ts_close(ts);
return durs;
}
static cst_utterance *tokentosegs(cst_utterance *u)
{
cst_item *t;
cst_relation *seg, *syl, *sylstructure, *word;
cst_item *sylitem, *sylstructureitem, *worditem, *sssyl;
cst_phoneset *ps;
ps = val_phoneset(utt_feat_val(u, "phoneset"));
/* Just copy tokens into the Segment relation */
seg = utt_relation_create(u, "Segment");
syl = utt_relation_create(u, "Syllable");
word = utt_relation_create(u, "Word");
sylstructure = utt_relation_create(u, "SylStructure");
sssyl = sylitem = worditem = sylstructureitem = 0;
for (t = relation_head(utt_relation(u, "Token")); t; t = item_next(t))
{
cst_item *segitem = relation_append(seg, NULL);
char const *pname = item_feat_string(t, "name");
char *name = cst_strdup(pname);
if (worditem == 0)
{
worditem = relation_append(word,NULL);
item_set_string(worditem, "name", "phonestring");
sylstructureitem = relation_append(sylstructure,worditem);
}
if (sylitem == 0)
{
sylitem = relation_append(syl,NULL);
sssyl = item_add_daughter(sylstructureitem,sylitem);
}
if (name[cst_strlen(name)-1] == '1')
{
item_set_string(sssyl,"stress","1");
name[cst_strlen(name)-1] = '\0';
}
else if (name[cst_strlen(name)-1] == '0')
{
item_set_string(sssyl,"stress","0");
name[cst_strlen(name)-1] = '\0';
}
if (cst_streq(name,"-"))
{
sylitem = 0; /* syllable break */
}
else if (phone_id(ps, name) == -1)
{
cst_errmsg("Phone `%s' not in phoneset\n", pname);
cst_error();
}
else
{
item_add_daughter(sssyl,segitem);
item_set_string(segitem, "name", name);
}
cst_free(name);
}
return u;
}
cst_utterance *russian_lexical_insertion(cst_utterance *u)
{
cst_item *word;
cst_relation *sylstructure,*seg,*syl,*sylvowel,*transcription;
const cst_val *p;
const char *phone_name;
cst_val *phones;
cst_item *ssword, *sssyl, *segitem, *sylitem, *seg_in_syl, *svsyl, *vowel_in_syl, *tword, *seg_in_word;
cst_item *i,*tmp;
int num_segs;
int total_num_segs=0;
syl = utt_relation_create(u,"Syllable");
sylstructure = utt_relation_create(u,"SylStructure");
seg = utt_relation_create(u,"Segment");
sylvowel = utt_relation_create(u,"SylVowel");
transcription = utt_relation_create(u,"Transcription");
for (word=relation_head(utt_relation(u,"Word"));word;word=item_next(word))
{
phones=word_to_phones(word);
if(!phones)
continue;
num_segs=val_length(phones);
if((total_num_segs+num_segs)>max_num_segs)
{
delete_val(phones);
break;
}
ssword = relation_append(sylstructure,word);
tword = relation_append(transcription,word);
for (sssyl=NULL,sylitem=NULL,p=phones; p; p=val_cdr(p))
{
if (sylitem == NULL)
{
sylitem = relation_append(syl,NULL);
sssyl = item_add_daughter(ssword,sylitem);
}
segitem = relation_append(seg,NULL);
phone_name = val_string(val_car(p));
item_set_string(segitem,"name",phone_name);
seg_in_syl = item_add_daughter(sssyl,segitem);
seg_in_word = item_add_daughter(tword,segitem);
if(is_vowel(phone_name))
{
svsyl=relation_append(sylvowel,sylitem);
vowel_in_syl=item_add_daughter(svsyl,segitem);
}
if (ru_syl_boundary(seg_in_syl,val_cdr(p)))
{
sylitem = NULL;
if (sssyl)
item_set_string(sssyl,"stress","0");
}
}
assign_stress(word);
delete_val(phones);
total_num_segs+=num_segs;
}
i=relation_head(utt_relation(u,"Word"));
while(i)
{
tmp=item_next(i);
if(item_as(i,"Transcription")==NULL)
{
delete_item(item_as(i,"Token"));
delete_item(item_as(i,"Phrase"));
delete_item(i);
}
i=tmp;
}
i=relation_head(utt_relation(u,"Phrase"));
while(i)
{
tmp=item_next(i);
if(item_daughter(i)==NULL)
delete_item(i);
i=tmp;
}
return u;
}
/**********************************
Compose item on map
**********************************/
static void compose_item(context_t * ctx,int layer_index)
{
char * sprite_name = NULL;
int sprite_align = ALIGN_CENTER;
int sprite_offset_y = 0;
anim_t * anim;
item_t * item;
int x;
int y;
int temp_x;
int temp_y;
char ** item_id;
int i;
static TTF_Font * font = NULL;
char * mytemplate;
int quantity;
char buf[SMALL_BUF];
char layer_name[SMALL_BUF];
sprintf(layer_name,"%s%d",MAP_KEY_LAYER,layer_index);
if(entry_get_group_list(MAP_TABLE,ctx->map,&item_id,layer_name,MAP_ENTRY_ITEM_LIST,NULL) == RET_NOK ) {
return;
}
font = font_get(ctx,ITEM_FONT, ITEM_FONT_SIZE);
i=0;
while( item_id[i] != NULL ) {
sprite_align = ALIGN_CENTER;
if(entry_read_int(MAP_TABLE,ctx->map,&x,layer_name,MAP_ENTRY_ITEM_LIST,item_id[i],MAP_ITEM_POS_X,NULL) == RET_NOK ) {
i++;
continue;
}
if(entry_read_int(MAP_TABLE,ctx->map,&y,layer_name,MAP_ENTRY_ITEM_LIST,item_id[i],MAP_ITEM_POS_Y,NULL) == RET_NOK ) {
i++;
continue;
}
mytemplate = item_is_resource(item_id[i]);
if ( mytemplate == NULL ) {
if(entry_read_string(ITEM_TABLE,item_id[i],&sprite_name,ITEM_SPRITE,NULL) == RET_NOK ) {
i++;
continue;
}
entry_read_int(ITEM_TABLE,item_id[i],&sprite_align,ITEM_ALIGN,NULL);
entry_read_int(ITEM_TABLE,item_id[i],&sprite_offset_y,ITEM_OFFSET_Y,NULL);
} else {
if(entry_read_string(ITEM_TEMPLATE_TABLE,mytemplate,&sprite_name,ITEM_SPRITE,NULL) == RET_NOK ) {
free(mytemplate);
i++;
continue;
}
entry_read_int(ITEM_TEMPLATE_TABLE,mytemplate,&sprite_align,ITEM_ALIGN,NULL);
entry_read_int(ITEM_TEMPLATE_TABLE,mytemplate,&sprite_offset_y,ITEM_OFFSET_Y,NULL);
free(mytemplate);
}
item = item_list_add(&item_list);
anim = imageDB_get_anim(ctx,sprite_name);
free(sprite_name);
temp_x = map_t2p_x(x,y,default_layer);
temp_y = map_t2p_y(x,y,default_layer);
x = temp_x;
y = temp_y;
/* Align on tile */
if( sprite_align == ALIGN_CENTER ) {
x -= ((anim->w*default_layer->map_zoom)-default_layer->tile_width)/2;
y -= ((anim->h*default_layer->map_zoom)-default_layer->tile_height)/2;
}
if( sprite_align == ALIGN_LOWER ) {
x -= ((anim->w*default_layer->map_zoom)-default_layer->tile_width)/2;
y -= (anim->h*default_layer->map_zoom)-default_layer->tile_height;
}
y += sprite_offset_y;
item_set_pos(item,x,y);
item_set_anim(item,anim,0);
item_set_zoom_x(item, default_layer->map_zoom );
item_set_zoom_y(item, default_layer->map_zoom );
if(font) {
quantity = resource_get_quantity(item_id[i]);
sprintf(buf,"%d",quantity);
item_set_string(item,buf);
item_set_font(item,font);
}
i++;
}
deep_free(item_id);
}
float flite_file_to_speech(const char *filename,
cst_voice *voice,
const char *outtype)
{
cst_utterance *utt;
cst_tokenstream *ts;
const char *token;
cst_item *t;
cst_relation *tokrel;
float d, durs = 0;
int num_tokens;
cst_breakfunc breakfunc = default_utt_break;
if ((ts = ts_open(filename,
get_param_string(voice->features,"text_whitespace",NULL),
get_param_string(voice->features,"text_singlecharsymbols",NULL),
get_param_string(voice->features,"text_prepunctuation",NULL),
get_param_string(voice->features,"text_postpunctuation",NULL)))
== NULL)
{
cst_errmsg("failed to open file \"%s\" for reading\n",
filename);
return 1;
}
if (feat_present(voice->features,"utt_break"))
breakfunc = val_breakfunc(feat_val(voice->features,"utt_break"));
/* If its a file to write to delete it as we're going to */
/* incrementally append to it */
if (!cst_streq(outtype,"play") && !cst_streq(outtype,"none"))
{
cst_wave *w;
w = new_wave();
cst_wave_resize(w,0,1);
cst_wave_set_sample_rate(w,16000);
cst_wave_save_riff(w,outtype); /* an empty wave */
delete_wave(w);
}
num_tokens = 0;
utt = new_utterance();
tokrel = utt_relation_create(utt, "Token");
while (!ts_eof(ts) || num_tokens > 0)
{
token = ts_get(ts);
if ((strlen(token) == 0) ||
(num_tokens > 500) || /* need an upper bound */
(relation_head(tokrel) &&
breakfunc(ts,token,tokrel)))
{
/* An end of utt */
d = flite_tokens_to_speech(utt,voice,outtype);
utt = NULL;
if (d < 0)
goto out;
durs += d;
if (ts_eof(ts))
goto out;
utt = new_utterance();
tokrel = utt_relation_create(utt, "Token");
num_tokens = 0;
}
num_tokens++;
t = relation_append(tokrel, NULL);
item_set_string(t,"name",token);
item_set_string(t,"whitespace",ts->whitespace);
item_set_string(t,"prepunctuation",ts->prepunctuation);
item_set_string(t,"punc",ts->postpunctuation);
item_set_int(t,"file_pos",ts->file_pos);
item_set_int(t,"line_number",ts->line_number);
}
out:
delete_utterance(utt);
ts_close(ts);
return durs;
}
static float flite_ssml_to_speech_ts(cst_tokenstream *ts,
cst_voice *voice,
const char *outtype)
{
cst_features *ssml_feats, *ssml_word_feats;
cst_features *attributes;
const char *token;
char *tag;
cst_utterance *utt;
cst_relation *tokrel;
int num_tokens;
cst_breakfunc breakfunc = default_utt_break;
cst_uttfunc utt_user_callback = 0;
float durs = 0.0;
cst_item *t;
ssml_feats = new_features();
ssml_word_feats = new_features();
set_charclasses(ts,
" \t\n\r",
ssml_singlecharsymbols_general,
get_param_string(voice->features,"text_prepunctuation",""),
get_param_string(voice->features,"text_postpunctuation","")
);
if (feat_present(voice->features,"utt_break"))
breakfunc = val_breakfunc(feat_val(voice->features,"utt_break"));
if (feat_present(voice->features,"utt_user_callback"))
utt_user_callback = val_uttfunc(feat_val(voice->features,"utt_user_callback"));
num_tokens = 0;
utt = new_utterance();
tokrel = utt_relation_create(utt, "Token");
while (!ts_eof(ts) || num_tokens > 0)
{
token = ts_get(ts);
if (cst_streq("<",token))
{ /* A tag */
tag = cst_upcase(ts_get(ts));
if (cst_streq("/",tag)) /* an end tag */
{
tag = cst_upcase(ts_get(ts));
attributes = ssml_get_attributes(ts);
feat_set_string(attributes,"_type","end");
}
else
attributes = ssml_get_attributes(ts);
utt = ssml_apply_tag(tag,attributes,utt,ssml_word_feats);
cst_free(tag);
}
else if (cst_streq("&",token))
{ /* an escape sequence */
/* skip to ; and insert value in rawdata */
}
else
{
if ((cst_strlen(token) == 0) ||
(num_tokens > 500) || /* need an upper bound */
(relation_head(tokrel) &&
breakfunc(ts,token,tokrel)))
{
/* An end of utt, so synthesize it */
if (utt_user_callback)
utt = (utt_user_callback)(utt);
if (utt)
{
utt = flite_do_synth(utt,voice,utt_synth_tokens);
durs += flite_process_output(utt,outtype,TRUE);
delete_utterance(utt); utt = NULL;
}
else
break;
if (ts_eof(ts)) break;
utt = new_utterance();
tokrel = utt_relation_create(utt, "Token");
num_tokens = 0;
}
num_tokens++;
t = relation_append(tokrel, NULL);
item_set_string(t,"name",token);
item_set_string(t,"whitespace",ts->whitespace);
item_set_string(t,"prepunctuation",ts->prepunctuation);
item_set_string(t,"punc",ts->postpunctuation);
/* Mark it at the beginning of the token */
item_set_int(t,"file_pos",
ts->file_pos-(1+ /* as we are already on the next char */
cst_strlen(token)+
cst_strlen(ts->prepunctuation)+
cst_strlen(ts->postpunctuation)));
item_set_int(t,"line_number",ts->line_number);
}
}
delete_utterance(utt);
return durs;
}
cst_utterance *default_lexical_insertion(cst_utterance *u)
{
cst_item *word;
cst_relation *sylstructure,*seg,*syl;
cst_lexicon *lex;
const cst_val *lex_addenda = NULL;
const cst_val *p, *wp = NULL;
char *phone_name;
char *stress = "0";
const char *pos;
cst_val *phones;
cst_item *ssword, *sssyl, *segitem, *sylitem, *seg_in_syl;
lex = val_lexicon(feat_val(u->features,"lexicon"));
if (lex->lex_addenda)
lex_addenda = lex->lex_addenda;
syl = utt_relation_create(u,"Syllable");
sylstructure = utt_relation_create(u,"SylStructure");
seg = utt_relation_create(u,"Segment");
for (word=relation_head(utt_relation(u,"Word"));
word; word=item_next(word))
{
ssword = relation_append(sylstructure,word);
pos = ffeature_string(word,"pos");
phones = NULL;
wp = NULL;
/* printf("awb_debug word %s pos %s gpos %s\n",
item_feat_string(word,"name"),
pos,
ffeature_string(word,"gpos")); */
/* FIXME: need to make sure that textanalysis won't split
tokens with explicit pronunciation (or that it will
propagate such to words, then we can remove the path here) */
if (item_feat_present(item_parent(item_as(word, "Token")), "phones"))
phones = (cst_val *) item_feat(item_parent(item_as(word, "Token")), "phones");
else
{
wp = val_assoc_string(item_feat_string(word, "name"),lex_addenda);
if (wp)
phones = (cst_val *)val_cdr(val_cdr(wp));
else
phones = lex_lookup(lex,item_feat_string(word,"name"),pos);
}
for (sssyl=NULL,sylitem=NULL,p=phones; p; p=val_cdr(p))
{
if (sylitem == NULL)
{
sylitem = relation_append(syl,NULL);
sssyl = item_add_daughter(ssword,sylitem);
stress = "0";
}
segitem = relation_append(seg,NULL);
phone_name = cst_strdup(val_string(val_car(p)));
if (phone_name[cst_strlen(phone_name)-1] == '1')
{
stress = "1";
phone_name[cst_strlen(phone_name)-1] = '\0';
}
else if (phone_name[cst_strlen(phone_name)-1] == '0')
{
stress = "0";
phone_name[cst_strlen(phone_name)-1] = '\0';
}
item_set_string(segitem,"name",phone_name);
seg_in_syl = item_add_daughter(sssyl,segitem);
#if 0
printf("awb_debug ph %s\n",phone_name);
#endif
if ((lex->syl_boundary)(seg_in_syl,val_cdr(p)))
{
#if 0
printf("awb_debug SYL\n");
#endif
sylitem = NULL;
if (sssyl)
item_set_string(sssyl,"stress",stress);
}
cst_free(phone_name);
}
if (!item_feat_present(item_parent(item_as(word, "Token")), "phones")
&& ! wp)
delete_val(phones);
}
return u;
}
cst_utterance *default_lexical_insertion(cst_utterance *u)
{
cst_item *word;
cst_relation *sylstructure,*seg,*syl;
cst_lexicon *lex, *ulex = NULL;
const cst_val *p;
char *phone_name;
char *stress = "0";
cst_val *phones;
cst_item *ssword, *sssyl, *segitem, *sylitem, *seg_in_syl;
lex = val_lexicon(feat_val(u->features,"lexicon"));
if (feat_present(u->features, "user_lexicon"))
ulex = val_lexicon(feat_val(u->features, "user_lexicon"));
syl = utt_relation_create(u,"Syllable");
sylstructure = utt_relation_create(u,"SylStructure");
seg = utt_relation_create(u,"Segment");
for (word=relation_head(utt_relation(u,"Word"));
word; word=item_next(word))
{
ssword = relation_append(sylstructure,word);
phones = NULL;
/* FIXME: need to make sure that textanalysis won't split
tokens with explicit pronunciation (or that it will
propagate such to words, then we can remove the path here) */
if (item_feat_present(item_parent(item_as(word, "Token")), "phones"))
phones = (cst_val *) item_feat(item_parent(item_as(word, "Token")), "phones");
else
{
if (ulex)
phones = lex_lookup(ulex,item_feat_string(word, "name"),0);
if (phones == NULL)
phones = lex_lookup(lex,item_feat_string(word,"name"),0);
}
for (sssyl=NULL,sylitem=NULL,p=phones; p; p=val_cdr(p))
{
if (sylitem == NULL)
{
sylitem = relation_append(syl,NULL);
sssyl = item_add_daughter(ssword,sylitem);
stress = "0";
}
segitem = relation_append(seg,NULL);
phone_name = cst_strdup(val_string(val_car(p)));
if (phone_name[strlen(phone_name)-1] == '1')
{
stress = "1";
phone_name[strlen(phone_name)-1] = '\0';
}
else if (phone_name[strlen(phone_name)-1] == '0')
{
stress = "0";
phone_name[strlen(phone_name)-1] = '\0';
}
item_set_string(segitem,"name",phone_name);
seg_in_syl = item_add_daughter(sssyl,segitem);
if ((lex->syl_boundary)(seg_in_syl,val_cdr(p)))
{
sylitem = NULL;
if (sssyl)
item_set_string(sssyl,"stress",stress);
}
cst_free(phone_name);
}
if (!item_feat_present(item_parent(item_as(word, "Token")), "phones"))
delete_val(phones);
}
return u;
}
void screen_play(SDL_Renderer * render,game_t * game)
{
char gold_buf[128];
char mana_buf[128];
SDL_Event event;
int tile_num;
int unit_num;
int city_num;
int encounter_num;
int i;
int j;
int x;
LBXAnimation_t * anim_ptr;
city_t * city;
local_render = render;
end_screen = -1;
selected_group = NULL;
city = (city_t*)game->wiz[0].city->data;
cur_tile_x = city->x;
cur_tile_y = city->y;
load_font();
/* Load resource */
if(anim==NULL) {
anim = load_graphics(render,"MAIN.LBX");
if(anim == NULL) {
exit(EXIT_FAILURE);
}
}
/* Load tiles */
if(tile==NULL) {
tile = load_graphics(render,"TERRAIN.LBX");
if(tile == NULL) {
exit(EXIT_FAILURE);
}
}
/* Load unit */
if(unit1==NULL) {
unit1 = load_graphics(render,"UNITS1.LBX");
if(unit1 == NULL) {
exit(EXIT_FAILURE);
}
}
if(unit2==NULL) {
unit2 = load_graphics(render,"UNITS2.LBX");
if(unit2 == NULL) {
exit(EXIT_FAILURE);
}
}
/* Concat unit1 and unit2 */
if(unit==NULL) {
j=0;
anim_ptr = unit1;
for(i=0; i<2; i++) {
while(anim_ptr->num_frame!=0) {
unit = (LBXAnimation_t*)realloc(unit,(j+1)*sizeof(LBXAnimation_t));
memcpy(&unit[j],anim_ptr,sizeof(LBXAnimation_t));
anim_ptr++;
j++;
}
anim_ptr= unit2;
}
}
/* Load back */
if(back==NULL) {
back = load_graphics(render,"MAPBACK.LBX");
if(back == NULL) {
exit(EXIT_FAILURE);
}
}
j=0;
item_init(&item_ui[j]);
item_set_frame(&item_ui[j],0,0,&anim[j]);
j++;
x=7;
item_init(&item_ui[j]);
item_set_frame(&item_ui[j],x,4,&anim[j]);
item_set_frame_click(&item_ui[j],1);
j++;
x+=item_ui[j-1].anim->w + 1;
item_init(&item_ui[j]);
item_set_frame(&item_ui[j],x,4,&anim[j]);
item_set_frame_click(&item_ui[j],1);
j++;
x+=item_ui[j-1].anim->w + 1;
item_init(&item_ui[j]);
item_set_frame(&item_ui[j],x,4,&anim[j]);
item_set_frame_click(&item_ui[j],1);
j++;
x+=item_ui[j-1].anim->w + 1;
item_init(&item_ui[j]);
item_set_frame(&item_ui[j],x,4,&anim[j]);
item_set_frame_click(&item_ui[j],1);
j++;
x+=item_ui[j-1].anim->w + 1;
item_init(&item_ui[j]);
item_set_frame(&item_ui[j],x,4,&anim[j]);
item_set_frame_click(&item_ui[j],1);
j++;
x+=item_ui[j-1].anim->w + 1;
item_init(&item_ui[j]);
item_set_frame(&item_ui[j],x,4,&anim[j]);
item_set_frame_click(&item_ui[j],1);
j++;
x+=item_ui[j-1].anim->w + 1;
item_init(&item_ui[j]);
item_set_frame(&item_ui[j],x,4,&anim[j]);
item_set_frame_click(&item_ui[j],1);
item_set_click_left(&item_ui[j],cb_plane,NULL);
j++;
/* Main loop */
while( end_screen == -1) {
tile_num = draw_tile(game);
city_num = draw_city(game);
encounter_num = draw_encounter(game);
unit_num = draw_unit(game);
/* Print gold */
item_init(&item_ui[8]);
item_set_font(&item_ui[8],font);
sprintf(gold_buf,"%d GP",game->wiz[0].gold);
item_set_string(&item_ui[8],gold_buf);
item_set_frame(&item_ui[8],264,71,NULL);
/* Print mana */
item_init(&item_ui[9]);
item_set_font(&item_ui[9],font);
sprintf(mana_buf,"%d MP",game->wiz[0].mana);
item_set_string(&item_ui[9],mana_buf);
item_set_frame(&item_ui[9],300,71,NULL);
while (SDL_PollEvent(&event)) {
if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_ESCAPE) {
return;
}
/* Move selected_unit */
if(event.type==SDL_KEYDOWN ) {
move_unit(game,event.key.keysym.sym);
}
sdl_screen_manager(&event);
sdl_mouse_manager(&event,item_ui,ITM_UI_NUM);
sdl_mouse_manager(&event,item_city,city_num);
sdl_mouse_manager(&event,item_encounter,encounter_num);
sdl_mouse_manager(&event,item_tile,tile_num);
sdl_mouse_manager(&event,item_unit,unit_num);
sdl_keyboard_manager(&event);
}
SDL_RenderClear(render);
sdl_blit_item_list(item_tile,tile_num);
sdl_blit_item_list(item_city,city_num);
sdl_blit_item_list(item_encounter,encounter_num);
sdl_blit_item_list(item_back,unit_num);
sdl_blit_item_list(item_unit,unit_num);
sdl_blit_item_list(item_ui,ITM_UI_NUM);
sdl_blit_to_screen();
sdl_loop_manager();
}
return;
}
static void assign_stress(cst_item *word)
{
int numsyls=ffeature_int(word,"word_numsyls");
const char *gpos=ffeature_string(word,"gpos");
const cst_item *word_in_phrase=item_as(word,"Phrase");
const cst_item *syls=item_as(word,"SylStructure");
const cst_item *syl=item_daughter(syls);
const cst_item *transcription=item_as(word,"Transcription");
int stressed=FALSE;
int n=item_feat_present(word,"stressed_syl_num")?item_feat_int(word,"stressed_syl_num"):0;
const char *name=item_name(word);
const char *pname=ffeature_string(word,"R:Phrase.p.name");
const char *nname=ffeature_string(word,"R:Phrase.n.name");
if(cst_streq(ffeature_string(word,"R:Token.p.name"),"по")&&
(cst_streq(name,"моему")||cst_streq(name,"своему")||cst_streq(name,"твоему")))
{
item_set_string(syl,"stress","1");
return;
}
else if((cst_streq(name,"не")||cst_streq(name,"ни"))&&
(cst_streq(nname,"был")||cst_streq(nname,"были")||cst_streq(nname,"было")))
{
item_set_string(syl,"stress","1");
return;
}
else if((cst_streq(name,"был")||cst_streq(name,"были")||cst_streq(name,"было"))&&
(cst_streq(pname,"не")||cst_streq(pname,"ни")))
return;
else if(cst_streq(gpos,"enc")&&item_prev(word_in_phrase))
return;
else if(cst_streq(gpos,"proc")&&item_next(word_in_phrase))
return;
if(!vowel_seg_between(item_daughter(transcription),item_last_daughter(transcription)))
return;
if(numsyls==1)
{
item_set_string(syl,"stress","1");
return;
}
for(;syl;syl=item_next(syl))
{
if(is_stressed_vowel(item_feat_string(item_daughter(item_as(syl,"SylVowel")),"name")))
{
item_set_string(syl,"stress","1");
stressed=TRUE;
}
}
if(n==0)
{
if(stressed)
return;
n=val_int(cart_interpret(word,&ru_stress_cart));
if((numsyls+n) < 0)
{
if(numsyls <= 4)
n=-2;
else
if(numsyls <= 6)
n=-3;
else
n=-4;
}
}
item_set_string(item_nth_daughter(syls,(numsyls+n)),"stress","1");
}