static LPC _Sound_to_LPC (Sound me, int predictionOrder, double analysisWidth, double dt,
double preEmphasisFrequency, int method, double tol1, double tol2) {
double t1, samplingFrequency = 1.0 / my dx;
double windowDuration = 2 * analysisWidth; /* gaussian window */
long nFrames, frameErrorCount = 0;
if (floor (windowDuration / my dx) < predictionOrder + 1) Melder_throw ("Analysis window duration too short.\n"
"For a prediction order of ", predictionOrder, " the analysis window duration has to be greater than ", my dx * (predictionOrder + 1),
"Please increase the analysis window duration or lower the prediction order.");
// Convenience: analyse the whole sound into one LPC_frame
if (windowDuration > my dx * my nx) {
windowDuration = my dx * my nx;
}
Sampled_shortTermAnalysis (me, windowDuration, dt, & nFrames, & t1);
autoSound sound = Data_copy (me);
autoSound sframe = Sound_createSimple (1, windowDuration, samplingFrequency);
autoSound window = Sound_createGaussian (windowDuration, samplingFrequency);
autoLPC thee = LPC_create (my xmin, my xmax, nFrames, dt, t1, predictionOrder, my dx);
autoMelderProgress progress (L"LPC analysis");
if (preEmphasisFrequency < samplingFrequency / 2) {
Sound_preEmphasis (sound.peek(), preEmphasisFrequency);
}
for (long i = 1; i <= nFrames; i++) {
LPC_Frame lpcframe = (LPC_Frame) & thy d_frames[i];
double t = Sampled_indexToX (thee.peek(), i);
LPC_Frame_init (lpcframe, predictionOrder);
Sound_into_Sound (sound.peek(), sframe.peek(), t - windowDuration / 2);
Vector_subtractMean (sframe.peek());
Sounds_multiply (sframe.peek(), window.peek());
if (method == LPC_METHOD_AUTO) {
if (! Sound_into_LPC_Frame_auto (sframe.peek(), lpcframe)) {
frameErrorCount++;
}
} else if (method == LPC_METHOD_COVAR) {
if (! Sound_into_LPC_Frame_covar (sframe.peek(), lpcframe)) {
frameErrorCount++;
}
} else if (method == LPC_METHOD_BURG) {
if (! Sound_into_LPC_Frame_burg (sframe.peek(), lpcframe)) {
frameErrorCount++;
}
} else if (method == LPC_METHOD_MARPLE) {
if (! Sound_into_LPC_Frame_marple (sframe.peek(), lpcframe, tol1, tol2)) {
frameErrorCount++;
}
}
if ( (i % 10) == 1) {
Melder_progress ( (double) i / nFrames, L"LPC analysis of frame ",
Melder_integer (i), L" out of ", Melder_integer (nFrames), L".");
}
}
return thee.transfer();
}
Sound Sound_filter_preemphasis (Sound me, double frequency) {
try {
autoSound thee = Data_copy (me);
Sound_preEmphasis (thee.peek(), frequency);
Matrix_scaleAbsoluteExtremum (thee.peek(), 0.99);
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, U": not filtered (pre-emphasis).");
}
}
PowerCepstrogram Sound_to_PowerCepstrogram (Sound me, double pitchFloor, double dt, double maximumFrequency, double preEmphasisFrequency) {
try {
// minimum analysis window has 3 periods of lowest pitch
double analysisWidth = 3 / pitchFloor;
double windowDuration = 2 * analysisWidth; /* gaussian window */
long nFrames;
// Convenience: analyse the whole sound into one Cepstrogram_frame
if (windowDuration > my dx * my nx) {
windowDuration = my dx * my nx;
}
double t1, samplingFrequency = 2 * maximumFrequency;
autoSound sound = Sound_resample (me, samplingFrequency, 50);
Sound_preEmphasis (sound.peek(), preEmphasisFrequency);
Sampled_shortTermAnalysis (me, windowDuration, dt, & nFrames, & t1);
autoSound sframe = Sound_createSimple (1, windowDuration, samplingFrequency);
autoSound window = Sound_createGaussian (windowDuration, samplingFrequency);
// find out the size of the FFT
long nfft = 2;
while (nfft < sframe -> nx) nfft *= 2;
long nq = nfft / 2 + 1;
double qmax = 0.5 * nfft / samplingFrequency, dq = qmax / (nq - 1);
autoPowerCepstrogram thee = PowerCepstrogram_create (my xmin, my xmax, nFrames, dt, t1, 0, qmax, nq, dq, 0);
autoMelderProgress progress (L"Cepstrogram analysis");
for (long iframe = 1; iframe <= nFrames; iframe++) {
double t = Sampled_indexToX (thee.peek(), iframe);
Sound_into_Sound (sound.peek(), sframe.peek(), t - windowDuration / 2);
Vector_subtractMean (sframe.peek());
Sounds_multiply (sframe.peek(), window.peek());
autoSpectrum spec = Sound_to_Spectrum (sframe.peek(), 1); // FFT yes
autoPowerCepstrum cepstrum = Spectrum_to_PowerCepstrum (spec.peek());
for (long i = 1; i <= nq; i++) {
thy z[i][iframe] = cepstrum -> z[1][i];
}
if ((iframe % 10) == 1) {
Melder_progress ((double) iframe / nFrames, L"PowerCepstrogram analysis of frame ",
Melder_integer (iframe), L" out of ", Melder_integer (nFrames), L".");
}
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, ": no PowerCepstrogram created.");
}
}
static autoFormant Sound_to_Formant_any_inline (Sound me, double dt_in, int numberOfPoles,
double halfdt_window, int which, double preemphasisFrequency, double safetyMargin)
{
double dt = dt_in > 0.0 ? dt_in : halfdt_window / 4.0;
double duration = my nx * my dx, t1;
double dt_window = 2.0 * halfdt_window;
long nFrames = 1 + (long) floor ((duration - dt_window) / dt);
long nsamp_window = (long) floor (dt_window / my dx), halfnsamp_window = nsamp_window / 2;
if (nsamp_window < numberOfPoles + 1)
Melder_throw (U"Window too short.");
t1 = my x1 + 0.5 * (duration - my dx - (nFrames - 1) * dt); // centre of first frame
if (nFrames < 1) {
nFrames = 1;
t1 = my x1 + 0.5 * duration;
dt_window = duration;
nsamp_window = my nx;
}
autoFormant thee = Formant_create (my xmin, my xmax, nFrames, dt, t1, (numberOfPoles + 1) / 2); // e.g. 11 poles -> maximally 6 formants
autoNUMvector <double> window (1, nsamp_window);
autoNUMvector <double> frame (1, nsamp_window);
autoNUMvector <double> cof (1, numberOfPoles); // superfluous if which==2, but nobody uses that anyway
autoMelderProgress progress (U"Formant analysis...");
/* Pre-emphasis. */
Sound_preEmphasis (me, preemphasisFrequency);
/* Gaussian window. */
for (long i = 1; i <= nsamp_window; i ++) {
double imid = 0.5 * (nsamp_window + 1), edge = exp (-12.0);
window [i] = (exp (-48.0 * (i - imid) * (i - imid) / (nsamp_window + 1) / (nsamp_window + 1)) - edge) / (1.0 - edge);
}
for (long iframe = 1; iframe <= nFrames; iframe ++) {
double t = Sampled_indexToX (thee.peek(), iframe);
long leftSample = Sampled_xToLowIndex (me, t);
long rightSample = leftSample + 1;
long startSample = rightSample - halfnsamp_window;
long endSample = leftSample + halfnsamp_window;
double maximumIntensity = 0.0;
if (startSample < 1) startSample = 1;
if (endSample > my nx) endSample = my nx;
for (long i = startSample; i <= endSample; i ++) {
double value = Sampled_getValueAtSample (me, i, Sound_LEVEL_MONO, 0);
if (value * value > maximumIntensity) {
maximumIntensity = value * value;
}
}
if (maximumIntensity == HUGE_VAL)
Melder_throw (U"Sound contains infinities.");
thy d_frames [iframe]. intensity = maximumIntensity;
if (maximumIntensity == 0.0) continue; // Burg cannot stand all zeroes
/* Copy a pre-emphasized window to a frame. */
for (long j = 1, i = startSample; j <= nsamp_window; j ++)
frame [j] = Sampled_getValueAtSample (me, i ++, Sound_LEVEL_MONO, 0) * window [j];
if (which == 1) {
burg (frame.peek(), endSample - startSample + 1, cof.peek(), numberOfPoles, & thy d_frames [iframe], 0.5 / my dx, safetyMargin);
} else if (which == 2) {
if (! splitLevinson (frame.peek(), endSample - startSample + 1, numberOfPoles, & thy d_frames [iframe], 0.5 / my dx)) {
Melder_clearError ();
Melder_casual (U"(Sound_to_Formant:)"
U" Analysis results of frame ", iframe,
U" will be wrong."
);
}
}
Melder_progress ((double) iframe / (double) nFrames, U"Formant analysis: frame ", iframe);
}
Formant_sort (thee.peek());
return thee;
}
LPC LPC_and_Sound_to_LPC_robust (LPC thee, Sound me, double analysisWidth, double preEmphasisFrequency, double k,
int itermax, double tol, int wantlocation) {
struct huber_struct struct_huber = { 0 };
try {
double t1, samplingFrequency = 1.0 / my dx, tol_svd = 0.000001;
double location = 0, windowDuration = 2 * analysisWidth; /* Gaussian window */
long nFrames, frameErrorCount = 0, iter = 0;
long p = thy maxnCoefficients;
if (my xmin != thy xmin || my xmax != thy xmax) {
Melder_throw ("Time domains differ.");
}
if (my dx != thy samplingPeriod) {
Melder_throw ("Sampling intervals differ.");
}
if (floor (windowDuration / my dx) < p + 1) {
Melder_throw ("Analysis window too short.");
}
Sampled_shortTermAnalysis (me, windowDuration, thy dx, & nFrames, & t1);
if (nFrames != thy nx || t1 != thy x1) {
Melder_throw ("Incorrect retrieved analysis width");
}
autoSound sound = Data_copy (me);
autoSound sframe = Sound_createSimple (1, windowDuration, samplingFrequency);
autoSound window = Sound_createGaussian (windowDuration, samplingFrequency);
autoLPC him = Data_copy (thee);
huber_struct_init (&struct_huber, windowDuration, p, samplingFrequency, location, wantlocation);
struct_huber.k = k;
struct_huber.tol = tol;
struct_huber.tol_svd = tol_svd;
struct_huber.itermax = itermax;
autoMelderProgress progess (L"LPC analysis");
Sound_preEmphasis (sound.peek(), preEmphasisFrequency);
for (long i = 1; i <= nFrames; i++) {
LPC_Frame lpc = (LPC_Frame) & thy d_frames[i];
LPC_Frame lpcto = (LPC_Frame) & his d_frames[i];
double t = Sampled_indexToX (thee, i);
Sound_into_Sound (sound.peek(), sframe.peek(), t - windowDuration / 2);
Vector_subtractMean (sframe.peek());
Sounds_multiply (sframe.peek(), window.peek());
try {
LPC_Frames_and_Sound_huber (lpc, sframe.peek(), lpcto, & struct_huber);
} catch (MelderError) {
frameErrorCount++;
}
iter += struct_huber.iter;
if ( (i % 10) == 1) {
Melder_progress ( (double) i / nFrames, L"LPC analysis of frame ",
Melder_integer (i), L" out of ", Melder_integer (nFrames), L".");
}
}
if (frameErrorCount) Melder_warning (L"Results of ", Melder_integer (frameErrorCount),
L" frame(s) out of ", Melder_integer (nFrames), L" could not be optimised.");
MelderInfo_writeLine4 (L"Number of iterations: ", Melder_integer (iter),
L"\n Average per frame: ", Melder_double (((double) iter) / nFrames));
huber_struct_destroy (&struct_huber);
return him.transfer();
} catch (MelderError) {
huber_struct_destroy (&struct_huber);
Melder_throw (me, ": no robust LPC created.");
}
}