void Optimizer::update(const ScaledData &scaledData, real x0, real x0Step, bool spectr)
{
TDTimedValue data;
scaledData.fillSmoothedDischarged(x0, data, 100, _settingsOptimizer._periodsOnWin, true);
_signalProcessor.update(data);
// //////////////////////////////////////////////////////////////////////////
// {
// const TVReal &tlog = _signalProcessor.getPeriodLogE();
// const TVComplex &v = _signalProcessor.getValueE();
// std::ofstream out("echo");
// out.precision(16);
// out.setf(std::ios::scientific);
//
// const TVReal <s = tlog;
// const TVComplex &vs = v;
//
// for(size_t i(0); i<lts.size(); i++)
// {
// out<<exp(lts[i])<<"\t";
// out<<vs[i].re()<<"\t";
// out<<vs[i].im()<<"\n";
// }
// out.flush();
// exit(0);
// }
// //////////////////////////////////////////////////////////////////////////
// _signalProcessor.update(scaledData.getSmoothed());
_separatorError = deconvolve(_signalProcessor.getPeriodLogE(), _signalProcessor.getValueE());
}
void bufconvolve_process_internal (t_bufconvolve *x, t_symbol *sym, short argc, t_atom *argv)
{
FFT_SETUP_D fft_setup;
FFT_SPLIT_COMPLEX_D spectrum_1;
FFT_SPLIT_COMPLEX_D spectrum_2;
FFT_SPLIT_COMPLEX_D spectrum_3;
double *out_buf;
float *in_temp;
float *filter_in;
AH_Boolean convolve_mode = sym == gensym("convolve") ? true : false;
t_symbol *target = atom_getsym(argv++);
t_symbol *source_1 = atom_getsym(argv++);
t_symbol *source_2 = atom_getsym(argv++);
t_symbol *filter = filter_retriever(x->deconvolve_filter_specifier);
double filter_specifier[HIRT_MAX_SPECIFIER_ITEMS];
double range_specifier[HIRT_MAX_SPECIFIER_ITEMS];
double time_mul = atom_getfloat(argv++);
double sample_rate = buffer_sample_rate(source_1);
double deconvolve_phase = phase_retriever(x->deconvolve_phase);
double deconvolve_delay;
AH_SIntPtr source_length_1 = buffer_length(source_1);
AH_SIntPtr source_length_2 = buffer_length(source_2);
AH_SIntPtr filter_length = buffer_length(filter);
AH_UIntPtr fft_size;
AH_UIntPtr fft_size_log2;
long deconvolve_mode = x->deconvolve_mode;
t_buffer_write_error error;
// Check input buffers
if (buffer_check((t_object *) x, source_1) || buffer_check((t_object *) x, source_2))
return;
// Check sample rates
if (sample_rate != buffer_sample_rate(source_2))
object_warn((t_object *) x, "sample rates do not match");
// Check and calculate lengths
if (convolve_mode == true)
fft_size = (AH_UIntPtr) ((source_length_1 + source_length_2) * time_mul);
else
fft_size = (AH_UIntPtr) (source_length_1 < source_length_2 ? source_length_2 * time_mul : source_length_1 * time_mul);
fft_size = calculate_fft_size(fft_size, &fft_size_log2);
deconvolve_delay = delay_retriever(x->deconvolve_delay, fft_size, sample_rate);
if (fft_size < 8)
{
object_error((t_object *) x, "input buffers are too short, or have no length");
return;
}
// Allocate Memory (use pointer aliasing where possible for efficiency)
fft_setup = hisstools_create_setup_d(fft_size_log2);
spectrum_1.realp = ALIGNED_MALLOC(sizeof(double) * fft_size * (convolve_mode == true ? 3 : 4));
spectrum_1.imagp = spectrum_1.realp + (fft_size >> 1);
spectrum_2.realp = spectrum_1.imagp + (fft_size >> 1);
spectrum_2.imagp = spectrum_2.realp + (fft_size >> 1);
spectrum_3.realp = spectrum_2.imagp + (fft_size >> 1);
spectrum_3.imagp = convolve_mode == true ? 0 : spectrum_3.realp + fft_size;
filter_in = filter_length ? ALIGNED_MALLOC(sizeof(float *) * filter_length) : 0;
out_buf = spectrum_2.realp;
in_temp = (float *) spectrum_3.realp;
// Check memory allocations
if (!fft_setup || !spectrum_1.realp || (filter_length && !filter_in))
{
object_error((t_object *) x, "could not allocate temporary memory for processing");
hisstools_destroy_setup_d(fft_setup);
ALIGNED_FREE(spectrum_1.realp);
ALIGNED_FREE(filter_in);
return;
}
// Get inputs - convert to frequency domain
buffer_read(source_1, x->read_chan - 1, in_temp, source_length_1);
time_to_halfspectrum_float(fft_setup, in_temp, source_length_1, spectrum_1, fft_size);
buffer_read(source_2, x->read_chan - 1, in_temp, source_length_2);
time_to_halfspectrum_float(fft_setup, in_temp, source_length_2, spectrum_2, fft_size);
// Do deconvolution or convolution
if (convolve_mode == true)
convolve(spectrum_1, spectrum_2, fft_size, SPECTRUM_REAL);
else
{
// Fill deconvolution filter specifiers - load filter from buffer (if specified) - deconvolve
fill_power_array_specifier(filter_specifier, x->deconvolve_filter_specifier, x->deconvolve_num_filter_specifiers);
fill_power_array_specifier(range_specifier, x->deconvolve_range_specifier, x->deconvolve_num_range_specifiers);
buffer_read(filter, 0, filter_in, fft_size);
deconvolve(fft_setup, spectrum_1, spectrum_2, spectrum_3, filter_specifier, range_specifier, 0.0, filter_in, filter_length, fft_size, SPECTRUM_REAL, deconvolve_mode, deconvolve_phase, deconvolve_delay, sample_rate);
}
// Convert to time domain - copy out to buffer
spectrum_to_time(fft_setup, out_buf, spectrum_1, fft_size, SPECTRUM_REAL);
error = buffer_write(target, out_buf, (convolve_mode == true ? source_length_1 + source_length_2 - 1 : fft_size), x->write_chan - 1, x->resize, sample_rate, 1.);
buffer_write_error((t_object *) x, target, error);
// Free resources
hisstools_destroy_setup_d(fft_setup);
ALIGNED_FREE(spectrum_1.realp);
ALIGNED_FREE(filter_in);
if (!error)
outlet_bang(x->process_done);
}
void irphase_process_internal (t_irphase *x, t_symbol *sym, short argc, t_atom *argv)
{
FFT_SETUP_D fft_setup;
FFT_SPLIT_COMPLEX_D spectrum_1;
FFT_SPLIT_COMPLEX_D spectrum_2;
FFT_SPLIT_COMPLEX_D spectrum_3;
float *in;
float *filter_in;
double *out_buf;
t_symbol *filter = filter_retriever(x->deconvolve_filter_specifier);
t_symbol *target = atom_getsym(argv++);
t_symbol *source = atom_getsym(argv++);
double filter_specifier[HIRT_MAX_SPECIFIER_ITEMS];
double range_specifier[HIRT_MAX_SPECIFIER_ITEMS];
double phase = atom_getfloat(argv++);
double time_mul = atom_getfloat(argv++);
double sample_rate = buffer_sample_rate(source);
double deconvolve_delay;
double deconvolve_phase;
t_phase_type mode = (t_phase_type) atom_getlong(argv++);
AH_UIntPtr fft_size;
AH_UIntPtr fft_size_log2;
AH_UIntPtr i;
t_buffer_write_error error;
long deconvolve_mode;
// Get input buffer lengths
AH_SIntPtr source_length_1 = buffer_length(source);
AH_SIntPtr filter_length = buffer_length(filter);
AH_SIntPtr max_length = source_length_1;
// Check input buffers
if (buffer_check((t_object *) x, source))
return;
// Calculate fft size
time_mul = time_mul == 0. ? 1 : time_mul;
if (time_mul < 1)
{
object_warn((t_object *) x, " time multiplier cannot be less than 1 (using 1)");
time_mul = 1;
}
fft_size = calculate_fft_size((long) (max_length * time_mul), &fft_size_log2);
if (fft_size < 8)
{
object_error((t_object *) x, "buffers are too short, or have no length");
return;
}
deconvolve_mode = x->deconvolve_mode;
deconvolve_phase = phase_retriever(x->deconvolve_phase);
deconvolve_delay = delay_retriever(x->deconvolve_delay, fft_size, sample_rate);
// Allocate momory
fft_setup = hisstools_create_setup_d(fft_size_log2);
spectrum_1.realp = ALIGNED_MALLOC(sizeof(double) * fft_size * (mode == MODE_ALLPASS ? 6 : 3));
spectrum_1.imagp = spectrum_1.realp + fft_size;
spectrum_2.realp = spectrum_1.imagp + fft_size;
spectrum_2.imagp = mode == MODE_ALLPASS ? spectrum_2.realp + fft_size : 0;
spectrum_3.realp = mode == MODE_ALLPASS ? spectrum_2.imagp + fft_size : 0;
spectrum_3.imagp = mode == MODE_ALLPASS ? spectrum_3.realp + fft_size : 0;
filter_in = filter_length ? ALIGNED_MALLOC(sizeof(float *) * filter_length) : 0;
out_buf = mode == MODE_ALLPASS ? spectrum_3.realp : spectrum_2.realp;
in = (float *) out_buf;
if (!spectrum_1.realp || !fft_setup || (filter_length && !filter_in))
{
object_error((t_object *) x, "could not allocate temporary memory for processing");
hisstools_destroy_setup_d(fft_setup);
ALIGNED_FREE(spectrum_1.realp);
ALIGNED_FREE(filter_in);
return;
}
// Get input - convert to frequency domain - get power spectrum - convert phase
buffer_read(source, x->read_chan - 1, in, fft_size);
time_to_spectrum_float(fft_setup, in, source_length_1, spectrum_1, fft_size);
power_spectrum(spectrum_1, fft_size, SPECTRUM_FULL);
variable_phase_from_power_spectrum(fft_setup, spectrum_1, fft_size, phase, false);
if (mode == MODE_ALLPASS)
{
// Copy minimum phase spectrum to spectrum_2
for (i = 0; i < fft_size; i++)
{
spectrum_2.realp[i] = spectrum_1.realp[i];
spectrum_2.imagp[i] = spectrum_1.imagp[i];
}
// Get input again
time_to_spectrum_float(fft_setup, in, source_length_1, spectrum_1, fft_size);
// Fill deconvolution filter specifiers - read filter from buffer (if specified) - deconvolve input by minimum phase spectrum
fill_power_array_specifier(filter_specifier, x->deconvolve_filter_specifier, x->deconvolve_num_filter_specifiers);
fill_power_array_specifier(range_specifier, x->deconvolve_range_specifier, x->deconvolve_num_range_specifiers);
buffer_read(filter, 0, filter_in, fft_size);
deconvolve(fft_setup, spectrum_1, spectrum_2, spectrum_3, filter_specifier, range_specifier, 0, filter_in, filter_length, fft_size, SPECTRUM_FULL, deconvolve_mode, deconvolve_phase, deconvolve_delay, sample_rate);
}
// Convert to time domain - copy out to buffer
spectrum_to_time(fft_setup, out_buf, spectrum_1, fft_size, SPECTRUM_FULL);
error = buffer_write(target, out_buf, fft_size, x->write_chan - 1, x->resize, sample_rate, 1);
buffer_write_error((t_object *) x, target, error);
// Free memory
hisstools_destroy_setup_d(fft_setup);
ALIGNED_FREE(spectrum_1.realp);
ALIGNED_FREE(filter_in);
if (!error)
outlet_bang(x->process_done);
}
