void Manipulation_replaceOriginalSound (Manipulation me, Sound sound) {
try {
my sound = Sound_convertToMono (sound);
Vector_subtractMean (my sound.get());
my lpc = autoLPC();
} catch (MelderError) {
Melder_throw (me, U": original Sound not replaced with ", sound, U".");
}
}
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();
}
autoManipulation Sound_PointProcess_to_Manipulation (Sound sound, PointProcess point) {
try {
autoManipulation me = Manipulation_create (sound -> xmin, sound -> xmax);
my sound = Sound_convertToMono (sound);
Vector_subtractMean (my sound.get());
my pulses = Data_copy (point);
my pitch = PointProcess_to_PitchTier (point, MAX_T);
return me;
} catch (MelderError) {
Melder_throw (sound, U" & ", point, U": not converted to Manipulation.");
}
}
autoManipulation Sound_to_Manipulation (Sound me, double timeStep, double minimumPitch, double maximumPitch) {
try {
autoManipulation thee = Manipulation_create (my xmin, my xmax);
thy sound = Sound_convertToMono (me);
Vector_subtractMean (thy sound.get());
autoPitch pitch = Sound_to_Pitch (thy sound.get(), timeStep, minimumPitch, maximumPitch);
thy pulses = Sound_Pitch_to_PointProcess_cc (thy sound.get(), pitch.get());
thy pitch = Pitch_to_PitchTier (pitch.get());
/* (DurationTier has been done at creation time) */
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to Manipulation.");
}
}
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.");
}
}
Sound Sound_lengthen_overlapAdd (Sound me, double fmin, double fmax, double factor) {
try {
if (my ny > 1)
Melder_throw (U"Overlap-add works only on mono sounds.");
autoSound sound = Data_copy (me);
Vector_subtractMean (sound.peek());
autoPitch pitch = Sound_to_Pitch (sound.peek(), 0.8 / fmin, fmin, fmax);
autoPointProcess pulses = Sound_Pitch_to_PointProcess_cc (sound.peek(), pitch.peek());
autoPitchTier pitchTier = Pitch_to_PitchTier (pitch.peek());
autoDurationTier duration = DurationTier_create (my xmin, my xmax);
RealTier_addPoint (duration.peek(), 0.5 * (my xmin + my xmax), factor);
autoSound thee = Sound_Point_Pitch_Duration_to_Sound (sound.peek(), pulses.peek(), pitchTier.peek(), duration.peek(), 1.5 / fmin);
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, U": not lengthened.");
}
}
Cepstrogram Sound_to_Cepstrogram (Sound me, double analysisWidth, double dt, double maximumFrequency) {
try {
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);
Sampled_shortTermAnalysis (me, windowDuration, dt, & nFrames, & t1);
autoSound sframe = Sound_createSimple (1, windowDuration, samplingFrequency);
autoSound window = Sound_createGaussian (windowDuration, samplingFrequency);
double qmin, qmax, dq, q1;
long nq;
{ // laziness: find out the proper dimensions
autoSpectrum spec = Sound_to_Spectrum (sframe.peek(), 1);
autoCepstrum cepstrum = Spectrum_to_Cepstrum (spec.peek());
qmin = cepstrum -> xmin; qmax = cepstrum -> xmax; dq = cepstrum -> dx;
q1 = cepstrum -> x1; nq = cepstrum -> nx;
}
autoCepstrogram thee = Cepstrogram_create (my xmin, my xmax, nFrames, dt, t1, qmin, qmax, nq, dq, q1);
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);
autoCepstrum cepstrum = Spectrum_to_Cepstrum (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"Cepstrogram analysis of frame ",
Melder_integer (iframe), L" out of ", Melder_integer (nFrames), L".");
}
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, ": no Cepstrogram created.");
}
}
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.");
}
}
