/*
Copyright (C) 2006-2011 Nasca Octavian Paul
Author: Nasca Octavian Paul
Author/Copyright (C) 2017 Xenakios
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License (version 2) for more details.
You should have received a copy of the GNU General Public License (version 2)
along with this program; if not, write to the Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#pragma once
#include "globals.h"
#ifndef PS_USE_VDSP_FFT
#define PS_USE_VDSP_FFT 0
#endif
#ifndef PS_USE_PFFFT
#define PS_USE_PFFFT 0
#endif
#if PS_USE_VDSP_FFT
#elif PS_USE_PFFFT
#include "../pffft/pffft.h"
#else
#include "fftw3.h"
#endif
#include "../JuceLibraryCode/JuceHeader.h"
#include <random>
#include <type_traits>
template<typename T>
class FFTWBuffer
{
public:
FFTWBuffer()
{
static_assert(std::is_floating_point<T>::value,"FFTWBuffer only works with floating point types");
}
~FFTWBuffer()
{
freeimpl(m_buf);
}
void resize(int size, bool clear)
{
// come on, zero size doesn't make sense!
jassert(size>0);
if (size==m_size && clear==false)
return;
if (m_buf)
freeimpl(m_buf);
mallocimpl(m_buf,size);
if (clear)
for (int i=0;i<size;++i)
m_buf[i]=T();
m_size = size;
}
T& operator[](int index)
{
jassert(index >= 0 && index < m_size);
return m_buf[index];
}
const T& operator[](int index) const
{
jassert(index >= 0 && index < m_size);
return m_buf[index];
}
T* data()
{
// callers to this will likely just blow themselves up if they get a nullptr back
jassert(m_buf!=nullptr);
return m_buf;
}
int getSize() { return m_size; }
FFTWBuffer(FFTWBuffer&& other) : m_buf(other.m_buf), m_size(other.m_size)
{
other.m_buf = nullptr;
other.m_size = 0;
}
FFTWBuffer& operator = (FFTWBuffer&& other)
{
std::swap(other.m_buf, m_buf);
std::swap(other.m_size, m_size);
return *this;
}
// These buffers probably shouldn't be copied anywhere, so just disallow that for now
FFTWBuffer(const FFTWBuffer&) = delete;
FFTWBuffer& operator = (const FFTWBuffer&) = delete;
private:
T* m_buf = nullptr;
int m_size = 0;
void mallocimpl(T*& buf,int size)
{
#if PS_USE_VDSP_FFT
// malloc aligns properly on vdsp platforms
if constexpr (std::is_same<T,float>::value)
buf = (float*)malloc(size*sizeof(float));
else
buf = (double*)malloc(size * sizeof(double));
#elif PS_USE_PFFFT
if constexpr (std::is_same<T,float>::value)
buf = (float*)pffft_aligned_malloc(size*sizeof(float));
else
buf = (double*)pffft_aligned_malloc(size * sizeof(double));
#else
if constexpr (std::is_same<T,float>::value)
buf = (float*)fftwf_malloc(size*sizeof(float));
else
buf = (double*)fftw_malloc(size * sizeof(double));
#endif
}
void freeimpl(T*& buf)
{
if (buf!=nullptr)
{
#if PS_USE_VDSP_FFT
if constexpr (std::is_same<T, float>::value)
free(buf);
else
free(buf);
#elif PS_USE_PFFFT
if constexpr (std::is_same<T, float>::value)
pffft_aligned_free(buf);
else
pffft_aligned_free(buf);
#else
if constexpr (std::is_same<T, float>::value)
fftwf_free(buf);
else
fftw_free(buf);
#endif
buf = nullptr;
}
}
};
enum FFTWindow{W_RECTANGULAR,W_HAMMING,W_HANN,W_BLACKMAN,W_BLACKMAN_HARRIS};
class FFT
{//FFT class that considers phases as random
public:
FFT(int nsamples_, bool no_inverse=false);//samples must be even
~FFT();
void smp2freq();//input is smp, output is freq (phases are discarded)
void freq2smp();//input is freq,output is smp (phases are random)
void applywindow(FFTWindow type);
std::vector<REALTYPE> smp;//size of samples/2
std::vector<REALTYPE> freq;//size of samples
int nsamples=0;
private:
#if PS_USE_VDSP_FFT
void * planfft;
int log2N;
FFTWBuffer<REALTYPE> m_workReal;
FFTWBuffer<REALTYPE> m_workImag;
#elif PS_USE_PFFFT
PFFFT_Setup *planpffft = nullptr;
FFTWBuffer<REALTYPE> m_work;
#else
fftwf_plan planfftw,planifftw;
#endif
FFTWBuffer<REALTYPE> data;
struct{
std::vector<REALTYPE> data;
FFTWindow type;
}window;
std::mt19937 m_randgen;
std::uniform_int_distribution<unsigned int> m_randdist{0,32767};
};
class Stretch
{
public:
Stretch(REALTYPE rap_,int in_bufsize_,FFTWindow w=W_HAMMING,bool bypass_=false,REALTYPE samplerate_=44100,int stereo_mode_=0);
//in_bufsize is also a half of a FFT buffer (in samples)
virtual ~Stretch();
int get_max_bufsize(){
return bufsize*3;
};
int get_bufsize(){
return bufsize;
};
virtual void setBufferSize(int sz);
REALTYPE get_onset_detection_sensitivity(){
return onset_detection_sensitivity;
};
REALTYPE process(REALTYPE *smps,int nsmps);//returns the onset value
void set_freezing(bool new_freezing){
freezing=new_freezing;
};
bool isFreezing() { return freezing; }
std::vector<REALTYPE> out_buf;//pot sa pun o variabila "max_out_bufsize" si asta sa fie marimea lui out_buf si pe out_bufsize sa il folosesc ca marime adaptiva
int get_nsamples(REALTYPE current_pos_percents);//how many samples are required
int get_nsamples_for_fill();//how many samples are required to be added for a complete buffer refill (at start of the song or after seek)
int get_skip_nsamples();//used for shorten
void set_rap(REALTYPE newrap);//set the current stretch value
void set_onset_detection_sensitivity(REALTYPE detection_sensitivity);;
void here_is_onset(REALTYPE onset);
virtual void setSampleRate(REALTYPE sr) { samplerate = jlimit(1000.0f, 384000.0f, sr); }
REALTYPE getSampleRate() { return samplerate; }
FFTWindow window_type;
protected:
int bufsize=0;
virtual void process_spectrum(REALTYPE *){};
virtual REALTYPE get_stretch_multiplier(REALTYPE pos_percents);
REALTYPE samplerate=0.0f;
private:
void do_analyse_inbuf(REALTYPE *smps);
void do_next_inbuf_smps(REALTYPE *smps);
REALTYPE do_detect_onset();
// REALTYPE *in_pool;//de marimea in_bufsize
REALTYPE rap,onset_detection_sensitivity;
std::vector<REALTYPE> old_out_smps;
std::vector<REALTYPE> old_freq;
std::vector<REALTYPE> new_smps,old_smps,very_old_smps;
std::unique_ptr<FFT> infft,outfft;
std::unique_ptr<FFT> fft;
long double remained_samples;//0..1
long double extra_onset_time_credit;
REALTYPE c_pos_percents;
int skip_samples;
bool require_new_buffer;
bool bypass,freezing;
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Stretch)
};