/* Dummy F0 modelling for phones, copied directly from us_f0_model.c */
cst_utterance *flat_prosody(cst_utterance *u)
{
/* F0 target model */
cst_item *s,*t;
cst_relation *targ_rel;
float mean, stddev;
targ_rel = utt_relation_create(u,"Target");
mean = get_param_float(u->features,"target_f0_mean", 100.0);
mean *= get_param_float(u->features,"f0_shift", 1.0);
stddev = get_param_float(u->features,"target_f0_stddev", 12.0);
s=relation_head(utt_relation(u,"Segment"));
t = relation_append(targ_rel,NULL);
item_set_float(t,"pos",0.0);
item_set_float(t,"f0",mean+stddev);
s=relation_tail(utt_relation(u,"Segment"));
t = relation_append(targ_rel,NULL);
item_set_float(t,"pos",item_feat_float(s,"end"));
item_set_float(t,"f0",mean-stddev);
return u;
}
static void cg_smooth_F0(cst_utterance *utt,cst_cg_db *cg_db,
cst_track *param_track)
{
/* Smooth F0 and mark unnoived frames as 0.0 */
cst_item *mcep;
int i, c;
float l, s;
float mean, stddev;
l = 0.0;
for (i=0; i<param_track->num_frames-1; i++)
{
c = 0; s = 0;
if (l > 0.0)
{
c++; s+=l;
}
if (param_track->frames[i+1][0] > 0.0)
{
c++; s+=param_track->frames[i+1][0];
}
l = param_track->frames[i][0];
if (param_track->frames[i][0] > 0.0)
{
c++; s+=param_track->frames[i][0];
param_track->frames[i][0] = s/c;
}
}
mean = get_param_float(utt->features,"int_f0_target_mean", cg_db->f0_mean);
mean *= get_param_float(utt->features,"f0_shift", 1.0);
stddev =
get_param_float(utt->features,"int_f0_target_stddev", cg_db->f0_stddev);
for (i=0,mcep=utt_rel_head(utt,"mcep"); mcep; i++,mcep=item_next(mcep))
{
if (voiced_frame(mcep))
{
/* scale the F0 -- which normally wont change it at all */
param_track->frames[i][0] =
(((param_track->frames[i][0]-cg_db->f0_mean)/cg_db->f0_stddev)
*stddev)+mean;
/* Some safety checks */
if (param_track->frames[i][0] < 50)
param_track->frames[i][0] = 50;
if (param_track->frames[i][0] > 700)
param_track->frames[i][0] = 700;
}
else /* Unvoice it */
param_track->frames[i][0] = 0.0;
}
return;
}
void P_label(Rainbow_hdr *rainbow_header, char* buf)
{
int labelnum;
char label;
sscanf(buf, "%c%d", &label, &labelnum);
if (labelnum == 3)
rainbow_header->range_start= get_param_float(buf);
else if (labelnum == 4)
rainbow_header->range_stop = get_param_float(buf);
else if (labelnum == 5)
rainbow_header->range_step = get_param_float(buf);
}
void A_label(Rainbow_hdr *rainbow_header, char* buf)
{
int labelnum;
char label;
sscanf(buf, "%c%d", &label, &labelnum);
if (labelnum == 3)
rainbow_header->az_step = get_param_float(buf);
else if (labelnum == 9)
rainbow_header->nsweeps = get_param_int(buf);
}
void R_label(Rainbow_hdr *rainbow_header, char* buf)
{
int labelnum;
sscanf(buf, "%*c%d", &labelnum);
if (labelnum == 1)
rainbow_header->nbins = get_param_int(buf);
else if (labelnum == 2)
rainbow_header->bin_resolution = get_param_float(buf);
else if (labelnum == 8)
rainbow_header->nvalues = get_param_int(buf);
}
void flite_strip_silence(AudioTrack * track)
{
int playlen, skip;
float stretch =
get_param_float(flite_voice->features, "duration_stretch", 1.);
int speed = (int)(1000. / stretch);
skip = (187 * track->sample_rate) / speed;
playlen = track->num_samples - skip * 2;
if (playlen > 0 && playlen < 500)
playlen += (skip * 2) / 3;
if (playlen < 0)
playlen = 0;
track->num_samples = playlen;
assert(track->bits == 16);
track->samples += skip * track->num_channels;
}
static cst_utterance *cg_make_params(cst_utterance *utt)
{
/* puts in the frame items */
/* historically called "mcep" but can actually be any random vectors */
cst_cg_db *cg_db;
cst_relation *mcep, *mcep_link;
cst_item *s, *mcep_parent, *mcep_frame;
int num_frames;
float start, end;
float dur_stretch, tok_stretch;
cg_db = val_cg_db(utt_feat_val(utt,"cg_db"));
mcep = utt_relation_create(utt,"mcep");
mcep_link = utt_relation_create(utt,"mcep_link");
end = 0.0;
num_frames = 0;
dur_stretch = get_param_float(utt->features,"duration_stretch", 1.0);
for (s = utt_rel_head(utt,"HMMstate"); s; s=item_next(s))
{
start = end;
tok_stretch = ffeature_float(s,"R:segstate.parent.R:SylStructure.parent.parent.R:Token.parent.local_duration_stretch");
if (tok_stretch == 0)
tok_stretch = 1.0;
end = start + (tok_stretch*dur_stretch*cg_state_duration(s,cg_db));
item_set_float(s,"end",end);
mcep_parent = relation_append(mcep_link, s);
for ( ; (num_frames * cg_db->frame_advance) <= end; num_frames++ )
{
mcep_frame = relation_append(mcep,NULL);
item_add_daughter(mcep_parent,mcep_frame);
item_set_int(mcep_frame,"frame_number",num_frames);
item_set(mcep_frame,"name",item_feat(mcep_parent,"name"));
}
}
/* Copy duration up onto Segment relation */
for (s = utt_rel_head(utt,"Segment"); s; s=item_next(s))
item_set(s,"end",ffeature(s,"R:segstate.daughtern.end"));
utt_set_feat_int(utt,"param_track_num_frames",num_frames);
return utt;
}
cst_utterance *cart_duration(cst_utterance *u)
{
cst_cart *dur_tree;
cst_item *s;
float zdur, dur_stretch, local_dur_stretch, dur;
float end;
dur_stats *ds;
const dur_stat *dur_stat;
end = 0;
if (feat_present(u->features,"no_segment_duration_model"))
return u; /* not all methods need segment durations */
dur_tree = val_cart(feat_val(u->features,"dur_cart"));
dur_stretch = get_param_float(u->features,"duration_stretch", 1.0);
ds = val_dur_stats(feat_val(u->features,"dur_stats"));
for (s=relation_head(utt_relation(u,"Segment")); s; s=item_next(s))
{
zdur = val_float(cart_interpret(s,dur_tree));
dur_stat = phone_dur_stat(ds,item_name(s));
local_dur_stretch = ffeature_float(s, "R:SylStructure.parent.parent."
"R:Token.parent.local_duration_stretch");
if (local_dur_stretch)
local_dur_stretch *= dur_stretch;
else
local_dur_stretch = dur_stretch;
dur = local_dur_stretch * ((zdur*dur_stat->stddev)+dur_stat->mean);
DPRINTF(0,("phone %s accent %s stress %s pdur %f stretch %f mean %f std %f dur %f\n",
item_name(s),
ffeature_string(s,"R:SylStructure.parent.accented"),
ffeature_string(s,"R:SylStructure.parent.stress"),
zdur, local_dur_stretch, dur_stat->mean,
dur_stat->stddev, dur));
end += dur;
item_set_float(s,"end",end);
}
return u;
}
result_t widget_wndproc(handle_t hwnd, const canmsg_t *msg)
{
bool changed = false;
hsi_window_t *wnd;
get_wnddata(hwnd, (void **)&wnd);
switch (msg->id)
{
case id_magnetic_heading:
{
int16_t direction;
get_param_int16(msg, 0, &direction);
while (direction < 0)
direction += 360;
while (direction > 359)
direction -= 360;
changed = wnd->direction != direction;
wnd->direction = direction;
}
break;
case id_heading:
{
int16_t value;
get_param_int16(msg, 0, &value);
changed = wnd->heading_bug != value;
wnd->heading_bug = value;
}
break;
case id_heading_angle:
{
int16_t value;
get_param_int16(msg, 0, &value);
changed = wnd->heading != value;
wnd->heading = value;
}
break;
case id_deviation:
{
int16_t value;
get_param_int16(msg, 0, &value);
changed = wnd->deviation != value;
wnd->deviation = value;
// the deviation is +/- * 10
}
break;
case id_selected_course:
{
int16_t value;
get_param_int16(msg, 0, &value);
changed = wnd->course != value;
wnd->course = value;
}
break;
case id_track:
{
int16_t value;
get_param_int16(msg, 0, &value);
changed = wnd->track != value;
wnd->track = value;
}
break;
case id_wind_speed:
{
float v;
get_param_float(msg, &v);
int16_t value = (int16_t)meters_per_second_to_knots(v);
changed = wnd->wind_speed != value;
wnd->wind_speed = value;
}
break;
case id_wind_direction:
{
float v;
get_param_float(msg, &v);
int16_t value = (int16_t)radians_to_degrees(v);
changed = wnd->wind_direction != value;
wnd->wind_direction != value;
}
break;
case id_distance_to_next:
{
float v;
get_param_float(msg, &v);
int16_t value = (int16_t)meters_to_nm(v);
changed = wnd->distance_to_waypoint != value;
wnd->distance_to_waypoint = value;
}
break;
case id_magnetic_variation:
{
float v;
get_param_float(msg, &v);
int16_t value = (int16_t)radians_to_degrees(v);
changed = wnd->magnetic_variation != value;
wnd->magnetic_variation = value;
}
break;
case id_estimated_time_to_next:
{
int16_t value;
get_param_int16(msg, 0, &value);
changed = wnd->time_to_waypoint != value;
wnd->time_to_waypoint = value;
}
break;
case id_paint:
begin_paint(hwnd);
update_window(hwnd, wnd);
end_paint(hwnd);
break;
default:
return defwndproc(hwnd, msg);
}
if (changed)
invalidate_rect(hwnd, 0);
return s_ok;
}
/*----------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
int loop, test, windowsize, count;
float temp;
double *pkernel, *gkernel, *dkernel;
double corner, thresh = 1.0/256.0, sigma = 1.0, sumall = 1.0;
for(loop=1;loop<argc;loop++)
{
if(strncmp(argv[loop],"-t",2)==0)
{
if(get_param_int(argc,argv,&loop,&test)<0)
{
printf("Cannot get threshold value?\n");
return -1;
}
thresh = 1.0/(double)test;
}
else if(strncmp(argv[loop],"-s",2)==0)
{
if(get_param_float(argc,argv,&loop,&temp)<0)
{
printf("Cannot get sigma value?\n");
return -1;
}
sigma = (double)temp;
}
}
loop=0;
do
{
corner = fgaussian2d(loop,loop,sigma);
if(corner>thresh)
{
sumall = corner;
loop++;
}
else
{
corner = sumall;
break;
}
}
while(1);
printf("Gaussian kernel build parameters:\n");
printf(" Sigma: %lf, Threshold: %lf, Corner: %lf\n",sigma,thresh,corner);
windowsize = (loop*2)-1;
count = windowsize/2;
gkernel = (double*) malloc(windowsize*windowsize*sizeof(double));
dkernel = (double*) malloc(windowsize*sizeof(double));
printf("Gaussian 1D kernel\n");
pkernel = dkernel; sumall = 0.0;
for(loop=0;loop<windowsize;loop++)
{
*pkernel = fgaussian1d(loop-count,sigma);
sumall += *pkernel;
pkernel++;
}
pkernel = dkernel;
for(loop=0;loop<windowsize;loop++)
{
*pkernel /= sumall;
printf(" %.6lf ",*pkernel);
pkernel++;
}
printf("\n");
printf("Gaussian 2D kernel from 1D!\n");
for(loop=0;loop<windowsize;loop++)
{
for(test=0;test<windowsize;test++)
{
printf(" %.6lf ",(dkernel[loop]*dkernel[test]));
}
printf("\n");
}
printf("Gaussian 2D kernel (%dx%d)\n",windowsize,windowsize);
pkernel = gkernel; sumall = 0.0;
for(loop=0;loop<windowsize;loop++)
{
for(test=0;test<windowsize;test++)
{
*pkernel = fgaussian2d(loop-count, test-count, sigma);
sumall += *pkernel;
pkernel++;
}
}
corner /= sumall;
// normalize and show it!
pkernel = gkernel;
for(loop=0;loop<windowsize;loop++)
{
for(test=0;test<windowsize;test++)
{
*pkernel /= sumall;
printf(" %.6lf ",*pkernel);
pkernel++;
}
printf("\n");
}
printf("Gaussian 2D kernel (1/%d)\n",(int)(1.0/corner));
pkernel = gkernel;
for(loop=0;loop<windowsize;loop++)
{
for(test=0;test<windowsize;test++)
{
printf(" %6d ",(int)((*pkernel)/corner));
pkernel++;
}
printf("\n");
}
free(dkernel);
free(gkernel);
return 0;
}
float flite_get_param_float(const cst_features *f, const char *name, float def)
{
return get_param_float(f,name,def);
}
