autoPitch Pitch_interpolate (Pitch me) {
try {
autoPitch thee = Pitch_create (my xmin, my xmax, my nx, my dx, my x1, my ceiling, 2);
for (long i = 1; i <= my nx; i ++) {
double f = my frame [i]. candidate [1]. frequency;
thy frame [i]. candidate [1]. strength = 0.9;
if (f > 0.0 && f < my ceiling) {
thy frame [i]. candidate [1]. frequency = f;
} else {
long left, right;
double fleft = 0.0, fright = 0.0;
for (left = i - 1; left >= 1 && fleft == 0.0; left --) {
fleft = my frame [left]. candidate [1]. frequency;
if (fleft >= my ceiling) fleft = 0.0;
}
for (right = i + 1; right <= my nx && fright == 0.0; right ++) {
fright = my frame [right]. candidate [1]. frequency;
if (fright >= my ceiling) fright = 0.0;
}
if (fleft != 0.0 && fright != 0.0)
thy frame [i]. candidate [1]. frequency =
((i - left) * fright + (right - i) * fleft) / (right - left);
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": not interpolated.");
}
}
Pitch PitchTier_to_Pitch (PitchTier me, double dt, double pitchFloor, double pitchCeiling) {
try {
if (my points -> size < 1) {
Melder_throw ("The PitchTier is empty.");
}
if (dt <= 0) {
Melder_throw ("The time step should be a positive number.");
}
if (pitchFloor >= pitchCeiling) {
Melder_throw ("The pitch ceiling must be a higher number than the pitch floor.");
}
double tmin = my xmin, tmax = my xmax, t1 = my xmin + dt / 2;
long nt = (tmax - tmin - t1) / dt;
if (t1 + nt * dt < tmax) {
nt++;
}
if (nt < 1) {
Melder_throw ("Duration is too short.");
}
autoPitch thee = Pitch_create (tmin, tmax, nt, dt, t1, pitchCeiling, 1);
for (long i = 1; i <= nt; i++) {
Pitch_Frame frame = (Pitch_Frame) & thy frame [i];
Pitch_Candidate candidate = (Pitch_Candidate) & frame -> candidate [1];
double t = t1 + (i - 1) * dt;
double f = RealTier_getValueAtTime (me, t);
if (f < pitchFloor || f > pitchCeiling) {
f = 0;
}
candidate -> frequency = f;
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, ": no Pitch created.");
}
}
autoPitch Pitch_killOctaveJumps (Pitch me) {
try {
autoPitch thee = Pitch_create (my xmin, my xmax, my nx, my dx, my x1, my ceiling, 2);
long nVoiced = 0, nUp = 0;
double lastFrequency = 0.0;
for (long i = 1; i <= my nx; i ++) {
double f = my frame [i]. candidate [1]. frequency;
thy frame [i]. candidate [1]. strength = my frame [i]. candidate [1]. strength;
if (f > 0.0 && f < my ceiling) {
nVoiced ++;
if (lastFrequency != 0.0) {
double fmin = lastFrequency * 0.7071, fmax = 2.0 * fmin;
while (f < fmin) { f *= 2.0; nUp ++; }
while (f > fmax) { f *= 0.5; nUp --; }
}
lastFrequency = thy frame [i]. candidate [1]. frequency = f;
}
}
thy ceiling *= 2.0; // make room for some octave jumps
while (nUp > nVoiced / 2) {
for (long i = 1; i <= thy nx; i ++)
thy frame [i]. candidate [1]. frequency *= 0.5;
nUp -= nVoiced;
}
while (nUp < - nVoiced / 2) {
for (long i = 1; i <= thy nx; i ++)
thy frame [i]. candidate [1]. frequency *= 2.0;
nUp += nVoiced;
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": octave jumps not killed.");
}
}
Pitch PitchTier_to_Pitch (PitchTier me, double dt, double pitchFloor, double pitchCeiling)
{
Pitch thee = NULL;
long i, nt;
double tmin = my xmin, tmax = my xmax, t1 = my xmin + dt / 2;
if (my points -> size < 1) return Melder_errorp1 (L"The PitchTier is empty.");
if (dt <= 0) return Melder_errorp1 (L"The time step should be a positive number.");
if (pitchFloor >= pitchCeiling) return Melder_errorp1 (L"The pitch ceiling must be a higher number than the pitch floor.");
nt = (tmax - tmin - t1) / dt;
if (t1 + nt * dt < tmax) nt++;
if (nt < 1) return Melder_errorp1 (L"Duration is too short.");
thee = Pitch_create (tmin, tmax, nt, dt, t1, pitchCeiling, 1);
if (thee == NULL) return NULL;
for (i = 1; i <= nt; i++)
{
Pitch_Frame frame = & thy frame [i];
Pitch_Candidate candidate = & frame -> candidate [1];
double t = t1 + (i - 1) * dt;
double f = RealTier_getValueAtTime (me, t);
if (f < pitchFloor || f > pitchCeiling) f = 0;
candidate -> frequency = f;
}
return thee;
}
Pitch Pitch_scaleTime (Pitch me, double scaleFactor) {
try {
double dx = my dx, x1 = my x1, xmax = my xmax;
if (scaleFactor != 1) {
dx = my dx * scaleFactor;
x1 = my xmin + 0.5 * dx;
xmax = my xmin + my nx * dx;
}
autoPitch thee = Pitch_create (my xmin, xmax, my nx, dx, x1, my ceiling, 2);
for (long i = 1; i <= my nx; i++) {
double f = my frame[i].candidate[1].frequency;
thy frame[i].candidate[1].strength = my frame[i].candidate[1].strength;
f /= scaleFactor;
if (f < my ceiling) {
thy frame[i].candidate[1].frequency = f;
}
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, ": not scaled.");
}
}
Pitch Matrix_to_Pitch (Matrix me) {
try {
autoPitch thee = Pitch_create (my xmin, my xmax, my nx, my dx, my x1, 5000, 2);
for (long i = 1; i <= my nx; i ++) {
Pitch_Frame frame = & thy frame [i];
if (my z [1] [i] == 0.0) {
Pitch_Frame_init (frame, 1);
frame->candidate[1].frequency = 0.0; // voiceless candidate always present
frame->candidate[1].strength = 0.4;
} else {
Pitch_Frame_init (frame, 2);
frame->intensity = 1;
frame->candidate[1].frequency = my z [1] [i];
frame->candidate[1].strength = 0.9;
frame->candidate[2].frequency = 0.0; // voiceless candidate always present
frame->candidate[2].strength = 0.4;
}
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, ": not converted to Pitch.");
}
}
Pitch Pitch_scaleTime (Pitch me, double scaleFactor)
{
Pitch thee = NULL;
long i;
double dx = my dx, x1 = my x1, xmax = my xmax;
if (scaleFactor != 1)
{
dx = my dx * scaleFactor;
x1 = my xmin + 0.5 * dx;
xmax = my xmin + my nx * dx;
}
thee = Pitch_create (my xmin, xmax, my nx, dx, x1, my ceiling, 2);
if ( thee == NULL) return NULL;
for (i = 1; i <= my nx; i++)
{
double f = my frame[i].candidate[1].frequency;
thy frame[i].candidate[1].strength = my frame[i].candidate[1].strength;
f /= scaleFactor;
if (f < my ceiling) thy frame[i].candidate[1].frequency = f;
}
return thee;
}
autoPitch SPINET_to_Pitch (SPINET me, double harmonicFallOffSlope, double ceiling, int maxnCandidates) {
try {
long nPointsPerOctave = 48;
double fmin = NUMerbToHertz (Sampled2_rowToY (me, 1));
double fmax = NUMerbToHertz (Sampled2_rowToY (me, my ny));
double fminl2 = NUMlog2 (fmin), fmaxl2 = NUMlog2 (fmax);
double points = (fmaxl2 - fminl2) * nPointsPerOctave;
double dfl2 = (fmaxl2 - fminl2) / (points - 1);
long nFrequencyPoints = (long) floor (points);
long maxHarmonic = (long) floor (fmax / fmin);
double maxStrength = 0.0, unvoicedCriterium = 0.45, maxPower = 0.0;
if (nFrequencyPoints < 2) {
Melder_throw (U"Frequency range too small.");
}
if (ceiling <= fmin) {
Melder_throw (U"Ceiling is smaller than centre frequency of lowest filter.");
}
autoPitch thee = Pitch_create (my xmin, my xmax, my nx, my dx, my x1, ceiling, maxnCandidates);
autoNUMvector<double> power (1, my nx);
autoNUMvector<double> pitch (1, nFrequencyPoints);
autoNUMvector<double> sumspec (1, nFrequencyPoints);
autoNUMvector<double> y (1, my ny);
autoNUMvector<double> yv2 (1, my ny);
autoNUMvector<double> fl2 (1, my ny);
// From ERB's to log (f)
for (long i = 1; i <= my ny; i++) {
double f = NUMerbToHertz (my y1 + (i - 1) * my dy);
fl2[i] = NUMlog2 (f);
}
// Determine global maximum power in frame
for (long j = 1; j <= my nx; j++) {
double p = 0.0;
for (long i = 1; i <= my ny; i++) {
p += my s[i][j];
}
if (p > maxPower) {
maxPower = p;
}
power[j] = p;
}
if (maxPower == 0.0) {
Melder_throw (U"No power");
}
for (long j = 1; j <= my nx; j++) {
Pitch_Frame pitchFrame = &thy frame[j];
pitchFrame -> intensity = power[j] / maxPower;
for (long i = 1; i <= my ny; i++) {
y[i] = my s[i][j];
}
NUMspline (fl2.peek(), y.peek(), my ny, 1e30, 1e30, yv2.peek());
for (long k = 1; k <= nFrequencyPoints; k++) {
double f = fminl2 + (k - 1) * dfl2;
NUMsplint (fl2.peek(), y.peek(), yv2.peek(), my ny, f, & pitch[k]);
sumspec[k] = 0.0;
}
// Formula (8): weighted harmonic summation.
for (long m = 1; m <= maxHarmonic; m++) {
double hm = 1 - harmonicFallOffSlope * NUMlog2 (m);
long kb = 1 + (long) floor (nPointsPerOctave * NUMlog2 (m));
for (long k = kb; k <= nFrequencyPoints; k++) {
if (pitch[k] > 0.0) {
sumspec[k - kb + 1] += pitch[k] * hm;
}
}
}
// into Pitch object
Pitch_Frame_init (pitchFrame, maxnCandidates);
pitchFrame -> nCandidates = 0; /* !!!!! */
Pitch_Frame_addPitch (pitchFrame, 0, 0, maxnCandidates); /* unvoiced */
for (long k = 2; k <= nFrequencyPoints - 1; k++) {
double y1 = sumspec[k - 1], y2 = sumspec[k], y3 = sumspec[k + 1];
if (y2 > y1 && y2 >= y3) {
double denum = y1 - 2.0 * y2 + y3, tmp = y3 - 4.0 * y2;
double x = dfl2 * (y1 - y3) / (2 * denum);
double f = pow (2.0, fminl2 + (k - 1) * dfl2 + x);
double strength = (2.0 * y1 * (4.0 * y2 + y3) - y1 * y1 - tmp * tmp) / (8.0 * denum);
if (strength > maxStrength) {
maxStrength = strength;
}
Pitch_Frame_addPitch (pitchFrame, f, strength, maxnCandidates);
}
}
}
// Scale the pitch strengths
for (long j = 1; j <= my nx; j++) {
double f0, localStrength;
Pitch_Frame_getPitch (&thy frame[j], &f0, &localStrength);
Pitch_Frame_resizeStrengths (&thy frame[j], localStrength / maxStrength, unvoicedCriterium);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Pitch created.");
}
}
Pitch Sound_to_Pitch_any (Sound me, double dt, /*timeStepStradygy related*/
double minimumPitch, /*Pitch settings realted*/
double periodsPerWindow, /*kTimeSoundAnalysisEditor_pitch_analysisMethod related*/
int maxnCandidates,
int method, /*method related*/
double silenceThreshold, double voicingThreshold, double octaveCost, double octaveJumpCost,
double voicedUnvoicedCost, double ceiling)
{
NUMfft_Table fftTable = NUMfft_Table_create();
double duration, t1;
double dt_window; /* Window length in seconds. */
long nsamp_window, halfnsamp_window; /* Number of samples per window. */
long nFrames, minimumLag, maximumLag;
long iframe, nsampFFT;
double interpolation_depth;
long nsamp_period, halfnsamp_period; /* Number of samples in longest period. */
long brent_ixmax, brent_depth;
double brent_accuracy; /* Obsolete. */
double globalPeak;
if (maxnCandidates < 2 || method < AC_HANNING && method > FCC_ACCURATE)
{
std::cout<<"Error: maxnCandidates: "<<maxnCandidates<<" method: "<<method<<"."<<std::endl;
std::cout<<"Sound_to_Pitch.cpp: Line 13. 69"<<std::endl;
return NULL;
}
if (maxnCandidates < ceiling / minimumPitch) maxnCandidates = ceiling / minimumPitch;
if (dt <= 0.0) dt = periodsPerWindow / minimumPitch / 4.0; /* e.g. 3 periods, 75 Hz: 10 milliseconds. */
switch (method) {
case AC_HANNING:
brent_depth = NUM_PEAK_INTERPOLATE_SINC70;
brent_accuracy = 1e-7;
interpolation_depth = 0.5;
break;
case AC_GAUSS:
periodsPerWindow *= 2; /* Because Gaussian window is twice as long. */
brent_depth = NUM_PEAK_INTERPOLATE_SINC700;
brent_accuracy = 1e-11;
interpolation_depth = 0.25; /* Because Gaussian window is twice as long. */
break;
case FCC_NORMAL:
brent_depth = NUM_PEAK_INTERPOLATE_SINC70;
brent_accuracy = 1e-7;
interpolation_depth = 1.0;
break;
case FCC_ACCURATE:
brent_depth = NUM_PEAK_INTERPOLATE_SINC700;
brent_accuracy = 1e-11;
interpolation_depth = 1.0;
break;
}
duration = my dx * my nx;
if (minimumPitch < periodsPerWindow / duration) {
std::cout<<"To analyse this Sound, minimum pitch must not be less than "<< periodsPerWindow / duration<<" Hz."<<std::endl;
std::cout<<"Sound_to_Pitch.cpp: Line 31.103"<<std::endl;
return NULL;
}
/*
* Determine the number of samples in the longest period.
* We need this to compute the local mean of the sound (looking one period in both directions),
* and to compute the local peak of the sound (looking half a period in both directions).
*/
nsamp_period = floor(1 / my dx / minimumPitch);
halfnsamp_period = nsamp_period / 2 + 1;
if (ceiling > 0.5 / my dx) ceiling = 0.5 / my dx;
// Determine window length in seconds and in samples.
dt_window = periodsPerWindow / minimumPitch;
nsamp_window = floor (dt_window / my dx);
halfnsamp_window = nsamp_window / 2 - 1;
if (halfnsamp_window < 2){
std::cout<<"Analysis window too short."<<std::endl;
std::cout<<"Sound_to_Pitch.cpp: Line 31.123"<<std::endl;
return NULL;
}
nsamp_window = halfnsamp_window * 2;
// Determine the minimum and maximum lags.
minimumLag = floor (1 / my dx / ceiling);
if (minimumLag < 2) minimumLag = 2;
maximumLag = floor (nsamp_window / periodsPerWindow) + 2;
if (maximumLag > nsamp_window) maximumLag = nsamp_window;
/*
* Determine the number of frames.
* Fit as many frames as possible symmetrically in the total duration.
* We do this even for the forward cross-correlation method,
* because that allows us to compare the two methods.
*/
if(!Sampled_shortTermAnalysis (me, method >= FCC_NORMAL ? 1 / minimumPitch + dt_window : dt_window, dt, & nFrames, & t1)){
std::cout<<"The pitch analysis would give zero pitch frames."<<std::endl;
std::cout<<"Sound_to_Pitch.cpp: Line 31.142"<<std::endl;
return NULL;
}
// Create the resulting pitch contour.
Pitch thee = Pitch_create (my xmin, my xmax, nFrames, dt, t1, ceiling, maxnCandidates);
// Compute the global absolute peak for determination of silence threshold.
globalPeak = 0.0;
for (long channel = 1; channel <= my ny; channel ++) {
double mean = 0.0;
for (long i = 1; i <= my nx; i ++) {
mean += my z [channel] [i];
}
mean /= my nx;
for (long i = 1; i <= my nx; i ++) {
double value = fabs (my z [channel] [i] - mean);
if (value > globalPeak) globalPeak = value;
}
}
if (globalPeak == 0.0) return thee;
double **frame, *ac, *window, *windowR;
if (method >= FCC_NORMAL) { /* For cross-correlation analysis. */
// Create buffer for cross-correlation analysis.
frame = (double **)malloc(sizeof(double *) * (my ny + 1));
for(long i = 1; i <= my ny; ++ i){
frame[i] = (double *)malloc(sizeof(double) * (nsamp_window + 1));
for(long j = 1; j <= nsamp_window; ++ j)
frame[i][j] = 0.0;
} /****frame.reset (1, my ny, 1, nsamp_window);****/
brent_ixmax = nsamp_window * interpolation_depth;
} else { /* For autocorrelation analysis. */
/*
* Compute the number of samples needed for doing FFT.
* To avoid edge effects, we have to append zeroes to the window.
* The maximum lag considered for maxima is maximumLag.
* The maximum lag used in interpolation is nsamp_window * interpolation_depth.
*/
nsampFFT = 1;
while (nsampFFT < nsamp_window * (1 + interpolation_depth)) nsampFFT *= 2;
// Create buffers for autocorrelation analysis.
frame = (double **)malloc(sizeof(double *) * (my ny + 1));
for(long i = 1; i <= my ny; ++ i){
frame [i] = (double *)malloc(sizeof(double) * (nsampFFT + 1));
for(long j = 0; j <= nsampFFT; ++ j)
frame[i][j] = 0.0;
} /****frame.reset (1, my ny, 1, nsampFFT);****/
window = (double *)malloc(sizeof(double) * (nsamp_window + 1));
for(long i = 0; i <= nsamp_window; ++ i)
window[i] = 0.0;
/****window.reset (1, nsamp_window);****/
windowR = (double *)malloc(sizeof(double) * (nsampFFT + 1));
ac = (double *)malloc(sizeof(double) * (nsampFFT + 1));
for(long i = 0; i <= nsampFFT; ++ i)
windowR[i] = ac[i] = 0.0;
/****windowR.reset (1, nsampFFT); ac.reset (1, nsampFFT); ****/
NUMfft_Table_init (fftTable, nsampFFT);
/*
* A Gaussian or Hanning window is applied against phase effects.
* The Hanning window is 2 to 5 dB better for 3 periods/window.
* The Gaussian window is 25 to 29 dB better for 6 periods/window.
*/
if (method == AC_GAUSS) { /* Gaussian window. */
double imid = 0.5 * (nsamp_window + 1), edge = exp (-12.0);
for (long i = 1; i <= nsamp_window; i ++)
window[i] = (exp(-48.0*(i-imid)*(i-imid) /
(nsamp_window + 1) / (nsamp_window + 1)) - edge) / (1 - edge);
} else { /* Hanning window*/
for (long i = 1; i <= nsamp_window; i ++)
window [i] = 0.5 - 0.5 * cos (i * 2 * NUMpi / (nsamp_window + 1));
}
// Compute the normalized autocorrelation of the window.
for (long i = 1; i <= nsamp_window; i ++) windowR [i] = window [i];
NUMfft_forward (fftTable, windowR);
windowR [1] *= windowR [1]; // DC component
for (long i = 2; i < nsampFFT; i += 2) {
windowR [i] = windowR [i] * windowR [i] + windowR [i+1] * windowR [i+1];
windowR [i + 1] = 0.0; // power spectrum: square and zero
}
windowR [nsampFFT] *= windowR [nsampFFT]; // Nyquist frequency
NUMfft_backward (fftTable, windowR); // autocorrelation
for (long i = 2; i <= nsamp_window; i ++) windowR [i] /= windowR [1]; // normalize
windowR [1] = 1.0; // normalize
brent_ixmax = nsamp_window * interpolation_depth;
}
double *r = (double *) malloc( sizeof(double) * (2 * (nsamp_window + 1) + 1) );
r += nsamp_window + 1; //make "r" become a symetrical vectr
long *imax = (long *) malloc( sizeof(long) * (maxnCandidates + 1));
double *localMean = (double *) malloc( sizeof(double) * (my ny + 1));
for(iframe = 1; iframe <= nFrames; iframe ++){
Pitch_Frame pitchFrame = & thy frame[iframe];
double t = thy x1 + (iframe - 1) *(thy dx), localPeak;
long leftSample = (long) floor((t - my x1) / my dx) + 1;
long rightSample = leftSample + 1;
long startSample, endSample;
for(long channel = 1; channel <= my ny; ++ channel){ //Compute the local mean; look one longest period to both sides.
startSample = rightSample - nsamp_period;
endSample = leftSample + nsamp_period;
if ( startSample < 0 ) {
std::cout<<"StartSample < 1"<<std::endl;
std::cout<<"Sound_to_Pitch.cpp: Line 31"<<std::endl;
return NULL;
}
if (endSample > my nx){
std::cout<<"EndSample > my nx"<<std::endl;
std::cout<<"Sound_to_Pitch.cpp: Line 31.262"<<std::endl;
return NULL;
}
localMean[channel] = 0.0;
for (long i = startSample; i <= endSample; i ++) {
localMean[channel] += my z[channel][i];
}
localMean[channel] /= 2 * nsamp_period;
// Copy a window to a frame and subtract the local mean. We are going to kill the DC component before windowing.
startSample = rightSample - halfnsamp_window;
endSample = leftSample + halfnsamp_window;
if ( startSample < 1 ) {
std::cout<<"StartSample < 1"<<std::endl;
std::cout<<"Sound_to_Pitch.cpp: Line 31.281"<<std::endl;
return NULL;
}
if (endSample > my nx){
std::cout<<"EndSample > my nx"<<std::endl;
std::cout<<"Sound_to_Pitch.cpp: Line 31.287"<<std::endl;
return NULL;
}
if (method < FCC_NORMAL) {
for (long j = 1, i = startSample; j <= nsamp_window; j ++)
frame [channel] [j] = (my z [channel] [i ++] - localMean [channel]) * window [j];
for (long j = nsamp_window + 1; j <= nsampFFT; j ++)
frame [channel] [j] = 0.0;
} else {
for (long j = 1, i = startSample; j <= nsamp_window; j ++)
frame [channel] [j] = my z [channel] [i ++] - localMean [channel];
}
}
// Compute the local peak; look half a longest period to both sides.
localPeak = 0.0;
if ((startSample = halfnsamp_window + 1 - halfnsamp_period) < 1) startSample = 1;
if ((endSample = halfnsamp_window + halfnsamp_period) > nsamp_window) endSample = nsamp_window;
for (long channel = 1; channel <= my ny; channel ++) {
for (long j = startSample; j <= endSample; j ++) {
double value = fabs (frame [channel] [j]);
if (value > localPeak) localPeak = value;
}
}
pitchFrame->intensity = localPeak > globalPeak ? 1.0 : localPeak / globalPeak;
// Compute the correlation into the array 'r'.
if (method >= FCC_NORMAL) {
double startTime = t - 0.5 * (1.0 / minimumPitch + dt_window);
long localSpan = maximumLag + nsamp_window, localMaximumLag, offset;
if ((startSample = (long) floor ((startTime - my x1) / my dx)) + 1 < 1)
startSample = 1;
if (localSpan > my nx + 1 - startSample) localSpan = my nx + 1 - startSample;
localMaximumLag = localSpan - nsamp_window;
offset = startSample - 1;
double sumx2 = 0; /* Sum of squares. */
for (long channel = 1; channel <= my ny; channel ++) { ///channel = 1; channel <= my ny
double *amp = my z[channel] + offset;
for (long i = 1; i <= nsamp_window; i ++) { ///i = 1; i <= nsamp_window
double x = amp[i] - localMean[channel];
sumx2 += x * x;
}
}
double sumy2 = sumx2; /* At zero lag, these are still equal. */
r[0] = 1.0;
for (long i = 1; i <= localMaximumLag; i ++) {
double product = 0.0;
for (long channel = 1; channel <= my ny; channel ++) { ///channel = 1; channel <= my ny
double *amp = my z[channel] + offset;
double y0 = amp[i] - localMean[channel];
double yZ = amp[i + nsamp_window] - localMean[channel];
sumy2 += yZ * yZ - y0 * y0;
for (long j = 1; j <= nsamp_window; j ++) { ///j = 1; j <= nsamp_window
double x = amp[j] - localMean[channel];
double y = amp[i + j] - localMean[channel];
product += x * y;
}
}
r[- i] = r[i] = product / sqrt (sumx2 * sumy2);
}
} else {
// The FFT of the autocorrelation is the power spectrum.
for (long i = 1; i <= nsampFFT; i ++)
ac [i] = 0.0;
for (long channel = 1; channel <= my ny; channel ++) {
NUMfft_forward (fftTable, frame [channel]); /* Complex spectrum. */
ac [1] += frame [channel] [1] * frame [channel] [1]; /* DC component. */
for (long i = 2; i < nsampFFT; i += 2) {
ac [i] += frame [channel] [i] * frame [channel] [i] + frame [channel] [i+1] * frame [channel] [i+1]; /* Power spectrum. */
}
ac [nsampFFT] += frame [channel] [nsampFFT] * frame [channel] [nsampFFT]; /* Nyquist frequency. */
}
NUMfft_backward (fftTable, ac); /* Autocorrelation. */
/*
* Normalize the autocorrelation to the value with zero lag,
* and divide it by the normalized autocorrelation of the window.
*/
r [0] = 1.0;
for (long i = 1; i <= brent_ixmax; i ++)
r [- i] = r [i] = ac [i + 1] / (ac [1] * windowR [i + 1]);
}
// Create (too much) space for candidates
Pitch_Frame_init (pitchFrame, maxnCandidates);
// Register the first candidate, which is always present: voicelessness.
pitchFrame->nCandidates = 1;
pitchFrame->candidate[1].frequency = 0.0; /* Voiceless: always present. */
pitchFrame->candidate[1].strength = 0.0;
/*
* Shortcut: absolute silence is always voiceless.
* Go to next frame.
*/
if (localPeak == 0) continue;
/*
* Find the strongest maxima of the correlation of this frame,
* and register them as candidates.
*/
imax[1] = 0;
for (long i = 2; i < maximumLag && i < brent_ixmax; i ++)
if (r[i] > 0.5 * voicingThreshold && /* Not too unvoiced? */
r[i] > r[i-1] && r[i] >= r[i+1]) /* Maximum ? */
{
int place = 0;
// Use parabolic interpolation for first estimate of frequency,and sin(x)/x interpolation to compute the strength of this frequency.
double dr = 0.5 * (r[i+1] - r[i-1]);
double d2r = 2 * r[i] - r[i-1] - r[i+1];
double frequencyOfMaximum = 1 / my dx / (i + dr / d2r);
long offset = - brent_ixmax - 1;
double strengthOfMaximum = /* method & 1 ? */
NUM_interpolate_sinc (& r[offset], brent_ixmax - offset, 1 / my dx / frequencyOfMaximum - offset, 30)
/* : r [i] + 0.5 * dr * dr / d2r */;
/* High values due to short windows are to be reflected around 1. */
if (strengthOfMaximum > 1.0) strengthOfMaximum = 1.0 / strengthOfMaximum;
// Find a place for this maximum.
if (pitchFrame->nCandidates < thy maxnCandidates) { /* Is there still a free place? */
place = ++ pitchFrame->nCandidates;
} else {
/* Try the place of the weakest candidate so far. */
double weakest = 2;
for (int iweak = 2; iweak <= thy maxnCandidates; iweak ++) { //iweak = 2; iweak <= thy maxnCandidates;
/* High frequencies are to be favoured */
/* if we want to analyze a perfectly periodic signal correctly. */
double localStrength = pitchFrame->candidate[iweak].strength - octaveCost *
NUMlog2 (minimumPitch / pitchFrame->candidate[iweak].frequency);
if (localStrength < weakest) {
weakest = localStrength;
place = iweak;
}
}
/* If this maximum is weaker than the weakest candidate so far, give it no place. */
if (strengthOfMaximum - octaveCost * NUMlog2 (minimumPitch / frequencyOfMaximum) <= weakest)
place = 0;
}
if (place) { /* Have we found a place for this candidate? */
pitchFrame->candidate[place].frequency = frequencyOfMaximum;
pitchFrame->candidate[place].strength = strengthOfMaximum;
imax [place] = i;
}
}
// Second pass: for extra precision, maximize sin(x)/x interpolation ('sinc').
for (long i = 2; i <= pitchFrame->nCandidates; i ++) {
if (method != AC_HANNING || pitchFrame->candidate[i].frequency > 0.0 / my dx) {
double xmid, ymid;
long offset = - brent_ixmax - 1;
ymid = NUMimproveMaximum (& r[offset], brent_ixmax - offset, imax[i] - offset,
pitchFrame->candidate[i].frequency > 0.3 / my dx ? NUM_PEAK_INTERPOLATE_SINC700 : brent_depth, & xmid);
xmid += offset;
pitchFrame->candidate[i].frequency = 1.0 / my dx / xmid;
if (ymid > 1.0) ymid = 1.0 / ymid;
pitchFrame->candidate[i].strength = ymid;
}
}
} /* Next frame. */
Pitch_pathFinder (thee, silenceThreshold, voicingThreshold,octaveCost, octaveJumpCost,
voicedUnvoicedCost, ceiling, false);
//false: Melder_debug == 31 ? true : false Melder_debug 31: Pitch analysis: formant pulling on
return thee;
}
Pitch SPINET_to_Pitch (SPINET me, double harmonicFallOffSlope, double ceiling, int maxnCandidates)
{
Pitch thee = NULL;
long i, j, k, m, nPointsPerOctave = 48;
double fmin = NUMerbToHertz (Sampled2_rowToY (me, 1));
double fmax = NUMerbToHertz (Sampled2_rowToY (me, my ny));
double fminl2 = NUMlog2 (fmin), fmaxl2 = NUMlog2 (fmax);
double points = (fmaxl2 - fminl2) * nPointsPerOctave;
double dfl2 = (fmaxl2 - fminl2) / (points - 1);
long nFrequencyPoints = points;
long maxHarmonic = fmax / fmin;
double maxStrength = 0, unvoicedCriterium = 0.45;
double maxPower = 0, *sumspec = NULL, *power = NULL;
double *y = NULL, *y2 = NULL, *pitch = NULL, *fl2 = NULL;
if (nFrequencyPoints < 2) return Melder_errorp1 (L"SPINET_to_Pitch: frequency range too small.");
if (ceiling <= fmin) return Melder_errorp1 (L"SPINET_to_Pitch: ceiling is smaller than centre "
"frequency of lowest filter.");
if (! (thee = Pitch_create (my xmin, my xmax, my nx, my dx, my x1,
ceiling, maxnCandidates)) ||
! (power = NUMdvector (1, my nx)) ||
! (pitch = NUMdvector (1, nFrequencyPoints)) ||
! (sumspec = NUMdvector (1, nFrequencyPoints)) ||
! (y = NUMdvector (1, my ny)) ||
! (y2 = NUMdvector (1, my ny)) ||
! (fl2 = NUMdvector (1, my ny))) goto cleanup;
/*
From ERB's to log (f)
*/
for (i=1; i <= my ny; i++)
{
double f = NUMerbToHertz (my y1 + (i - 1) * my dy);
fl2[i] = NUMlog2 (f);
}
/*
Determine global maximum power in frame
*/
for (j=1; j <= my nx; j++)
{
double p = 0;
for (i=1; i <= my ny; i++) p += my s[i][j];
if (p > maxPower) maxPower = p;
power[j] = p;
}
if (maxPower == 0) goto cleanup;
for (j=1; j <= my nx; j++)
{
Pitch_Frame pitchFrame = &thy frame[j];
pitchFrame->intensity = power[j] / maxPower;
for (i=1; i <= my ny; i++) y[i] = my s[i][j];
if (! NUMspline (fl2, y, my ny, 1e30, 1e30, y2)) goto cleanup;
for (k=1; k <= nFrequencyPoints; k++)
{
double f = fminl2 + (k-1) * dfl2;
NUMsplint (fl2, y, y2, my ny, f, & pitch[k]);
sumspec[k] = 0;
}
/*
Formula (8): weighted harmonic summation.
*/
for (m=1; m <= maxHarmonic; m++)
{
double hm = 1 - harmonicFallOffSlope * NUMlog2 (m);
long kb = 1 + floor (nPointsPerOctave * NUMlog2 (m));
for (k=kb; k <= nFrequencyPoints; k++)
{
if (pitch[k] > 0) sumspec[k-kb+1] += pitch[k] * hm;
}
}
/*
into Pitch object
*/
if (! Pitch_Frame_init (pitchFrame, maxnCandidates)) goto cleanup;
pitchFrame->nCandidates = 0; /* !!!!! */
Pitch_Frame_addPitch (pitchFrame, 0, 0, maxnCandidates); /* unvoiced */
for (k=2; k <= nFrequencyPoints-1; k++)
{
double y1 = sumspec[k-1], y2 = sumspec[k], y3 = sumspec[k+1];
if (y2 > y1 && y2 >= y3)
{
double denum = y1 - 2 * y2 + y3, tmp = y3 - 4 * y2;
double x = dfl2 * (y1 - y3) / (2 * denum);
double f = pow (2, fminl2 + (k - 1) * dfl2 + x);
double strength = (2 * y1 * (4 * y2 + y3) - y1 * y1 - tmp * tmp) / (8 * denum);
if (strength > maxStrength) maxStrength = strength;
Pitch_Frame_addPitch (pitchFrame, f, strength, maxnCandidates);
}
}
}
/*
Scale the pitch strengths
*/
for (j=1; j <= my nx; j++)
{
double f0, localStrength;
Pitch_Frame_getPitch (&thy frame[j], &f0, &localStrength);
Pitch_Frame_resizeStrengths (&thy frame[j], localStrength / maxStrength, unvoicedCriterium);
}
cleanup:
NUMdvector_free (pitch, 1); NUMdvector_free (sumspec, 1);
NUMdvector_free (y, 1); NUMdvector_free (y2, 1);
NUMdvector_free (fl2, 1);NUMdvector_free (power, 1);
if (! Melder_hasError()) return thee;
forget (thee);
return Melder_errorp1 (L"SPINET_to_Pitch: not performed.");
}
Pitch Sound_to_Pitch_shs (Sound me, double timeStep, double minimumPitch,
double maximumFrequency, double ceiling, long maxnSubharmonics, long maxnCandidates,
double compressionFactor, long nPointsPerOctave) {
try {
double firstTime, newSamplingFrequency = 2 * maximumFrequency;
double windowDuration = 2 / minimumPitch, halfWindow = windowDuration / 2;
double atans = nPointsPerOctave * NUMlog2 (65.0 / 50.0) - 1;
// Number of speech samples in the downsampled signal in each frame:
// 100 for windowDuration == 0.04 and newSamplingFrequency == 2500
long nx = lround (windowDuration * newSamplingFrequency);
// The minimum number of points for the fft is 256.
long nfft = 1;
while ( (nfft *= 2) < nx || nfft <= 128) {
;
}
long nfft2 = nfft / 2 + 1;
double frameDuration = nfft / newSamplingFrequency;
double df = newSamplingFrequency / nfft;
// The number of points on the octave scale
double fminl2 = NUMlog2 (minimumPitch), fmaxl2 = NUMlog2 (maximumFrequency);
long nFrequencyPoints = (long) floor ((fmaxl2 - fminl2) * nPointsPerOctave);
double dfl2 = (fmaxl2 - fminl2) / (nFrequencyPoints - 1);
autoSound sound = Sound_resample (me, newSamplingFrequency, 50);
long numberOfFrames;
Sampled_shortTermAnalysis (sound.peek(), windowDuration, timeStep, &numberOfFrames, &firstTime);
autoSound frame = Sound_createSimple (1, frameDuration, newSamplingFrequency);
autoSound hamming = Sound_createHamming (nx / newSamplingFrequency, newSamplingFrequency);
autoPitch thee = Pitch_create (my xmin, my xmax, numberOfFrames, timeStep, firstTime,
ceiling, maxnCandidates);
autoNUMvector<double> cc (1, numberOfFrames);
autoNUMvector<double> specAmp (1, nfft2);
autoNUMvector<double> fl2 (1, nfft2);
autoNUMvector<double> yv2 (1, nfft2);
autoNUMvector<double> arctg (1, nFrequencyPoints);
autoNUMvector<double> al2 (1, nFrequencyPoints);
Melder_assert (frame->nx >= nx);
Melder_assert (hamming->nx == nx);
// Compute the absolute value of the globally largest amplitude w.r.t. the global mean.
double globalMean, globalPeak;
Sound_localMean (sound.peek(), sound -> xmin, sound -> xmax, &globalMean);
Sound_localPeak (sound.peek(), sound -> xmin, sound -> xmax, globalMean, &globalPeak);
/*
For the cubic spline interpolation we need the frequencies on an octave
scale, i.e., a log2 scale. All frequencies must be DIFFERENT, otherwise
the cubic spline interpolation will give corrupt results.
Because log2(f==0) is not defined, we use the heuristic: f[2]-f[1] == f[3]-f[2].
*/
for (long i = 2; i <= nfft2; i++) {
fl2[i] = NUMlog2 ( (i - 1) * df);
}
fl2[1] = 2 * fl2[2] - fl2[3];
// Calculate frequencies regularly spaced on a log2-scale and
// the frequency weighting function.
for (long i = 1; i <= nFrequencyPoints; i++) {
arctg[i] = 0.5 + atan (3 * (i - atans) / nPointsPerOctave) / NUMpi;
}
// Perform the analysis on all frames.
for (long i = 1; i <= numberOfFrames; i++) {
Pitch_Frame pitchFrame = &thy frame[i];
double hm = 1, f0, pitch_strength, localMean, localPeak;
double tmid = Sampled_indexToX (thee.peek(), i); /* The center of this frame */
long nx_tmp = frame -> nx;
// Copy a frame from the sound, apply a hamming window. Get local 'intensity'
frame -> nx = nx; /*begin vies */
Sound_into_Sound (sound.peek(), frame.peek(), tmid - halfWindow);
Sounds_multiply (frame.peek(), hamming.peek());
Sound_localMean (sound.peek(), tmid - 3 * halfWindow, tmid + 3 * halfWindow, &localMean);
Sound_localPeak (sound.peek(), tmid - halfWindow, tmid + halfWindow, localMean, &localPeak);
pitchFrame -> intensity = localPeak > globalPeak ? 1 : localPeak / globalPeak;
frame -> nx = nx_tmp; /* einde vies */
// Get the Fourier spectrum.
autoSpectrum spec = Sound_to_Spectrum (frame.peek(), 1);
Melder_assert (spec->nx == nfft2);
// From complex spectrum to amplitude spectrum.
for (long j = 1; j <= nfft2; j++) {
double rs = spec -> z[1][j], is = spec -> z[2][j];
specAmp[j] = sqrt (rs * rs + is * is);
}
// Enhance the peaks in the spectrum.
spec_enhance_SHS (specAmp.peek(), nfft2);
// Smooth the enhanced spectrum.
spec_smoooth_SHS (specAmp.peek(), nfft2);
// Go to a logarithmic scale and perform cubic spline interpolation to get
// spectral values for the increased number of frequency points.
NUMspline (fl2.peek(), specAmp.peek(), nfft2, 1e30, 1e30, yv2.peek());
for (long j = 1; j <= nFrequencyPoints; j++) {
double f = fminl2 + (j - 1) * dfl2;
NUMsplint (fl2.peek(), specAmp.peek(), yv2.peek(), nfft2, f, &al2[j]);
}
// Multiply by frequency selectivity of the auditory system.
for (long j = 1; j <= nFrequencyPoints; j++) al2[j] = al2[j] > 0 ?
al2[j] * arctg[j] : 0;
// The subharmonic summation. Shift spectra in octaves and sum.
Pitch_Frame_init (pitchFrame, maxnCandidates);
autoNUMvector<double> sumspec (1, nFrequencyPoints);
pitchFrame -> nCandidates = 0; /* !!!!! */
for (long m = 1; m <= maxnSubharmonics + 1; m++) {
long kb = 1 + (long) floor (nPointsPerOctave * NUMlog2 (m));
for (long k = kb; k <= nFrequencyPoints; k++) {
sumspec[k - kb + 1] += al2[k] * hm;
}
hm *= compressionFactor;
}
// First register the voiceless candidate (always present).
Pitch_Frame_addPitch (pitchFrame, 0, 0, maxnCandidates);
/*
Get the best local estimates for the pitch as the maxima of the
subharmonic sum spectrum by parabolic interpolation on three points:
The formula for a parabole with a maximum is:
y(x) = a - b (x - c)^2 with a, b, c >= 0
The three points are (-x, y1), (0, y2) and (x, y3).
The solution for a (the maximum) and c (the position) is:
a = (2 y1 (4 y2 + y3) - y1^2 - (y3 - 4 y2)^2)/( 8 (y1 - 2 y2 + y3)
c = dx (y1 - y3) / (2 (y1 - 2 y2 + y3))
(b = (2 y2 - y1 - y3) / (2 dx^2) )
*/
for (long k = 2; k <= nFrequencyPoints - 1; k++) {
double y1 = sumspec[k - 1], y2 = sumspec[k], y3 = sumspec[k + 1];
if (y2 > y1 && y2 >= y3) {
double denum = y1 - 2 * y2 + y3, tmp = y3 - 4 * y2;
double x = dfl2 * (y1 - y3) / (2 * denum);
double f = pow (2, fminl2 + (k - 1) * dfl2 + x);
double strength = (2 * y1 * (4 * y2 + y3) - y1 * y1 - tmp * tmp) / (8 * denum);
Pitch_Frame_addPitch (pitchFrame, f, strength, maxnCandidates);
}
}
/*
Check whether f0 corresponds to an actual periodicity T = 1 / f0:
correlate two signal periods of duration T, one starting at the
middle of the interval and one starting T seconds before.
If there is periodicity the correlation coefficient should be high.
However, some sounds do not show any regularity, or very low
frequency and regularity, and nevertheless have a definite
pitch, e.g. Shepard sounds.
*/
Pitch_Frame_getPitch (pitchFrame, &f0, &pitch_strength);
if (f0 > 0) {
cc[i] = Sound_correlateParts (sound.peek(), tmid - 1.0 / f0, tmid, 1.0 / f0);
}
}
// Base V/UV decision on correlation coefficients.
// Resize the pitch strengths w.r.t. the cc.
double vuvCriterium = 0.52;
for (long i = 1; i <= numberOfFrames; i++) {
Pitch_Frame_resizeStrengths (& thy frame[i], cc[i], vuvCriterium);
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, U": no Pitch (shs) created.");
}
}
