Loading...
Searching...
No Matches
sigpr_utt.cc
/*************************************************************************/
/* */
/* Centre for Speech Technology Research */
/* University of Edinburgh, UK */
/* Copyright (c) 1996 */
/* All Rights Reserved. */
/* */
/* Permission is hereby granted, free of charge, to use and distribute */
/* this software and its documentation without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of this work, and to */
/* permit persons to whom this work is furnished to do so, subject to */
/* the following conditions: */
/* 1. The code must retain the above copyright notice, this list of */
/* conditions and the following disclaimer. */
/* 2. Any modifications must be clearly marked as such. */
/* 3. Original authors' names are not deleted. */
/* 4. The authors' names are not used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK */
/* DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING */
/* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */
/* SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE */
/* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES */
/* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN */
/* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, */
/* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF */
/* THIS SOFTWARE. */
/* */
/*************************************************************************/
/* Authors: Paul Taylor and Simon King */
/* Date : March 1998 */
/*-----------------------------------------------------------------------*/
/* Signal processing functions which operate on entire utterances */
/* */
/*=======================================================================*/
#include "EST_error.h"
#include "EST_track_aux.h"
#include "EST_inline_utils.h"
#include "sigpr/EST_fft.h"
#include "sigpr/EST_sigpr_frame.h"
#include "sigpr/EST_sigpr_utt.h"
#include "EST_Features.h"
#include "EST_types.h"
#include "EST_string_aux.h"
void sigpr_acc(EST_Wave &sig, EST_Track &fv, EST_Features &op,
const EST_StrList &slist);
void sigpr_delta(EST_Wave &sig, EST_Track &fv, EST_Features &op,
const EST_StrList &slist);
static void parse_op_settings(EST_Features &op, EST_WindowFunc *&wf, float &f)
{
EST_String w_name;
if (op.present("window_type"))
w_name = op.S("window_type");
else
w_name = DEFAULT_WINDOW_NAME;
wf = EST_Window::creator(w_name);
f = op.present("frame_factor") ? op.F("frame_factor")
: DEFAULT_FRAME_FACTOR;
}
void add_channels_to_map(EST_StrList &map, EST_StrList &types,
EST_Features &op, int delta_order)
{
EST_String t;
EST_String dos;
if (delta_order == 0)
dos = "";
else if (delta_order == 1)
dos = "_d";
else if (delta_order == 2)
dos = "_a";
else
EST_error("Requested delta order too high: %d\n", delta_order);
for (EST_Litem *s = types.head(); s; s = s->next())
{
t = types(s);
if (op.present(t + "_order"))
{
int actual_order = op.I(t + "_order");
if(actual_order < 1)
{
cerr << "Invalid " << t << "_order" << " : ";
cerr << actual_order;
cerr << " (using 1 instead) " << endl;
actual_order = 1;
}
int lowest_coef=0,highest_coef=actual_order-1;
if(t == "lpc")
// For lpc coefficients, we ALWAYS include energy as the
// 0th coefficient, so when the users gives lpc_order of
// 16, we produce 17 coefficients (0 to 16)
highest_coef=actual_order;
if(t == "melcep")
{
// Mel cepstra have special names - if we are not
// including c0, then the coefficients are numbered
// 1...order, and NOT 0...order-1
highest_coef=actual_order;
if(op.present("include_c0"))
lowest_coef = 0;
else
lowest_coef = 1;
}
if(actual_order == 1)
map.append(t + dos);
else
map.append("$" + t + dos + "-"+itoString(lowest_coef)+"+"+itoString(highest_coef));
}
else
map.append(t + dos);
}
}
void sigpr_base(EST_Wave &sig, EST_Track &fv, EST_Features &op,
const EST_StrList &slist)
{
EST_Track fill, tmp;
EST_String b_name;
EST_String k;
float frame_factor;
EST_WindowFunc *wf;
int fbank_order;
float liftering_parameter=0;
bool use_power_rather_than_energy=false, take_logs=true, include_c0=false;
parse_op_settings(op, wf, frame_factor);
for (EST_Litem *s = slist.head(); s; s = s->next())
{
k = slist(s);
EST_String start_channel="0";
if( (slist(s) == "melcep") && !op.present("include_c0"))
start_channel = "1";
if (fv.has_channel(k))
fv.sub_track(fill, 0, EST_ALL, k , 1);
else
fv.sub_track(fill, 0, EST_ALL, k + "_" + start_channel, k + "_N");
if(op.present("usepower"))
cerr << "USING POWER" << endl;
if ((slist(s) == "lpc") || (slist(s) == "cep")
||(slist(s) == "ref") || (slist(s) == "lsf"))
sig2coef(sig, fill, slist(s), frame_factor, wf);
else if (slist(s) == "power")
power(sig, fill, frame_factor);
else if (slist(s) == "energy")
energy(sig, fill, frame_factor);
else if (slist(s) == "f0")
{
op.set("srpd_resize", 0);
op.set("pda_frame_shift", op.F("frame_shift"));
pda(sig, fill, op, "srpd");
}
// else if (slist(s) == "rasta")
// rasta(sig, fill, op);
else if (slist(s) == "fbank")
{
use_power_rather_than_energy = op.present("usepower");
fbank(sig, fill, frame_factor, wf, use_power_rather_than_energy,
take_logs);
}
else if (slist(s) == "melcep")
{
fbank_order=op.I("fbank_order");
use_power_rather_than_energy = op.present("usepower");
include_c0=op.present("include_c0");
if(op.present("lifter"))
liftering_parameter=op.F("lifter");
//cerr << "calling melcep " << fill.num_channels() << endl;
melcep(sig, fill, frame_factor, fbank_order,
liftering_parameter, wf, include_c0,
use_power_rather_than_energy);
}
else
EST_error("Error: Unnknown type of processing requested: %s\n",
((const char*) slist(s)));
}
}
void sigpr_delta(EST_Wave &sig, EST_Track &fv, EST_Features &op,
const EST_String &k)
{
EST_Track base, fill;
// cout << "type: " << k << endl;
// look to see if base coefficients already exist
EST_String start_channel="0";
if( (k == "melcep") && !op.present("include_c0"))
start_channel = "1";
if (fv.has_channel(k))
fv.sub_track(base, 0, EST_ALL, k , 1);
else if (fv.has_channel(k + "_" + start_channel))
fv.sub_track(base, 0, EST_ALL, k + "_" + start_channel, k + "_N");
else // otherwise make them in temporary track
{
// cout << "making tmp cpoefs\n";
EST_StrList tmp_base, tmp_map;
tmp_base.append(k);
add_channels_to_map(tmp_map, tmp_base, op, 0);
base.resize(fv.num_frames(), tmp_map);
base.fill_time(fv);
base.set_equal_space(false);
sigpr_base(sig, base, op, tmp_base);
// cout << "BASE\n" << base;
// cout <<"after\n";
}
if (fv.has_channel(k + "_d"))
fv.sub_track(fill, 0, EST_ALL, k+"_d", 1);
else
fv.sub_track(fill, 0, EST_ALL, k+"_d_" + start_channel, k+"_d_N");
/* cout << "base\n";
track_info(base);
cout << "fill\n";
track_info(fill);
*/
delta(base, fill);
}
void sigpr_acc(EST_Wave &sig, EST_Track &fv, EST_Features &op,
const EST_String &k)
{
EST_Track base, fill;
// cout << endl << endl << "acc\n";
// cout << "type: " << k << endl;
// look to see if delta coefficients already exist
EST_String start_channel="0";
if( (k == "melcep") && !op.present("include_c0"))
start_channel = "1";
if (fv.has_channel(k+"_d"))
fv.sub_track(base, 0, EST_ALL, k + "_d", 1);
else if (fv.has_channel(k + "_d_" + start_channel))
fv.sub_track(base, 0, EST_ALL, k + "_d_" + start_channel, k + "_d_N");
else // otherwise make them in temporary track
{
EST_StrList tmp_base, tmp_map;
tmp_base.append(k);
add_channels_to_map(tmp_map, tmp_base, op, 1);
base.resize(fv.num_frames(), tmp_map);
base.fill_time(fv);
base.set_equal_space(false);
sigpr_delta(sig, base, op, tmp_base);
}
if (fv.has_channel(k + "_a"))
fv.sub_track(fill, 0, EST_ALL, k+"_a", 1);
else
fv.sub_track(fill, 0, EST_ALL, k+"_a_" + start_channel, k+"_a_N");
// cout << "base\n";
// track_info(base);
// cout << "fill\n";
// track_info(fill);
delta(base, fill);
}
void sigpr_acc(EST_Wave &sig, EST_Track &fv, EST_Features &op,
const EST_StrList &slist)
{
for (EST_Litem *s = slist.head(); s; s = s->next())
sigpr_acc(sig, fv, op, slist(s));
}
void sigpr_delta(EST_Wave &sig, EST_Track &fv, EST_Features &op,
const EST_StrList &slist)
{
for (EST_Litem *s = slist.head(); s; s = s->next())
sigpr_delta(sig, fv, op, slist(s));
}
int get_frame_size(EST_Track &pms,
int i, int sample_rate, int prefer_prev)
{
int prev = -1;
int next = -1;
if (i>0)
prev = irint((pms.t(i) - pms.t(i-1))*sample_rate);
if (i<pms.num_frames()-1)
next = irint((pms.t(i+1) - pms.t(i))*sample_rate);
if (prefer_prev)
return prev>=0?prev:(next>=0?next:0);
return next>=0?next:(prev>=0?prev:0);
}
float get_time_frame_size(EST_Track &pms, int i, int prefer_prev)
{
float prev = -1;
float next = -1;
if (i > 0)
prev = pms.t(i) - pms.t(i-1);
if (i < pms.num_frames() -1)
next = pms.t(i+1) - pms.t(i);
if (prefer_prev)
return prev>=0 ? prev: (next>=0 ? next : 0.0);
return next>=0 ? next: (prev>=0 ? prev : 0.0);
}
/*void sig2lpc(EST_Wave &sig, EST_Track &lpc, EST_WindowFunc *wf, float factor)
{
int order = lpc.num_channels() - 1;
EST_FVector coefs(order + 1);
int k;
int window_start, window_size, length; // can be merged with window_size
int sample_rate = sig.sample_rate();
EST_FVector frame;
for (k = 0; k < lpc.num_frames(); ++k)
{
int pos = irint(lpc.t(k) * sample_rate);
length = get_local_frame_size(lpc, k, sig.sample_rate());
window_size = irint(length * factor);
window_start = pos - (window_size/2);
EST_Window::window_signal(sig, wf, window_start,
window_size, frame, 1);
lpc.frame(coefs, k);
sig2lpc(frame, coefs);
}
lpc.save("test.est", "est");
}
*/
/*typedef void EST_FrameFunc(const EST_FVector &in_frame,
EST_FVector &out_frame);
void sig2coef(EST_Wave &sig, EST_Track &lpc, EST_WindowFunc *wf,
EST_FrameFunc *ff, float factor)
{
EST_FVector coefs, frame;
int start, size;
for (int k = 0; k < lpc.num_frames(); ++k)
{
size = irint(get_local_frame_size(lpc, k, sig.sample_rate())* factor);
start = (irint(lpc.t(k) * sig.sample_rate()) - (size/2));
EST_Window::window_signal(sig, wf, start, size, frame, 1);
lpc.frame(coefs, k);
(*ff)(frame, coefs);
}
}
*/
void sig2coef(EST_Wave &sig, EST_Track &tr, EST_String type,
float factor, EST_WindowFunc *wf)
{
EST_FVector coefs, frame;
int start, size;
// cout << "TYPE IS " << type << endl;
for (int k = 0; k < tr.num_frames(); ++k)
{
if (factor < 0) // want fixed frame rate
size = (int)(-1.0 * factor * (float)sig.sample_rate());
else
size = irint(get_frame_size(tr, k, sig.sample_rate())* factor);
start = (irint(tr.t(k) * sig.sample_rate()) - (size/2));
EST_Window::window_signal(sig, wf, start, size, frame, 1);
tr.frame(coefs, k);
frame_convert(frame, "sig", coefs, type);
}
}
void power(EST_Wave &sig, EST_Track &pow, float factor)
{
EST_FVector frame;
int window_start, window_size, pos, k;
EST_WindowFunc *wf = EST_Window::creator("rectangular");
for (k = 0; k < pow.num_frames(); ++k)
{
pos = irint(pow.t(k) * sig.sample_rate());
if (factor < 0) // want fixed frame rate
window_size = (int)(-1.0 * factor * (float)sig.sample_rate());
else
window_size = irint(get_frame_size(pow, k, sig.sample_rate())
* factor);
window_start = pos - window_size/2;
EST_Window::window_signal(sig, wf, window_start, window_size,frame, 1);
sig2pow(frame, pow.a(k));
}
}
void energy(EST_Wave &sig, EST_Track &pow, float factor)
{
EST_FVector frame;
int window_start, window_size, pos, k;
EST_WindowFunc *wf = EST_Window::creator("rectangular");
for (k = 0; k < pow.num_frames(); ++k)
{
pos = irint(pow.t(k) * sig.sample_rate());
if (factor < 0) // want fixed frame rate
window_size = (int)(-1.0 * factor * (float)sig.sample_rate());
else
window_size = irint(get_frame_size(pow, k, sig.sample_rate())
* factor);
window_start = pos - window_size/2;
EST_Window::window_signal(sig, wf, window_start, window_size,frame,1);
sig2rms(frame, pow.a(k));
}
}
static EST_String determine_type(const EST_String &intype)
{
return (intype.contains("_") ? intype.before("_"): intype);
}
void convert_track(EST_Track &in_track, EST_Track &out_track,
const EST_String &out_type, const EST_String &in_type)
{
if (in_track.num_frames() != out_track.num_frames())
EST_error("In track has %d frames, out track has %d\n",
in_track.num_frames(), out_track.num_frames());
EST_String tmp;
tmp = ((in_type == "") ? determine_type(in_track.channel_name(0)):in_type);
EST_FVector in_frame(in_track.num_channels());
EST_FVector out_frame(out_track.num_channels());
for (int i = 0; i < in_track.num_frames(); ++i)
{
in_track.frame(in_frame, i);
out_track.frame(out_frame, i);
frame_convert(in_frame, tmp, out_frame, out_type);
}
}
void fbank(EST_Wave &sig,
EST_Track &fbank_track,
const float factor,
EST_WindowFunc *wf,
const bool use_power_rather_than_energy,
const bool take_log)
{
// still to add : high/low pass filtering
int window_start, window_size, pos, k;
EST_FVector frame,fbank_frame;
// get_order(...) gives wrong answer ... Paul ?
int fbank_order = fbank_track.num_channels();
// sanity check
if(fbank_order < 1)
{
EST_error("Filterbank order of %i makes no sense.\n",fbank_order);
return;
}
for (k = 0; k < fbank_track.num_frames(); ++k)
{
if (factor < 0) // want fixed frame rate
window_size = (int)(-1.0 * factor * (float)sig.sample_rate());
else
window_size = irint(get_frame_size(fbank_track, k, sig.sample_rate())
* factor);
pos = irint(fbank_track.t(k) * sig.sample_rate());
window_start = pos - window_size/2;
EST_Window::window_signal(sig, wf, window_start, window_size,frame, 1);
fbank_track.frame(fbank_frame,k);
sig2fbank(frame,fbank_frame,sig.sample_rate(),
use_power_rather_than_energy,take_log);
}
}
void melcep(EST_Wave &sig, EST_Track &mfcc_track,
float factor,
int fbank_order,
float liftering_parameter,
EST_WindowFunc *wf,
const bool include_c0,
const bool use_power_rather_than_energy)
{
EST_FVector frame,mfcc_frame,fbank_frame;
int k;
// first, do filterbank analysis
// need a temporary track, with the same setup as mfcc_track
EST_Track fbank_track;
// cout << "MELPCEP\n" << fbank_order << endl;
fbank_track.resize(mfcc_track.num_frames(), fbank_order);
fbank_track.fill_time(mfcc_track);
fbank_track.set_equal_space(false);
// temp removed by pault 24/02/99
// make_timed_track(mfcc_track, fbank_track, "filter", fbank_order, 0);
// 'true' makes fbank(...) take logs
fbank(sig, fbank_track, factor, wf, use_power_rather_than_energy, true);
/*
if(include_c0)
cerr << "melcep c0" << endl;
else
cerr << "melcep no c0" << endl;
*/
for (k = 0; k < mfcc_track.num_frames(); ++k)
{
mfcc_track.frame(mfcc_frame,k);
fbank_track.frame(fbank_frame,k);
fbank2melcep(fbank_frame, mfcc_frame,liftering_parameter,include_c0);
}
}
EST_FVector
Definition EST_FMatrix.h:114
EST_Features
Definition EST_Features.h:62
EST_Features::set
void set(const EST_String &name, int ival)
Definition EST_Features.h:185
EST_Features::F
const float F(const EST_String &path) const
Definition EST_Features.h:135
EST_Features::S
const EST_String S(const EST_String &path) const
Definition EST_Features.h:157
EST_Features::present
int present(const EST_String &name) const
Definition EST_Features.cc:147
EST_Features::I
const int I(const EST_String &path) const
Definition EST_Features.h:146
EST_String
Definition EST_String.h:70
EST_String::before
EST_String before(int pos, int len=0) const
Part before position.
Definition EST_String.h:286
EST_String::contains
int contains(const char *s, int pos=-1) const
Does it contain this substring?
Definition EST_String.h:375
EST_TList::append
void append(const T &item)
add item onto end of list
Definition EST_TList.h:191
EST_Track
Definition EST_Track.h:89
EST_Track::t
float & t(int i=0)
return time position of frame i
Definition EST_Track.h:477
EST_Track::a
float & a(int i, int c=0)
Definition EST_Track.cc:1022
EST_Track::sub_track
void sub_track(EST_Track &st, int start_frame=0, int nframes=EST_ALL, int start_chan=0, int nchans=EST_ALL)
Definition EST_Track.cc:1097
EST_Track::has_channel
bool has_channel(const char *name) const
Definition EST_Track.h:384
EST_Track::num_channels
int num_channels() const
return number of channels in track
Definition EST_Track.h:656
EST_Track::num_frames
int num_frames() const
return number of frames in track
Definition EST_Track.h:650
EST_Track::resize
void resize(int num_frames, int num_channels, bool preserve=1)
Definition EST_Track.cc:211
EST_Track::fill_time
void fill_time(float t, int start=1)
Definition EST_Track.cc:786
EST_Track::frame
void frame(EST_FVector &fv, int n, int startf=0, int nf=EST_ALL)
Definition EST_Track.h:209
EST_Wave
Definition EST_Wave.h:65
EST_Wave::sample_rate
int sample_rate() const
return the sampling rate (frequency)
Definition EST_Wave.h:147
EST_Window::window_signal
static void window_signal(const EST_Wave &sig, EST_WindowFunc *make_window, int start, int size, EST_TBuffer< float > &frame)
Definition EST_Window.cc:275
EST_Window::creator
static Func * creator(const char *name, bool report_error=false)
Return the creation function for the given window type.
Definition EST_Window.cc:216