Mercurial > hg > vamp-fanchirp
changeset 7:3b2fed77a6cf perf
Indent
| author | Chris Cannam |
|---|---|
| date | Tue, 02 Oct 2018 13:14:21 +0100 |
| parents | cd6169f7940a |
| children | 7ec763dc767c |
| files | FChTransformF0gram.cpp FChTransformF0gram.h |
| diffstat | 2 files changed, 378 insertions(+), 376 deletions(-) [+] |
line wrap: on
line diff
--- 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 <http://www.gnu.org/licenses/>. - */ +*/ #include "FChTransformF0gram.h" #include "FChTransformUtils.h" #include <math.h> #include <float.h> //#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<transitionWidth)) { - printf(" m_timeWindow[%d] = %f.\n",i,m_timeWindow[i]); - } - } - #endif +#ifdef DEBUG + for (int i = 0; i < m_blockSize; i++) { + if ((i<transitionWidth)) { + printf(" m_timeWindow[%d] = %f.\n",i,m_timeWindow[i]); + } + } +#endif - delete [] lp_transitionWindow; + delete [] lp_transitionWindow; }
--- a/FChTransformF0gram.h Tue Oct 02 13:13:36 2018 +0100 +++ b/FChTransformF0gram.h Tue Oct 02 13:14:21 2018 +0100 @@ -13,11 +13,12 @@ You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. - */ +*/ // Remember to use a different guard symbol in each header! #ifndef _FCHTRANSFORMF0GRAM_H_ #define _FCHTRANSFORMF0GRAM_H_ + #define _USE_MATH_DEFINES #include <cmath> #include <vamp-sdk/Plugin.h> @@ -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; };