# HG changeset patch
# User Chris Cannam
# Date 1538482461 -3600
# Node ID 3b2fed77a6cfb6793857a7005ede60e1ede8dff6
# Parent cd6169f7940a8f8f7f2f5fe2fb9e5cbdb605866a
Indent
diff -r cd6169f7940a -r 3b2fed77a6cf FChTransformF0gram.cpp
--- a/FChTransformF0gram.cpp Tue Oct 02 13:13:36 2018 +0100
+++ b/FChTransformF0gram.cpp Tue Oct 02 13:14:21 2018 +0100
@@ -13,20 +13,21 @@
You should have received a copy of the GNU General Public License
along with this program. If not, see .
- */
+*/
#include "FChTransformF0gram.h"
#include "FChTransformUtils.h"
#include
#include
//#define DEBUG
+
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
FChTransformF0gram::FChTransformF0gram(float inputSampleRate) :
-Plugin(inputSampleRate),
-m_currentProgram("default"),
-m_stepSize(0), // We are using 0 for step and block size to indicate "not yet set".
-m_blockSize(0) {
+ Plugin(inputSampleRate),
+ m_currentProgram("default"),
+ m_stepSize(0), // We are using 0 for step and block size to indicate "not yet set".
+ m_blockSize(0) {
m_fs = inputSampleRate;
// max frequency of interest (Hz)
@@ -50,8 +51,8 @@
// glogs parameters
m_glogs_params.HP_logS = true;
m_glogs_params.att_subharms = 1;
- // display parameters
- m_f0gram_mode = true;
+ // display parameters
+ m_f0gram_mode = true;
m_glogs_params.median_poly_coefs[0] = -0.000000058551680;
m_glogs_params.median_poly_coefs[1] = -0.000006945207775;
@@ -368,7 +369,7 @@
return m_f0_params.prefer_mean;
} else if (identifier == "f0_prefer_stdev") {
return m_f0_params.prefer_stdev;
- } else if (identifier == "f0gram_mode") {
+ } else if (identifier == "f0gram_mode") {
return m_f0gram_mode;
} else {
return 0.f;
@@ -462,7 +463,7 @@
m_num_f0s = 0;
- m_f0gram_mode = 1;
+ m_f0gram_mode = 1;
}
}
@@ -493,10 +494,10 @@
d.unit = "Hertz";
d.hasFixedBinCount = true;
//d.binCount = m_num_f0s;
- //d.binCount = m_blockSize/2+1;
- //d.binCount = m_warp_params.nsamps_twarp/2+1;
- //d.binCount = m_warpings.nsamps_torig;
- d.binCount = m_f0_params.num_octs*m_f0_params.num_f0s_per_oct;
+ //d.binCount = m_blockSize/2+1;
+ //d.binCount = m_warp_params.nsamps_twarp/2+1;
+ //d.binCount = m_warpings.nsamps_torig;
+ d.binCount = m_f0_params.num_octs*m_f0_params.num_f0s_per_oct;
d.binNames = f0values;
d.hasKnownExtents = false;
d.isQuantized = false;
@@ -510,7 +511,7 @@
bool
FChTransformF0gram::initialise(size_t channels, size_t stepSize, size_t blockSize) {
if (channels < getMinChannelCount() ||
- channels > getMaxChannelCount()) return false;
+ channels > getMaxChannelCount()) return false;
// set blockSize and stepSize (but changed below)
m_blockSize = blockSize;
@@ -527,22 +528,22 @@
/* initialise m_f0_params */
/* initialise m_glogs_params */
- design_GLogS();
+ design_GLogS();
/* design of FChT */
// design_fcht(m_warps, m_accums, m_f0s)
design_FChT();
- design_FFT();
+ design_FFT();
- design_LPF();
+ design_LPF();
- design_time_window();
+ design_time_window();
- // Create Hanning window for warped signals
- mp_HanningWindow = new double[m_warp_params.nsamps_twarp];
- bool normalize = false;
- hanning_window(mp_HanningWindow, m_warp_params.nsamps_twarp, normalize);
+ // Create Hanning window for warped signals
+ mp_HanningWindow = new double[m_warp_params.nsamps_twarp];
+ bool normalize = false;
+ hanning_window(mp_HanningWindow, m_warp_params.nsamps_twarp, normalize);
return true;
}
@@ -550,102 +551,102 @@
void
FChTransformF0gram::design_GLogS() {
- // total number & initial quantity of f0s
- m_glogs_init_f0s = (size_t)(((double)m_f0_params.num_f0s_per_oct)*log2(5.0))+1;
- m_glogs_num_f0s = (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct + m_glogs_init_f0s;
+ // total number & initial quantity of f0s
+ m_glogs_init_f0s = (size_t)(((double)m_f0_params.num_f0s_per_oct)*log2(5.0))+1;
+ m_glogs_num_f0s = (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct + m_glogs_init_f0s;
- // Initialize arrays
- m_glogs_f0 = new double[m_glogs_num_f0s];
- m_glogs = new double[m_glogs_num_f0s*m_warp_params.num_warps];
- m_glogs_n = new size_t[m_glogs_num_f0s];
- m_glogs_index = new size_t[m_glogs_num_f0s];
+ // Initialize arrays
+ m_glogs_f0 = new double[m_glogs_num_f0s];
+ m_glogs = new double[m_glogs_num_f0s*m_warp_params.num_warps];
+ m_glogs_n = new size_t[m_glogs_num_f0s];
+ m_glogs_index = new size_t[m_glogs_num_f0s];
- // Compute f0 values
- m_glogs_harmonic_count = 0;
- double factor = (double)(m_warp_params.nsamps_twarp/2)/(double)(m_warp_params.nsamps_twarp/2+1);
- for (size_t i = 0; i < m_glogs_num_f0s; i++) {
- m_glogs_f0[i] = (m_f0_params.f0min/5.0)*pow(2.0,(double)i/(double)m_f0_params.num_f0s_per_oct);
- // for every f0 compute number of partials less or equal than m_fmax.
- m_glogs_n[i] = m_fmax*factor/m_glogs_f0[i];
- m_glogs_index[i] = m_glogs_harmonic_count;
- m_glogs_harmonic_count += m_glogs_n[i];
- }
+ // Compute f0 values
+ m_glogs_harmonic_count = 0;
+ double factor = (double)(m_warp_params.nsamps_twarp/2)/(double)(m_warp_params.nsamps_twarp/2+1);
+ for (size_t i = 0; i < m_glogs_num_f0s; i++) {
+ m_glogs_f0[i] = (m_f0_params.f0min/5.0)*pow(2.0,(double)i/(double)m_f0_params.num_f0s_per_oct);
+ // for every f0 compute number of partials less or equal than m_fmax.
+ m_glogs_n[i] = m_fmax*factor/m_glogs_f0[i];
+ m_glogs_index[i] = m_glogs_harmonic_count;
+ m_glogs_harmonic_count += m_glogs_n[i];
+ }
- // Initialize arrays for interpolation
- m_glogs_posint = new size_t[m_glogs_harmonic_count];
- m_glogs_posfrac = new double[m_glogs_harmonic_count];
- m_glogs_interp = new double[m_glogs_harmonic_count];
+ // Initialize arrays for interpolation
+ m_glogs_posint = new size_t[m_glogs_harmonic_count];
+ m_glogs_posfrac = new double[m_glogs_harmonic_count];
+ m_glogs_interp = new double[m_glogs_harmonic_count];
- // Compute int & frac of interpolation positions
- size_t aux_index = 0;
- double aux_pos;
- for (size_t i = 0; i < m_glogs_num_f0s; i++) {
- for (size_t j = 1; j <= m_glogs_n[i]; j++) {
- // indice en el vector de largo t_warp/2+1 donde el ultimo valor corresponde a f=m_fmax
- aux_pos = ((double)j*m_glogs_f0[i])*((double)(m_warp_params.nsamps_twarp/2+1))/m_fmax;
- m_glogs_posint[aux_index] = (size_t)aux_pos;
- m_glogs_posfrac[aux_index] = aux_pos - (double)m_glogs_posint[aux_index];
- aux_index++;
- }
- }
+ // Compute int & frac of interpolation positions
+ size_t aux_index = 0;
+ double aux_pos;
+ for (size_t i = 0; i < m_glogs_num_f0s; i++) {
+ for (size_t j = 1; j <= m_glogs_n[i]; j++) {
+ // indice en el vector de largo t_warp/2+1 donde el ultimo valor corresponde a f=m_fmax
+ aux_pos = ((double)j*m_glogs_f0[i])*((double)(m_warp_params.nsamps_twarp/2+1))/m_fmax;
+ m_glogs_posint[aux_index] = (size_t)aux_pos;
+ m_glogs_posfrac[aux_index] = aux_pos - (double)m_glogs_posint[aux_index];
+ aux_index++;
+ }
+ }
- // Third harmonic attenuation
- double aux_third_harmonic;
- m_glogs_third_harmonic_posint = new size_t[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
- m_glogs_third_harmonic_posfrac = new double[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
- for (size_t i = 0; i < (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct; i++) {
- aux_third_harmonic = (double)i + (double)m_glogs_init_f0s - ((double)m_f0_params.num_f0s_per_oct)*log2(3.0);
- m_glogs_third_harmonic_posint[i] = (size_t)aux_third_harmonic;
- m_glogs_third_harmonic_posfrac[i] = aux_third_harmonic - (double)(m_glogs_third_harmonic_posint[i]);
- }
- m_glogs_third_harmonic = new double[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
+ // Third harmonic attenuation
+ double aux_third_harmonic;
+ m_glogs_third_harmonic_posint = new size_t[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
+ m_glogs_third_harmonic_posfrac = new double[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
+ for (size_t i = 0; i < (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct; i++) {
+ aux_third_harmonic = (double)i + (double)m_glogs_init_f0s - ((double)m_f0_params.num_f0s_per_oct)*log2(3.0);
+ m_glogs_third_harmonic_posint[i] = (size_t)aux_third_harmonic;
+ m_glogs_third_harmonic_posfrac[i] = aux_third_harmonic - (double)(m_glogs_third_harmonic_posint[i]);
+ }
+ m_glogs_third_harmonic = new double[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
- // Fifth harmonic attenuation
- double aux_fifth_harmonic;
- m_glogs_fifth_harmonic_posint = new size_t[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
- m_glogs_fifth_harmonic_posfrac = new double[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
- for (size_t i = 0; i < (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct; i++) {
- aux_fifth_harmonic = (double)i + (double)m_glogs_init_f0s - ((double)m_f0_params.num_f0s_per_oct)*log2(5.0);
- m_glogs_fifth_harmonic_posint[i] = (size_t)aux_fifth_harmonic;
- m_glogs_fifth_harmonic_posfrac[i] = aux_fifth_harmonic - (double)(m_glogs_fifth_harmonic_posint[i]);
- }
- m_glogs_fifth_harmonic = new double[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
+ // Fifth harmonic attenuation
+ double aux_fifth_harmonic;
+ m_glogs_fifth_harmonic_posint = new size_t[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
+ m_glogs_fifth_harmonic_posfrac = new double[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
+ for (size_t i = 0; i < (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct; i++) {
+ aux_fifth_harmonic = (double)i + (double)m_glogs_init_f0s - ((double)m_f0_params.num_f0s_per_oct)*log2(5.0);
+ m_glogs_fifth_harmonic_posint[i] = (size_t)aux_fifth_harmonic;
+ m_glogs_fifth_harmonic_posfrac[i] = aux_fifth_harmonic - (double)(m_glogs_fifth_harmonic_posint[i]);
+ }
+ m_glogs_fifth_harmonic = new double[(m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct];
- // Normalization & attenuation windows
- m_glogs_f0_preference_weights = new double[m_f0_params.num_octs*m_f0_params.num_f0s_per_oct];
- m_glogs_median_correction = new double[m_f0_params.num_octs*m_f0_params.num_f0s_per_oct];
- m_glogs_sigma_correction = new double[m_f0_params.num_octs*m_f0_params.num_f0s_per_oct];
- m_glogs_hf_smoothing_window = new double[m_warp_params.nsamps_twarp/2+1];
- double MIDI_value;
- for (size_t i = 0; i < m_f0_params.num_octs*m_f0_params.num_f0s_per_oct; i++) {
- MIDI_value = 69.0 + 12.0 * log2(m_glogs_f0[i + m_glogs_init_f0s]/440.0);
- m_glogs_f0_preference_weights[i] = 1.0/sqrt(2.0*M_PI*m_f0_params.prefer_stdev*m_f0_params.prefer_stdev)*exp(-(MIDI_value-m_f0_params.prefer_mean)*(MIDI_value-m_f0_params.prefer_mean)/(2.0*m_f0_params.prefer_stdev*m_f0_params.prefer_stdev));
- m_glogs_f0_preference_weights[i] = (0.01 + m_glogs_f0_preference_weights[i]) / (1.01);
+ // Normalization & attenuation windows
+ m_glogs_f0_preference_weights = new double[m_f0_params.num_octs*m_f0_params.num_f0s_per_oct];
+ m_glogs_median_correction = new double[m_f0_params.num_octs*m_f0_params.num_f0s_per_oct];
+ m_glogs_sigma_correction = new double[m_f0_params.num_octs*m_f0_params.num_f0s_per_oct];
+ m_glogs_hf_smoothing_window = new double[m_warp_params.nsamps_twarp/2+1];
+ double MIDI_value;
+ for (size_t i = 0; i < m_f0_params.num_octs*m_f0_params.num_f0s_per_oct; i++) {
+ MIDI_value = 69.0 + 12.0 * log2(m_glogs_f0[i + m_glogs_init_f0s]/440.0);
+ m_glogs_f0_preference_weights[i] = 1.0/sqrt(2.0*M_PI*m_f0_params.prefer_stdev*m_f0_params.prefer_stdev)*exp(-(MIDI_value-m_f0_params.prefer_mean)*(MIDI_value-m_f0_params.prefer_mean)/(2.0*m_f0_params.prefer_stdev*m_f0_params.prefer_stdev));
+ m_glogs_f0_preference_weights[i] = (0.01 + m_glogs_f0_preference_weights[i]) / (1.01);
- m_glogs_median_correction[i] = m_glogs_params.median_poly_coefs[0]*(i+1.0)*(i+1.0) + m_glogs_params.median_poly_coefs[1]*(i+1.0) + m_glogs_params.median_poly_coefs[2];
- m_glogs_sigma_correction[i] = 1.0 / (m_glogs_params.sigma_poly_coefs[0]*(i+1.0)*(i+1.0) + m_glogs_params.sigma_poly_coefs[1]*(i+1.0) + m_glogs_params.sigma_poly_coefs[2]);
- }
+ m_glogs_median_correction[i] = m_glogs_params.median_poly_coefs[0]*(i+1.0)*(i+1.0) + m_glogs_params.median_poly_coefs[1]*(i+1.0) + m_glogs_params.median_poly_coefs[2];
+ m_glogs_sigma_correction[i] = 1.0 / (m_glogs_params.sigma_poly_coefs[0]*(i+1.0)*(i+1.0) + m_glogs_params.sigma_poly_coefs[1]*(i+1.0) + m_glogs_params.sigma_poly_coefs[2]);
+ }
- double smooth_width = 1000.0; // hertz.
- double smooth_aux = (double)(m_warp_params.nsamps_twarp/2+1)*(m_fmax-smooth_width)/m_fmax;
- for (size_t i = 0; i < m_warp_params.nsamps_twarp/2+1; i++) {
- if (i < smooth_aux) {
- m_glogs_hf_smoothing_window[i] = 1.0;
- } else {
- m_glogs_hf_smoothing_window[i] = ((double)i - (double)m_warp_params.nsamps_twarp/2.0)*(-1.0/((double)(m_warp_params.nsamps_twarp/2+1)-smooth_aux));
- }
- }
+ double smooth_width = 1000.0; // hertz.
+ double smooth_aux = (double)(m_warp_params.nsamps_twarp/2+1)*(m_fmax-smooth_width)/m_fmax;
+ for (size_t i = 0; i < m_warp_params.nsamps_twarp/2+1; i++) {
+ if (i < smooth_aux) {
+ m_glogs_hf_smoothing_window[i] = 1.0;
+ } else {
+ m_glogs_hf_smoothing_window[i] = ((double)i - (double)m_warp_params.nsamps_twarp/2.0)*(-1.0/((double)(m_warp_params.nsamps_twarp/2+1)-smooth_aux));
+ }
+ }
}
void
FChTransformF0gram::design_FFT() {
in = (fftw_complex*) fftw_malloc(sizeof (fftw_complex) * m_nfft);
out = (fftw_complex*) fftw_malloc(sizeof (fftw_complex) * m_nfft);
- //TODO verificar que el tipo de datos de in_window es del tipo double, era float.
+ //TODO verificar que el tipo de datos de in_window es del tipo double, era float.
in_window = (double*) fftw_malloc(sizeof (double) * m_nfft);
planFFT = fftw_plan_dft_1d(m_nfft, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
- //TODO hacer diseño del FFT para el filtrado pasabajos.
+ //TODO hacer diseño del FFT para el filtrado pasabajos.
}
@@ -677,8 +678,8 @@
// linear chirps warping definition as relative frequency deviation
//double * freq_relative = new double [m_warpings.nsamps_torig * m_warp_params.num_warps];
- //TODO
- double *freq_relative = new double [m_warpings.nsamps_torig * m_warp_params.num_warps];
+ //TODO
+ double *freq_relative = new double [m_warpings.nsamps_torig * m_warp_params.num_warps];
define_warps_linear_chirps(freq_relative, t_orig);
// maximum relative frequency deviation
@@ -706,37 +707,37 @@
*/
/*
- output << "chirp_rates" << endl;
- for (size_t j = 0; j < m_warp_params.num_warps; j++){
- output << m_warpings.chirp_rates[j];
- output << " ";
- }
- output << endl << "freq_relative" << endl;
+ output << "chirp_rates" << endl;
+ for (size_t j = 0; j < m_warp_params.num_warps; j++){
+ output << m_warpings.chirp_rates[j];
+ output << " ";
+ }
+ output << endl << "freq_relative" << endl;
- for (size_t i = 0; i < m_warpings.nsamps_torig; i++){
- for (size_t j = 0; j < m_warp_params.num_warps; j++){
- output << freq_relative[j * m_warpings.nsamps_torig + i];
- output << " ";
- }
- output << endl;
- }
+ for (size_t i = 0; i < m_warpings.nsamps_torig; i++){
+ for (size_t j = 0; j < m_warp_params.num_warps; j++){
+ output << freq_relative[j * m_warpings.nsamps_torig + i];
+ output << " ";
+ }
+ output << endl;
+ }
- output << endl << "t_orig" << endl;
+ output << endl << "t_orig" << endl;
- for (size_t i = 0; i < m_warpings.nsamps_torig; i++){
- output << t_orig[i] << endl ;
- }
- */
+ for (size_t i = 0; i < m_warpings.nsamps_torig; i++){
+ output << t_orig[i] << endl ;
+ }
+ */
- delete [] freq_relative;
+ delete [] freq_relative;
//output.close();
/* ============= FFTW PLAN DESIGN ============= */
- // Initialize 2-d array for warped signals
- x_warping = new double[m_warp_params.nsamps_twarp];
- m_absFanChirpTransform = (double*)fftw_malloc(sizeof (double) * m_warp_params.num_warps * (m_warp_params.nsamps_twarp/2 + 1));
- m_auxFanChirpTransform = (fftw_complex*)fftw_malloc(sizeof ( fftw_complex) * (m_warp_params.nsamps_twarp/2 + 1));
- plan_forward_xwarping = fftw_plan_dft_r2c_1d(m_warp_params.nsamps_twarp, x_warping, m_auxFanChirpTransform, FFTW_ESTIMATE);
+ // Initialize 2-d array for warped signals
+ x_warping = new double[m_warp_params.nsamps_twarp];
+ m_absFanChirpTransform = (double*)fftw_malloc(sizeof (double) * m_warp_params.num_warps * (m_warp_params.nsamps_twarp/2 + 1));
+ m_auxFanChirpTransform = (fftw_complex*)fftw_malloc(sizeof ( fftw_complex) * (m_warp_params.nsamps_twarp/2 + 1));
+ plan_forward_xwarping = fftw_plan_dft_r2c_1d(m_warp_params.nsamps_twarp, x_warping, m_auxFanChirpTransform, FFTW_ESTIMATE);
}
@@ -746,17 +747,17 @@
given by the desired frequency deviation, to do this, the interpolation
instants are stored in a structure as an integer index and a fractional value
hypothesis: sampling frequency at the central point equals the original
- */
+ */
m_warpings.pos_int = new size_t[m_warp_params.num_warps * m_warp_params.nsamps_twarp];
- m_warpings.pos_frac = new double[m_warp_params.num_warps * m_warp_params.nsamps_twarp];
+ m_warpings.pos_frac = new double[m_warp_params.num_warps * m_warp_params.nsamps_twarp];
- // vector of phase values
- double *phi = new double[m_warpings.nsamps_torig];
- double aux;
+ // vector of phase values
+ double *phi = new double[m_warpings.nsamps_torig];
+ double aux;
- // warped positions
- double *pos1 = new double[m_warp_params.nsamps_twarp*m_warp_params.num_warps];
+ // warped positions
+ double *pos1 = new double[m_warp_params.nsamps_twarp*m_warp_params.num_warps];
for (size_t i = 0; i < m_warp_params.num_warps; i++) {
// vector of phase values
@@ -768,17 +769,17 @@
// interpolation of phase values to obtain warped positions
//pos1(i,:) = interp1(phi,t_orig,t_warp)*fs_orig + length(t_orig)/2;
- // integration of relative frequency to obtain phase values
- cumtrapz(t_orig, freq_relative + i*(m_warpings.nsamps_torig), m_warpings.nsamps_torig, phi);
+ // integration of relative frequency to obtain phase values
+ cumtrapz(t_orig, freq_relative + i*(m_warpings.nsamps_torig), m_warpings.nsamps_torig, phi);
- // centering of phase values to force original frequency in the middle
- aux = phi[m_warpings.nsamps_torig/2];
- for (size_t j = 0; j < m_warpings.nsamps_torig; j++) {
- phi[j] -= aux;
- } //for
+ // centering of phase values to force original frequency in the middle
+ aux = phi[m_warpings.nsamps_torig/2];
+ for (size_t j = 0; j < m_warpings.nsamps_torig; j++) {
+ phi[j] -= aux;
+ } //for
- // interpolation of phase values to obtain warped positions
- interp1(phi, t_orig, m_warpings.nsamps_torig, t_warp, pos1 + i*m_warp_params.nsamps_twarp, m_warp_params.nsamps_twarp);
+ // interpolation of phase values to obtain warped positions
+ interp1(phi, t_orig, m_warpings.nsamps_torig, t_warp, pos1 + i*m_warp_params.nsamps_twarp, m_warp_params.nsamps_twarp);
}
@@ -789,24 +790,24 @@
// % fractional value that defines the warped position
// warps.pos1_frac = (double(pos1)' - double(pos1_int));
- // m_warpings.pos_int = new size_t[m_warp_params.num_warps * m_warp_params.nsamps_twarp];
- for (size_t j = 0; j < m_warp_params.nsamps_twarp*m_warp_params.num_warps; j++) {
- // previous sample index
- pos1[j] = pos1[j]*m_warpings.fs_orig + m_warpings.nsamps_torig/2 + 1;
- m_warpings.pos_int[j] = (size_t) pos1[j];
- m_warpings.pos_frac[j] = pos1[j] - (double)(m_warpings.pos_int[j]);
- } //for
+ // m_warpings.pos_int = new size_t[m_warp_params.num_warps * m_warp_params.nsamps_twarp];
+ for (size_t j = 0; j < m_warp_params.nsamps_twarp*m_warp_params.num_warps; j++) {
+ // previous sample index
+ pos1[j] = pos1[j]*m_warpings.fs_orig + m_warpings.nsamps_torig/2 + 1;
+ m_warpings.pos_int[j] = (size_t) pos1[j];
+ m_warpings.pos_frac[j] = pos1[j] - (double)(m_warpings.pos_int[j]);
+ } //for
- delete [] phi;
- delete [] pos1;
+ delete [] phi;
+ delete [] pos1;
}
void
FChTransformF0gram::define_warps_linear_chirps(double * freq_relative, double * t_orig) {
/** define warps as relative frequency deviation from original frequency
- t_orig : time vector
- freq_relative : relative frequency deviations
- */
+ t_orig : time vector
+ freq_relative : relative frequency deviations
+ */
if (m_warp_params.alpha_dist == 0) {
// linear alpha values spacing
@@ -873,28 +874,28 @@
}
}
LPF_time = (double*)fftw_malloc(sizeof ( double) * m_warpings.nsamps_torig);
- //memset((char*)LPF_time, 0, m_warpings.nsamps_torig * sizeof(double));
- // sustituyo el memset por un for:
- for (size_t i = 0; i < m_warpings.nsamps_torig; i++) {
- LPF_time[i] = 0.0;
- }
- #ifdef DEBUG
- printf(" Corrio primer memset...\n");
- #endif
+ //memset((char*)LPF_time, 0, m_warpings.nsamps_torig * sizeof(double));
+ // sustituyo el memset por un for:
+ for (size_t i = 0; i < m_warpings.nsamps_torig; i++) {
+ LPF_time[i] = 0.0;
+ }
+#ifdef DEBUG
+ printf(" Corrio primer memset...\n");
+#endif
LPF_frequency = (fftw_complex*)fftw_malloc(sizeof ( fftw_complex) * (m_warpings.nsamps_torig/2 + 1)); //tamaño de la fft cuando la entrada es real
- //memset((char*)LPF_frequency, 0, sizeof(fftw_complex) * (m_warpings.nsamps_torig/2 + 1));
- // sustituyo el memset por un for:
- for (size_t i = 0; i < (m_warpings.nsamps_torig/2 + 1); i++) {
- LPF_frequency[i][0] = 0.0;
- LPF_frequency[i][1] = 0.0;
- }
+ //memset((char*)LPF_frequency, 0, sizeof(fftw_complex) * (m_warpings.nsamps_torig/2 + 1));
+ // sustituyo el memset por un for:
+ for (size_t i = 0; i < (m_warpings.nsamps_torig/2 + 1); i++) {
+ LPF_frequency[i][0] = 0.0;
+ LPF_frequency[i][1] = 0.0;
+ }
// for (int i=0; i<(m_blockSize/2+1); i++) {
// LPF_frequency[i] = new fftw_complex;
// }
plan_forward_LPF = fftw_plan_dft_r2c_1d(m_blockSize, LPF_time, LPF_frequency, FFTW_ESTIMATE);
plan_backward_LPF = fftw_plan_dft_c2r_1d(m_warpings.nsamps_torig, LPF_frequency, LPF_time, FFTW_ESTIMATE|FFTW_PRESERVE_INPUT);
- size_t winWidth = 11;
+ size_t winWidth = 11;
double *lp_hanningWindow = new double[winWidth];
double accum=0;
for (size_t i = 0; i < winWidth; i++) {
@@ -907,13 +908,13 @@
}
for (size_t i = 0; i < m_blockSize/2+1; i++) {
//if (((i-(winWidth-1)/2)<0)||(i+(winWidth-1))/2>m_blockSize/2-1) {//consideramos winWidth impar, si la ventana sale del arreglo se rellena con el valor origianl
- if ( (i > (i_max + (winWidth-1)/2)) || (i <= (i_max - (winWidth-1)/2)) ) {
+ if ( (i > (i_max + (winWidth-1)/2)) || (i <= (i_max - (winWidth-1)/2)) ) {
mp_LPFWindow[i]=lp_LPFWindow_aux[i];
} else {
accum=0;
- for (size_t j = -((winWidth-1)/2); j <= (winWidth-1)/2; j++) {
+ for (size_t j = -((winWidth-1)/2); j <= (winWidth-1)/2; j++) {
accum+=lp_LPFWindow_aux[i-j]*lp_hanningWindow[j+(winWidth-1)/2];
- }
+ }
mp_LPFWindow[i]=accum;
}
}
@@ -930,59 +931,59 @@
}
fftw_execute(plan_backward_LPF);
- // TODO ver si hay que hacer fftshift para corregir la fase respecto al centro del frame.
- // nota: además de aplicar el LPF, esta función resamplea la señal original.
+ // TODO ver si hay que hacer fftshift para corregir la fase respecto al centro del frame.
+ // nota: además de aplicar el LPF, esta función resamplea la señal original.
}
void FChTransformF0gram::clean_LPF() {
delete[] mp_LPFWindow;
- fftw_destroy_plan(plan_forward_LPF);
- fftw_destroy_plan(plan_backward_LPF);
- fftw_free(LPF_time);
- fftw_free(LPF_frequency);
+ fftw_destroy_plan(plan_forward_LPF);
+ fftw_destroy_plan(plan_backward_LPF);
+ fftw_free(LPF_time);
+ fftw_free(LPF_frequency);
}
void FChTransformF0gram::reset() {
// Clear buffers, reset stored values, etc
- delete [] m_warpings.pos_int;
- delete [] m_warpings.pos_frac;
+ delete [] m_warpings.pos_int;
+ delete [] m_warpings.pos_frac;
fftw_destroy_plan(planFFT);
- fftw_free(in);
- fftw_free(out);
+ fftw_free(in);
+ fftw_free(out);
- clean_LPF();
+ clean_LPF();
- delete [] m_timeWindow;
+ delete [] m_timeWindow;
- delete [] mp_HanningWindow;
+ delete [] mp_HanningWindow;
- // Warping
- delete [] x_warping;
- fftw_destroy_plan(plan_forward_xwarping);
- fftw_free(m_absFanChirpTransform);
- fftw_free(m_auxFanChirpTransform);
+ // Warping
+ delete [] x_warping;
+ fftw_destroy_plan(plan_forward_xwarping);
+ fftw_free(m_absFanChirpTransform);
+ fftw_free(m_auxFanChirpTransform);
- // design_GLogS
- delete [] m_glogs_f0;
- delete [] m_glogs;
- delete [] m_glogs_n;
- delete [] m_glogs_index;
- delete [] m_glogs_posint;
- delete [] m_glogs_posfrac;
- delete [] m_glogs_third_harmonic_posint;
- delete [] m_glogs_third_harmonic_posfrac;
- delete [] m_glogs_third_harmonic;
- delete [] m_glogs_fifth_harmonic_posint;
- delete [] m_glogs_fifth_harmonic_posfrac;
- delete [] m_glogs_fifth_harmonic;
- delete [] m_glogs_f0_preference_weights;
- delete [] m_glogs_median_correction;
- delete [] m_glogs_sigma_correction;
- delete [] m_glogs_hf_smoothing_window;
+ // design_GLogS
+ delete [] m_glogs_f0;
+ delete [] m_glogs;
+ delete [] m_glogs_n;
+ delete [] m_glogs_index;
+ delete [] m_glogs_posint;
+ delete [] m_glogs_posfrac;
+ delete [] m_glogs_third_harmonic_posint;
+ delete [] m_glogs_third_harmonic_posfrac;
+ delete [] m_glogs_third_harmonic;
+ delete [] m_glogs_fifth_harmonic_posint;
+ delete [] m_glogs_fifth_harmonic_posfrac;
+ delete [] m_glogs_fifth_harmonic;
+ delete [] m_glogs_f0_preference_weights;
+ delete [] m_glogs_median_correction;
+ delete [] m_glogs_sigma_correction;
+ delete [] m_glogs_hf_smoothing_window;
}
@@ -992,38 +993,38 @@
// // Do actual work!
//
- /* PSEUDOCÓDIGO:
- - Aplicar FFT al frame entero.
- - Filtro pasabajos en frecuencia.
- - FFT inversa al frame entero.
------------------------------------------------------------------------------
- - Para cada warp: *Si es un espectrograma direccional (un solo warp
- => no es para cada warp sino para el elegido)
- - Hacer la interpolación con interp1q.
- - Aplicar la FFT al frame warpeado.
- - (Opcional) GLogS.
- - ...
- */
+ /* PSEUDOCÓDIGO:
+ - Aplicar FFT al frame entero.
+ - Filtro pasabajos en frecuencia.
+ - FFT inversa al frame entero.
+ -----------------------------------------------------------------------------
+ - Para cada warp: *Si es un espectrograma direccional (un solo warp
+ => no es para cada warp sino para el elegido)
+ - Hacer la interpolación con interp1q.
+ - Aplicar la FFT al frame warpeado.
+ - (Opcional) GLogS.
+ - ...
+ */
//---------------------------------------------------------------------------
- FeatureSet fs;
+ FeatureSet fs;
- #ifdef DEBUG
- printf("\n ----- DEBUG INFORMATION ----- \n");
- printf(" m_fs = %f Hz.\n",m_fs);
- printf(" fs_orig = %f Hz.\n",m_warpings.fs_orig);
- printf(" fs_warp = %f Hz.\n",m_warpings.fs_warp);
- printf(" m_nfft = %d.\n",m_nfft);
- printf(" m_blockSize = %d.\n",m_blockSize);
- printf(" m_warpings.nsamps_torig = %d.\n",m_warpings.nsamps_torig);
- printf(" m_warp_params.num_warps = %d.\n",m_warp_params.num_warps);
- printf(" m_glogs_harmonic_count = %d.\n",m_glogs_harmonic_count);
- #endif
+#ifdef DEBUG
+ printf("\n ----- DEBUG INFORMATION ----- \n");
+ printf(" m_fs = %f Hz.\n",m_fs);
+ printf(" fs_orig = %f Hz.\n",m_warpings.fs_orig);
+ printf(" fs_warp = %f Hz.\n",m_warpings.fs_warp);
+ printf(" m_nfft = %d.\n",m_nfft);
+ printf(" m_blockSize = %d.\n",m_blockSize);
+ printf(" m_warpings.nsamps_torig = %d.\n",m_warpings.nsamps_torig);
+ printf(" m_warp_params.num_warps = %d.\n",m_warp_params.num_warps);
+ printf(" m_glogs_harmonic_count = %d.\n",m_glogs_harmonic_count);
+#endif
// size_t n = m_nfft/2 + 1;
- // double *tbuf = in_window;
+ // double *tbuf = in_window;
- for (size_t i = 0; i < m_blockSize; i++) {
+ for (size_t i = 0; i < m_blockSize; i++) {
LPF_time[i] = (double)(inputBuffers[0][i]) * m_timeWindow[i];
}
@@ -1032,15 +1033,15 @@
// cout << flush;
// #endif
- apply_LPF();
- // Señal filtrada queda en LPF_time
+ apply_LPF();
+ // Señal filtrada queda en LPF_time
- Feature feature;
+ Feature feature;
feature.hasTimestamp = false;
- /* Solo a modo de prueba, voy a poner la salida del filtrado en «in» y
- voy a mostrar la FFT de eso, para ver el efecto del filtrado. */
+ /* Solo a modo de prueba, voy a poner la salida del filtrado en «in» y
+ voy a mostrar la FFT de eso, para ver el efecto del filtrado. */
// for (size_t i = 0; i < m_nfft; i++) {
// in[i][0] = tbuf[i];
// in[i][1] = 0;
@@ -1066,102 +1067,102 @@
// ----------------------------------------------------------------------------------------------
// Hanning window & FFT for all warp directions
- double max_glogs = -DBL_MAX;
- size_t ind_max_glogs = 0;
+ double max_glogs = -DBL_MAX;
+ size_t ind_max_glogs = 0;
- for (size_t i_warp = 0; i_warp < m_warp_params.num_warps; i_warp++) {
- // Interpolate
- interp1q(LPF_time, (m_warpings.pos_int) + i_warp*m_warp_params.nsamps_twarp, m_warpings.pos_frac + i_warp*m_warp_params.nsamps_twarp, x_warping, m_warp_params.nsamps_twarp);
+ for (size_t i_warp = 0; i_warp < m_warp_params.num_warps; i_warp++) {
+ // Interpolate
+ interp1q(LPF_time, (m_warpings.pos_int) + i_warp*m_warp_params.nsamps_twarp, m_warpings.pos_frac + i_warp*m_warp_params.nsamps_twarp, x_warping, m_warp_params.nsamps_twarp);
- // Apply window
- for (size_t i = 0; i < m_warp_params.nsamps_twarp; i++) {
- x_warping[i] *= mp_HanningWindow[i];
- }
+ // Apply window
+ for (size_t i = 0; i < m_warp_params.nsamps_twarp; i++) {
+ x_warping[i] *= mp_HanningWindow[i];
+ }
- // Transform
- fftw_execute(plan_forward_xwarping);
+ // Transform
+ fftw_execute(plan_forward_xwarping);
- // Copy result
- //memcpy(m_absFanChirpTransform + i_warp*(m_warp_params.nsamps_twarp/2+1), m_auxFanChirpTransform, (m_warp_params.nsamps_twarp/2+1)*sizeof(fftw_complex)); asi como esta no funciona
- double *aux_abs_fcht = m_absFanChirpTransform + i_warp*(m_warp_params.nsamps_twarp/2+1);
- for (size_t i = 0; i < (m_warp_params.nsamps_twarp/2+1); i++) {
- aux_abs_fcht[i] = log10(1.0 + 10.0*sqrt(m_auxFanChirpTransform[i][0]*m_auxFanChirpTransform[i][0]+m_auxFanChirpTransform[i][1]*m_auxFanChirpTransform[i][1]));
- // smoothing high frequency values
- //aux_abs_fcht[i] *= m_glogs_hf_smoothing_window[i];
- }
+ // Copy result
+ //memcpy(m_absFanChirpTransform + i_warp*(m_warp_params.nsamps_twarp/2+1), m_auxFanChirpTransform, (m_warp_params.nsamps_twarp/2+1)*sizeof(fftw_complex)); asi como esta no funciona
+ double *aux_abs_fcht = m_absFanChirpTransform + i_warp*(m_warp_params.nsamps_twarp/2+1);
+ for (size_t i = 0; i < (m_warp_params.nsamps_twarp/2+1); i++) {
+ aux_abs_fcht[i] = log10(1.0 + 10.0*sqrt(m_auxFanChirpTransform[i][0]*m_auxFanChirpTransform[i][0]+m_auxFanChirpTransform[i][1]*m_auxFanChirpTransform[i][1]));
+ // smoothing high frequency values
+ //aux_abs_fcht[i] *= m_glogs_hf_smoothing_window[i];
+ }
// -----------------------------------------------------------------------------------------
// GLogS
- interp1q(aux_abs_fcht, m_glogs_posint, m_glogs_posfrac, m_glogs_interp, m_glogs_harmonic_count);
- size_t glogs_ind = 0;
- for (size_t i = 0; i < m_glogs_num_f0s; i++) {
- double glogs_accum = 0;
- for (size_t j = 1; j <= m_glogs_n[i]; j++) {
- glogs_accum += m_glogs_interp[glogs_ind++];
- }
- m_glogs[i + i_warp*m_glogs_num_f0s] = glogs_accum/(double)m_glogs_n[i];
- }
+ interp1q(aux_abs_fcht, m_glogs_posint, m_glogs_posfrac, m_glogs_interp, m_glogs_harmonic_count);
+ size_t glogs_ind = 0;
+ for (size_t i = 0; i < m_glogs_num_f0s; i++) {
+ double glogs_accum = 0;
+ for (size_t j = 1; j <= m_glogs_n[i]; j++) {
+ glogs_accum += m_glogs_interp[glogs_ind++];
+ }
+ m_glogs[i + i_warp*m_glogs_num_f0s] = glogs_accum/(double)m_glogs_n[i];
+ }
// Sub/super harmonic correction
- interp1q(m_glogs + i_warp*m_glogs_num_f0s, m_glogs_third_harmonic_posint, m_glogs_third_harmonic_posfrac, m_glogs_third_harmonic, (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct);
- interp1q(m_glogs + i_warp*m_glogs_num_f0s, m_glogs_fifth_harmonic_posint, m_glogs_fifth_harmonic_posfrac, m_glogs_fifth_harmonic, (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct);
- for (size_t i = m_glogs_num_f0s-1; i >= m_glogs_init_f0s; i--) {
- m_glogs[i + i_warp*m_glogs_num_f0s] -= MAX(MAX(m_glogs[i-m_f0_params.num_f0s_per_oct + i_warp*m_glogs_num_f0s],m_glogs_third_harmonic[i-m_glogs_init_f0s]),m_glogs_fifth_harmonic[i-m_glogs_init_f0s]);
- //m_glogs[i] -= MAX(m_glogs[i-m_f0_params.num_f0s_per_oct],m_glogs_third_harmonic[i-m_glogs_init_f0s]);
- }
- for (size_t i = m_glogs_init_f0s; i < m_glogs_num_f0s-m_f0_params.num_f0s_per_oct; i++) {
- m_glogs[i + i_warp*m_glogs_num_f0s] -= 0.3*m_glogs[i+m_f0_params.num_f0s_per_oct + i_warp*m_glogs_num_f0s];
- // Median, sigma $ weights correction
- m_glogs[i + i_warp*m_glogs_num_f0s] = (m_glogs[i + i_warp*m_glogs_num_f0s]-m_glogs_median_correction[i-m_glogs_init_f0s])*m_glogs_sigma_correction[i-m_glogs_init_f0s]*m_glogs_f0_preference_weights[i-m_glogs_init_f0s];
- }
+ interp1q(m_glogs + i_warp*m_glogs_num_f0s, m_glogs_third_harmonic_posint, m_glogs_third_harmonic_posfrac, m_glogs_third_harmonic, (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct);
+ interp1q(m_glogs + i_warp*m_glogs_num_f0s, m_glogs_fifth_harmonic_posint, m_glogs_fifth_harmonic_posfrac, m_glogs_fifth_harmonic, (m_f0_params.num_octs+1)*m_f0_params.num_f0s_per_oct);
+ for (size_t i = m_glogs_num_f0s-1; i >= m_glogs_init_f0s; i--) {
+ m_glogs[i + i_warp*m_glogs_num_f0s] -= MAX(MAX(m_glogs[i-m_f0_params.num_f0s_per_oct + i_warp*m_glogs_num_f0s],m_glogs_third_harmonic[i-m_glogs_init_f0s]),m_glogs_fifth_harmonic[i-m_glogs_init_f0s]);
+ //m_glogs[i] -= MAX(m_glogs[i-m_f0_params.num_f0s_per_oct],m_glogs_third_harmonic[i-m_glogs_init_f0s]);
+ }
+ for (size_t i = m_glogs_init_f0s; i < m_glogs_num_f0s-m_f0_params.num_f0s_per_oct; i++) {
+ m_glogs[i + i_warp*m_glogs_num_f0s] -= 0.3*m_glogs[i+m_f0_params.num_f0s_per_oct + i_warp*m_glogs_num_f0s];
+ // Median, sigma $ weights correction
+ m_glogs[i + i_warp*m_glogs_num_f0s] = (m_glogs[i + i_warp*m_glogs_num_f0s]-m_glogs_median_correction[i-m_glogs_init_f0s])*m_glogs_sigma_correction[i-m_glogs_init_f0s]*m_glogs_f0_preference_weights[i-m_glogs_init_f0s];
+ }
- // Look for maximum value to determine best direction
- for (size_t i = m_glogs_init_f0s; i < m_glogs_num_f0s-m_f0_params.num_f0s_per_oct; i++) {
- if (m_glogs[i + i_warp*m_glogs_num_f0s] > max_glogs) {
- max_glogs = m_glogs[i + i_warp*m_glogs_num_f0s];
- ind_max_glogs = i_warp;
- }
- }
- }
+ // Look for maximum value to determine best direction
+ for (size_t i = m_glogs_init_f0s; i < m_glogs_num_f0s-m_f0_params.num_f0s_per_oct; i++) {
+ if (m_glogs[i + i_warp*m_glogs_num_f0s] > max_glogs) {
+ max_glogs = m_glogs[i + i_warp*m_glogs_num_f0s];
+ ind_max_glogs = i_warp;
+ }
+ }
+ }
// ----------------------------------------------------------------------------------------------
- for (size_t i=m_glogs_init_f0s; i< m_glogs_num_f0s - m_f0_params.num_f0s_per_oct; i++) {
+ for (size_t i=m_glogs_init_f0s; i< m_glogs_num_f0s - m_f0_params.num_f0s_per_oct; i++) {
//for (size_t i=0; i<(m_warp_params.nsamps_twarp/2+1); i++) {
- //feature.values.push_back((float)(m_warpings.pos_int[i])+ (float)(m_warpings.pos_frac[i]));
- //feature.values.push_back((float)(phi[i]*100000.0));
- //feature.values.push_back((float)(t_orig[i]));
- //feature.values.push_back((float)(pos1[i]));
- //feature.values.push_back((float)x_warping[i]);
- //feature.values.push_back(m_absFanChirpTransform[i + ind_max_glogs*(m_warp_params.nsamps_twarp/2+1)]);
- //feature.values.push_back((float)m_glogs[i+(long)ind_max_glogs*(long)m_glogs_num_f0s]);
- switch (m_f0gram_mode) {
- case 1:
- max_glogs = -DBL_MAX;
- for (size_t i_warp = 0; i_warp < m_warp_params.num_warps; i_warp++) {
- if (m_glogs[i + i_warp*m_glogs_num_f0s] > max_glogs) {
- max_glogs = m_glogs[i + i_warp*m_glogs_num_f0s];
- ind_max_glogs = i_warp;
- }
- }
- feature.values.push_back((float)max_glogs);
- break;
- case 0:
- feature.values.push_back((float)m_glogs[i+(size_t)ind_max_glogs*(size_t)m_glogs_num_f0s]);
- break;
- }
- //feature.values.push_back((float)m_glogs_hf_smoothing_window[i]);
- }
+ //feature.values.push_back((float)(m_warpings.pos_int[i])+ (float)(m_warpings.pos_frac[i]));
+ //feature.values.push_back((float)(phi[i]*100000.0));
+ //feature.values.push_back((float)(t_orig[i]));
+ //feature.values.push_back((float)(pos1[i]));
+ //feature.values.push_back((float)x_warping[i]);
+ //feature.values.push_back(m_absFanChirpTransform[i + ind_max_glogs*(m_warp_params.nsamps_twarp/2+1)]);
+ //feature.values.push_back((float)m_glogs[i+(long)ind_max_glogs*(long)m_glogs_num_f0s]);
+ switch (m_f0gram_mode) {
+ case 1:
+ max_glogs = -DBL_MAX;
+ for (size_t i_warp = 0; i_warp < m_warp_params.num_warps; i_warp++) {
+ if (m_glogs[i + i_warp*m_glogs_num_f0s] > max_glogs) {
+ max_glogs = m_glogs[i + i_warp*m_glogs_num_f0s];
+ ind_max_glogs = i_warp;
+ }
+ }
+ feature.values.push_back((float)max_glogs);
+ break;
+ case 0:
+ feature.values.push_back((float)m_glogs[i+(size_t)ind_max_glogs*(size_t)m_glogs_num_f0s]);
+ break;
+ }
+ //feature.values.push_back((float)m_glogs_hf_smoothing_window[i]);
+ }
// ----------------------------------------------------------------------------------------------
- fs[0].push_back(feature);
+ fs[0].push_back(feature);
- #ifdef DEBUG
- printf(" ----------------------------- \n");
- #endif
+#ifdef DEBUG
+ printf(" ----------------------------- \n");
+#endif
- return fs;
+ return fs;
//---------------------------------------------------------------------------
//return FeatureSet();
@@ -1175,32 +1176,32 @@
void
FChTransformF0gram::design_time_window() {
- size_t transitionWidth = (size_t)m_blockSize/128 + 1;;
+ size_t transitionWidth = (size_t)m_blockSize/128 + 1;;
m_timeWindow = new double[m_blockSize];
- double *lp_transitionWindow = new double[transitionWidth];
+ double *lp_transitionWindow = new double[transitionWidth];
- //memset(m_timeWindow, 1.0, m_blockSize);
- for (size_t i = 0; i < m_blockSize; i++) {
- m_timeWindow[i] = 1.0;
- }
+ //memset(m_timeWindow, 1.0, m_blockSize);
+ for (size_t i = 0; i < m_blockSize; i++) {
+ m_timeWindow[i] = 1.0;
+ }
- for (size_t i = 0; i < transitionWidth; i++) {
+ for (size_t i = 0; i < transitionWidth; i++) {
lp_transitionWindow[i]=0.5*(1.0-cos(2*M_PI*(double)(i+1)/((double)transitionWidth+1.0)));
}
- for (size_t i = 0; i < transitionWidth/2; i++) {
- m_timeWindow[i] = lp_transitionWindow[i];
- m_timeWindow[m_blockSize-1-i] = lp_transitionWindow[transitionWidth-1-i];
- }
+ for (size_t i = 0; i < transitionWidth/2; i++) {
+ m_timeWindow[i] = lp_transitionWindow[i];
+ m_timeWindow[m_blockSize-1-i] = lp_transitionWindow[transitionWidth-1-i];
+ }
- #ifdef DEBUG
- for (int i = 0; i < m_blockSize; i++) {
- if ((i.
- */
+*/
// Remember to use a different guard symbol in each header!
#ifndef _FCHTRANSFORMF0GRAM_H_
#define _FCHTRANSFORMF0GRAM_H_
+
#define _USE_MATH_DEFINES
#include
#include
@@ -62,7 +63,7 @@
void reset();
FeatureSet process(const float *const *inputBuffers,
- Vamp::RealTime timestamp);
+ Vamp::RealTime timestamp);
FeatureSet getRemainingFeatures();
@@ -107,7 +108,7 @@
} f0_parameters;
f0_parameters m_f0_params;
- bool m_f0gram_mode;
+ bool m_f0gram_mode;
// ======== GATHERED LOG SPECTRUM PARAMETERS =======
@@ -140,53 +141,53 @@
fftw_complex *LPF_frequency;
fftw_plan plan_backward_LPF;
fftw_plan plan_forward_LPF;
- // timeWindow
- double *m_timeWindow;
- // Warpings
- double *x_warping;
- // Hanning window
- double *mp_HanningWindow;
- // FChT plan & transformed data structs
- double *m_absFanChirpTransform;
- fftw_complex *m_auxFanChirpTransform;
- fftw_plan plan_forward_xwarping;
- // GLogS
- double *m_glogs_f0;
- double *m_glogs;
- size_t *m_glogs_n;
- size_t *m_glogs_index;
- size_t *m_glogs_posint;
- double *m_glogs_posfrac;
- double *m_glogs_interp;
- size_t m_glogs_harmonic_count;
- size_t m_glogs_num_f0s;
- size_t m_glogs_init_f0s;
- size_t *m_glogs_third_harmonic_posint;
- double *m_glogs_third_harmonic_posfrac;
- double *m_glogs_third_harmonic;
- size_t *m_glogs_fifth_harmonic_posint;
- double *m_glogs_fifth_harmonic_posfrac;
- double *m_glogs_fifth_harmonic;
- double *m_glogs_f0_preference_weights;
- double *m_glogs_median_correction;
- double *m_glogs_sigma_correction;
- double *m_glogs_hf_smoothing_window;
+ // timeWindow
+ double *m_timeWindow;
+ // Warpings
+ double *x_warping;
+ // Hanning window
+ double *mp_HanningWindow;
+ // FChT plan & transformed data structs
+ double *m_absFanChirpTransform;
+ fftw_complex *m_auxFanChirpTransform;
+ fftw_plan plan_forward_xwarping;
+ // GLogS
+ double *m_glogs_f0;
+ double *m_glogs;
+ size_t *m_glogs_n;
+ size_t *m_glogs_index;
+ size_t *m_glogs_posint;
+ double *m_glogs_posfrac;
+ double *m_glogs_interp;
+ size_t m_glogs_harmonic_count;
+ size_t m_glogs_num_f0s;
+ size_t m_glogs_init_f0s;
+ size_t *m_glogs_third_harmonic_posint;
+ double *m_glogs_third_harmonic_posfrac;
+ double *m_glogs_third_harmonic;
+ size_t *m_glogs_fifth_harmonic_posint;
+ double *m_glogs_fifth_harmonic_posfrac;
+ double *m_glogs_fifth_harmonic;
+ double *m_glogs_f0_preference_weights;
+ double *m_glogs_median_correction;
+ double *m_glogs_sigma_correction;
+ double *m_glogs_hf_smoothing_window;
// auxiliar methods
- void design_GLogS();
+ void design_GLogS();
void design_FChT();
void define_warps_linear_chirps(double *, double *);
void design_warps(double *, double *, double *);
void design_LPF();
void clean_LPF();
void apply_LPF();
- void design_FFT();
- void design_time_window();
+ void design_FFT();
+ void design_time_window();
- // FFT variables
- fftw_complex *in, *out;
- //TODO verificar que el tipo de datos de in_window es del tipo double, era del tipo float.
- double *in_window;
- fftw_plan planFFT;
+ // FFT variables
+ fftw_complex *in, *out;
+ //TODO verificar que el tipo de datos de in_window es del tipo double, era del tipo float.
+ double *in_window;
+ fftw_plan planFFT;
};