void fft_filt_c::pre_run() {
if (filter_is_set) {
prepare_filter();
if (!fft_ready && filter_is_ready) {
if (is_complex) {
fft_fcfg_c = kiss_fft_alloc(fft_len,0,0,0);
fft_icfg_c = kiss_fft_alloc(fft_len,1,0,0);
input_buf_c = new kiss_fft_cpx[fft_len];
fdom_buf = new kiss_fft_cpx[fft_len];
fdom_conv_buf = new kiss_fft_cpx[fft_len];
output_buf_c = new kiss_fft_cpx[fft_len];
last_output_buf_c = new kiss_fft_cpx[fft_len-l];
memset(last_output_buf_c,0,sizeof(kiss_fft_cpx)*(fft_len-l));
} else {
fft_fcfg_r = kiss_fftr_alloc(fft_len,0,0,0);
fft_icfg_r = kiss_fftr_alloc(fft_len,1,0,0);
input_buf_r = new kiss_fft_scalar[fft_len];
fdom_buf = new kiss_fft_cpx[fft_len/2+1];
fdom_conv_buf = new kiss_fft_cpx[fft_len/2+1];
output_buf_r = new kiss_fft_scalar[fft_len];
last_output_buf_r = new kiss_fft_scalar[fft_len-l];
memset(last_output_buf_r,0,sizeof(kiss_fft_scalar)*(fft_len-l));
}
fft_ready = true;
}
}
};
FFT::FFT(int nsamples_){
nsamples=nsamples_;
if (nsamples%2!=0) {
nsamples+=1;
printf("WARNING: Odd sample size on FFT::FFT() (%d)",nsamples);
};
smp=new REALTYPE[nsamples];for (int i=0;i<nsamples;i++) smp[i]=0.0;
freq=new REALTYPE[nsamples/2+1];for (int i=0;i<nsamples/2+1;i++) freq[i]=0.0;
window.data=new REALTYPE[nsamples];for (int i=0;i<nsamples;i++) window.data[i]=0.707;
window.type=W_RECTANGULAR;
#ifdef KISSFFT
datar=new kiss_fft_scalar[nsamples+2];
for (int i=0;i<nsamples+2;i++) datar[i]=0.0;
datac=new kiss_fft_cpx[nsamples/2+2];
for (int i=0;i<nsamples/2+2;i++) datac[i].r=datac[i].i=0.0;
plankfft = kiss_fftr_alloc(nsamples,0,0,0);
plankifft = kiss_fftr_alloc(nsamples,1,0,0);
#else
data=new REALTYPE[nsamples];for (int i=0;i<nsamples;i++) data[i]=0.0;
planfftw=fftwf_plan_r2r_1d(nsamples,data,data,FFTW_R2HC,FFTW_ESTIMATE);
planifftw=fftwf_plan_r2r_1d(nsamples,data,data,FFTW_HC2R,FFTW_ESTIMATE);
#endif
rand_seed=start_rand_seed;
start_rand_seed+=161103;
};
void FftConvolver::setResponse(int length, float* newResponse) {
int neededLength= kiss_fftr_next_fast_size_real (block_size+length);
int newTailSize=neededLength-block_size;
if(neededLength !=fft_size || tail_size !=newTailSize) {
if(workspace) freeArray(workspace);
workspace=allocArray<float>(neededLength);
if(tail) freeArray(tail);
tail=allocArray<float>(newTailSize);
fft_size=neededLength/2+1;
workspace_size=neededLength;
tail_size=newTailSize;
if(fft) kiss_fftr_free(fft);
fft = kiss_fftr_alloc(workspace_size, 0, nullptr, nullptr);
if(ifft) kiss_fftr_free(ifft);
ifft=kiss_fftr_alloc(workspace_size, 1, nullptr, nullptr);
if(response_fft) freeArray(response_fft);
response_fft=allocArray<kiss_fft_cpx>(fft_size);
if(block_fft) freeArray(block_fft);
block_fft=allocArray<kiss_fft_cpx>(fft_size);
}
memset(workspace, 0, sizeof(float)*workspace_size);
memset(tail, 0, sizeof(float)*tail_size);
//Store the fft of the response.
std::copy(newResponse, newResponse+length, workspace);
kiss_fftr(fft, workspace, response_fft);
}
int fft2_init(bool cmplx1 /* if complex transform */,
int pad1 /* padding on the first axis */,
int nx, int ny /* input data size */,
int *nx2, int *ny2 /* padded data size */)
/*< initialize >*/
{
#ifndef SF_HAS_FFTW
int i2;
#endif
cmplx = cmplx1;
if (cmplx) {
nk = n1 = kiss_fft_next_fast_size(nx*pad1);
#ifndef SF_HAS_FFTW
cfg1 = kiss_fft_alloc(n1,0,NULL,NULL);
icfg1 = kiss_fft_alloc(n1,1,NULL,NULL);
#endif
} else {
nk = kiss_fft_next_fast_size(pad1*(nx+1)/2)+1;
n1 = 2*(nk-1);
#ifndef SF_HAS_FFTW
cfg = kiss_fftr_alloc(n1,0,NULL,NULL);
icfg = kiss_fftr_alloc(n1,1,NULL,NULL);
#endif
}
n2 = kiss_fft_next_fast_size(ny);
if (cmplx) {
cc = sf_complexalloc2(n1,n2);
} else {
ff = sf_floatalloc2(n1,n2);
}
#ifndef SF_HAS_FFTW
cfg2 = kiss_fft_alloc(n2,0,NULL,NULL);
icfg2 = kiss_fft_alloc(n2,1,NULL,NULL);
tmp = (kiss_fft_cpx **) sf_alloc(n2,sizeof(*tmp));
tmp[0] = (kiss_fft_cpx *) sf_alloc(nk*n2,sizeof(kiss_fft_cpx));
for (i2=0; i2 < n2; i2++) {
tmp[i2] = tmp[0]+i2*nk;
}
trace2 = sf_complexalloc(n2);
ctrace2 = (kiss_fft_cpx *) trace2;
#endif
*nx2 = n1;
*ny2 = n2;
wt = 1.0/(n1*n2);
return (nk*n2);
}
ADRess::ADRess(double sampleRate, int blockSize, int beta):sampleRate_(sampleRate),BLOCK_SIZE(blockSize),BETA(beta)
{
currStatus_ = kBypass;
d_ = BETA/2;
H_ = BETA/4;
LR_ = 2;
currFilter_ = kAllPass;
cutOffFrequency_ = 0.0;
cutOffBinIndex_ = 0;
// Hann window
windowBuffer_ = new float[BLOCK_SIZE];
for (int i = 0; i < BLOCK_SIZE; i++)
windowBuffer_[i] = 0.5*(1.0 - cos(2.0*M_PI*(float)i/(BLOCK_SIZE-1)) );
// all pass frequency mask
frequencyMask_ = new float[BLOCK_SIZE/2+1];
for (int i = 0; i < BLOCK_SIZE/2+1; i++)
frequencyMask_[i] = 1.0;
// initialise FFt
fwd_= kiss_fftr_alloc(BLOCK_SIZE,0,NULL,NULL);
inv_= kiss_fftr_alloc(BLOCK_SIZE,1,NULL,NULL);
leftSpectrum_ = new complex<float>[BLOCK_SIZE];
rightSpectrum_ = new complex<float>[BLOCK_SIZE];
leftMag_ = new float[BLOCK_SIZE/2+1];
rightMag_ = new float[BLOCK_SIZE/2+1];
leftPhase_ = new float[BLOCK_SIZE/2+1];
rightPhase_ = new float[BLOCK_SIZE/2+1];
resynMagL_ = new float[BLOCK_SIZE/2+1];
for (int i = 0; i<=BLOCK_SIZE/2; i++)
resynMagL_[i] = 0;
resynMagR_ = new float[BLOCK_SIZE/2+1];
for (int i = 0; i<=BLOCK_SIZE/2; i++)
resynMagR_[i] = 0;
minIndicesL_ = new int[BLOCK_SIZE/2+1];
minValuesL_ = new float[BLOCK_SIZE/2+1];
maxValuesL_ = new float[BLOCK_SIZE/2+1];
minIndicesR_ = new int[BLOCK_SIZE/2+1];
minValuesR_ = new float[BLOCK_SIZE/2+1];
maxValuesR_ = new float[BLOCK_SIZE/2+1];
azimuthL_ = new float*[BLOCK_SIZE/2+1];
for (int n = 0; n<BLOCK_SIZE/2+1; n++)
azimuthL_[n] = new float[BETA+1];
azimuthR_ = new float*[BLOCK_SIZE/2+1];
for (int n = 0; n<BLOCK_SIZE/2+1; n++)
azimuthR_[n] = new float[BETA+1];
}
SjOscSpectrum::SjOscSpectrum(long sampleCount)
{
m_sampleCount = sampleCount;
m_kiss_fft_setup = kiss_fftr_alloc(SPEC_NUM*2, 0, NULL, 0);
m_chData[0].chNum = 0;
m_chData[1].chNum = 1;
m_crazyState = CRAZY_NONE;
m_firstCrazy = FALSE;
// calculate the frequency band -> box array
static const unsigned int analyzer[20]= {1,3,5,7,9,13,19,25,38,58,78,116,156,195,235,274,313,352,391,430};
int b;
for( b = 0; b < NUM_BOXES; b++ )
{
int from = b? analyzer[b-1]+(analyzer[b] -analyzer[b-1])/2 : 0;
int to = b<NUM_BOXES-1? analyzer[b] +(analyzer[b+1]-analyzer[b] )/2 : SPEC_NUM;
int j;
for( j = from; j < to; j++ )
{
m_freqToBox[j] = b;
}
m_boxSampleCount[b] = to-from;
}
}
FFTLib::FFTLib(size_t frame_size) : m_frame_size(frame_size) {
m_window = (kiss_fft_scalar *) KISS_FFT_MALLOC(sizeof(kiss_fft_scalar) * frame_size);
m_input = (kiss_fft_scalar *) KISS_FFT_MALLOC(sizeof(kiss_fft_scalar) * frame_size);
m_output = (kiss_fft_cpx *) KISS_FFT_MALLOC(sizeof(kiss_fft_cpx) * frame_size);
PrepareHammingWindow(m_window, m_window + frame_size, 1.0 / INT16_MAX);
m_cfg = kiss_fftr_alloc(frame_size, 0, NULL, NULL);
}
void ConstQ::genSparseKernel()
{
// get frequencies of min and max Note
minFreq = noteNum2Freq((float)minNote);
maxFreq = noteNum2Freq((float)maxNote);
// get Q value and the number of total constant Q bins
Q = 1./(pow(2.,(1./bpo)) - 1);
constQBins = ceil(bpo * log2(maxFreq/minFreq));
// memory alloc for sparkernel bins
sparkernel = new sparKernel[constQBins];
fftLength =
nextPowerOf2((unsigned int) ceil(Q * fs/minFreq));
// fft setup
fft = kiss_fft_alloc(fftLength, 0, NULL, NULL);
fftr = kiss_fftr_alloc(fftLength, 0, NULL, NULL);
for (int k=constQBins; k > 0; k--){
double centerFreq = (minFreq * pow(2,(float(k-1)/bpo)));
int upperBound = ceil(centerFreq * pow(2, 1./12) * fftLength/fs);
int lowerBound = floor(centerFreq * pow(2, -1./12) * fftLength/fs);
sparkernel[k-1].s = lowerBound;
sparkernel[k-1].e = upperBound;
sparkernel[k-1].cpx = new kiss_fft_cpx[upperBound - lowerBound];
}
pthread_create(&thread, NULL, ConstQ::sparseKernelThread, this);
}
static
void fft_file_real(FILE * fin, FILE * fout, int nfft, int isinverse)
{
kiss_fftr_cfg st;
kiss_fft_scalar * rbuf;
kiss_fft_cpx * cbuf;
rbuf = (kiss_fft_scalar*)malloc(sizeof(kiss_fft_scalar) * nfft);
cbuf = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (nfft / 2 + 1));
st = kiss_fftr_alloc(nfft , isinverse , 0, 0);
if (isinverse == 0) {
while (fread(rbuf , sizeof(kiss_fft_scalar) * nfft , 1, fin) > 0) {
kiss_fftr(st , rbuf , cbuf);
fwrite(cbuf , sizeof(kiss_fft_cpx) , (nfft / 2 + 1) , fout);
}
} else {
while (fread(cbuf , sizeof(kiss_fft_cpx) * (nfft / 2 + 1) , 1, fin) > 0) {
kiss_fftri(st , cbuf , rbuf);
fwrite(rbuf , sizeof(kiss_fft_scalar) , nfft , fout);
}
}
free(st);
free(rbuf);
free(cbuf);
}
JNIEXPORT jlong JNICALL Java_com_badlogic_gdx_audio_analysis_KissFFT_create (JNIEnv *, jobject, jint numSamples)
{
KissFFT* fft = new KissFFT();
fft->config = kiss_fftr_alloc(numSamples,0,NULL,NULL);
fft->spectrum = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * numSamples);
fft->numSamples = numSamples;
return (jlong)fft;
return 0;
}
JNIEXPORT jlong JNICALL Java_de_jurihock_voicesmith_dsp_KissFFT_alloc(JNIEnv *,
jobject, jint size)
{
KissFFT* fft = new KissFFT();
fft->size = size;
fft->forward = kiss_fftr_alloc(size, 0, NULL, NULL);
fft->backward = kiss_fftr_alloc(size, 1, NULL, NULL);
// The spectrum buffer contains N/2+1 float tuples (Re,Im)
fft->spectrum = (kiss_fft_cpx*) malloc(
sizeof(kiss_fft_cpx) * ((size / 2) + 1));
fft->halfBuffer = (float*) malloc(sizeof(float) * (size / 2));
return (jlong) fft;
}
// ----------------------------------------------------------------------------
void ofOpenALSoundPlayer::initSystemFFT(int bands){
if(int(systemBins.size())==bands) return;
int signalSize = (bands-1)*2;
if(systemFftCfg!=0) kiss_fftr_free(systemFftCfg);
systemFftCfg = kiss_fftr_alloc(signalSize, 0, NULL, NULL);
systemCx_out.resize(bands);
systemBins.resize(bands);
createWindow(signalSize);
}
// ----------------------------------------------------------------------------
void ofOpenALSoundPlayer_TimelineAdditions::initFFT(int bands){
if(int(bins.size())==bands) return;
int signalSize = (bands-1)*2;
if(fftCfg!=0) kiss_fftr_free(fftCfg);
fftCfg = kiss_fftr_alloc(signalSize, 0, NULL, NULL);
cx_out.resize(bands);
bins.resize(bands);
createWindow(signalSize);
}
void velcon_init(int nt1 /* time samples */,
int nx1 /* space samples */,
float dt1 /* time sampling */,
float dx1 /* space sampling */,
float t1 /* time origin */,
int pad1,
int pad2 /* padding in time */,
int next /* trace extension */)
/*< initialize >*/
{
nt = nt1;
nx = nx1;
dt = dt1;
dx = dx1;
t0 = t1;
n2 = pad1;
n3 = pad2;
/* t squared stretch */
o2 = t0*t0;
d2 = t0+(nt-1)*dt;
d2 = (d2*d2 - o2)/(n2-1);
str = fint1_init(next,nt,0);
istr = fint1_init(next,n2,0);
/* FFT in time */
forw = kiss_fftr_alloc(n3,0,NULL,NULL);
invs = kiss_fftr_alloc(n3,1,NULL,NULL);
if (NULL == forw || NULL == invs)
sf_error("KISS FFT allocation error");
nw = n3/2+1;
dw = 2*SF_PI/(n3*d2);
/* cosine FT in space */
sf_cosft_init(nx);
dx = SF_PI/(kiss_fft_next_fast_size(nx-1)*dx1);
strace = sf_floatalloc(n3);
ctrace = sf_complexalloc(nw);
}
void FFTinit() {
/**************************************************************************/
// initialize audio frequency analysis arrays
/**************************************************************************/
fft_cfg = kiss_fftr_alloc(FFT_SIZE, FALSE, NULL, NULL);
fft_in = (kiss_fft_scalar*)malloc(FFT_SIZE * sizeof(kiss_fft_scalar));
fft_out = (kiss_fft_cpx*)malloc(FFT_SIZE / 2 * sizeof(kiss_fft_cpx) + 1);
/**************************************************************************/
}
void sf_cosft_init(int n1_in)
/*< initialize >*/
{
n1 = n1_in;
nt = 2*kiss_fft_next_fast_size(n1-1);
nw = nt/2+1;
p = sf_floatalloc (nt);
pp = (kiss_fft_cpx*) sf_complexalloc(nw);
#ifdef SF_HAS_FFTW
cfg = fftwf_plan_dft_r2c_1d(nt, p, (fftwf_complex *) pp,
FFTW_ESTIMATE);
icfg = fftwf_plan_dft_c2r_1d(nt, (fftwf_complex *) pp, p,
FFTW_ESTIMATE);
#else
forw = kiss_fftr_alloc(nt,0,NULL,NULL);
invs = kiss_fftr_alloc(nt,1,NULL,NULL);
#endif
}
void fft1_2D_fwd (float *input, float *output, int n2)
/*< Fast Fourier Transform along the first axis forward>*/
{
/*bool inv, sym, opt;*/
int n1, i1, i2;
float *p, wt, shift;
kiss_fft_cpx *pp, ce;
char *label;
sf_file out=NULL;
kiss_fftr_cfg cfg;
bool verb;
verb=1;
wt = sym? 1./sqrtf((float) ntopt): 1.0/ntopt;
p = sf_floatalloc(ntopt);
pp = (kiss_fft_cpx*) sf_complexalloc(nw);
cfg = kiss_fftr_alloc(ntopt,0,NULL,NULL);
for (i2=0; i2 < n2; i2++) {
/*sf_floatread (p,n1,in);*/
memcpy(p,&input[i2*nt],nt*sizeof(float));
if (sym) {
for (i1=0; i1 < nt; i1++) {
p[i1] *= wt;
}
}
for (i1=nt; i1 < ntopt; i1++) {
p[i1]=0.0; // padding
}
kiss_fftr (cfg,p,pp);
if (0. != ot) {
for (i1=0; i1 < nw; i1++) {
shift = -2.0*SF_PI*i1*dw*ot;
ce.r = cosf(shift);
ce.i = sinf(shift);
pp[i1]=sf_cmul(pp[i1],ce);
}
}
memcpy(&output[i2*2*nw],pp,2*nw*sizeof(float));
}
free(p);
free(pp);
/*exit (0);*/
}
IFFT::IFFT (ssi_size_t rfft_, ssi_size_t dim_)
: rfft (rfft_), nfft ((rfft_ - 1) << 1), dim (dim_) {
_icfg = kiss_fftr_alloc (nfft,1,0,0);
_data = new ssi_real_t *[dim];
_fdata = new kiss_fft_cpx *[dim];
for (ssi_size_t i = 0; i < dim; i++) {
_data[i] = new ssi_real_t[nfft];
_fdata[i] = new kiss_fft_cpx[rfft];
}
}
int main(int argc, char *argv[])
{
const char *filename_wav, *filename_png;
kiss_fftr_cfg fft;
int err = 0;
for (;;) {
const int c = getopt(argc, argv, "h");
if (0 > c)
break;
switch (c) {
case '?':
err = EINVAL;
/*@fallthrough@*/
case 'h':
usage();
return err;
}
}
if (argc < 3 || argc != (optind + 2)) {
usage();
return -EINVAL;
}
filename_wav = argv[optind++];
filename_png = argv[optind++];
fft = kiss_fftr_alloc(NUM_FFT, 0, 0, 0);
if (!fft) {
err = ENOMEM;
goto out;
}
err = read_wav(fft, filename_wav);
if (err)
goto out;
err = plot_spectrum(filename_png);
if (err)
goto out;
out:
if (fft)
kiss_fftr_free(fft);
tmr_debug();
mem_debug();
return err;
}
JNIEXPORT jlong JNICALL Java_euphony_lib_receiver_KissFFT_create (JNIEnv *, jobject, jint numSamples)
{
KissFFT* fft = new KissFFT();
fft->config = kiss_fftr_alloc(numSamples,0,NULL,NULL);
fft->spectrum = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (int)numSamples);
//__android_log_print(ANDROID_LOG_INFO,"----","r: %f i : %f",fft->spectrum->r, fft->spectrum->i);
fft->numSamples = numSamples;
return (jlong)fft;
return 0;
}
void freqfilt4pi_init(int n1, int n2 /* data dimensions */,
int nw1 /* number of frequencies */)
/*< initialize >*/
{
m1 = n1;
nw = nw1;
m2 = n2;
nfft = 2*kiss_fft_next_fast_size((n1+1)/2);
tfor = kiss_fftr_alloc(nfft,0,NULL,NULL);
tinv = kiss_fftr_alloc(nfft,1,NULL,NULL);
xfor = kiss_fft_alloc(n2,0,NULL,NULL);
xinv = kiss_fft_alloc(n2,1,NULL,NULL);
if (NULL == tfor || NULL == tinv || NULL == xfor || NULL == xinv)
sf_error("%s: KISS FFT allocation error",__FILE__);
trace = sf_floatalloc(nfft);
ctrace = (kiss_fft_cpx*) sf_complexalloc(nw);
ctrace2 = (kiss_fft_cpx*) sf_complexalloc(n2);
fft = (kiss_fft_cpx**) sf_complexalloc2(nw,n2);
}
void radonoper_init (int nt_in, float dt_in, float t0_in,
int nx_in, float dx_in, float ox_in, float x0_in,
int np_in, float dp_in, float p0_in,
bool par_in)
/*< initialize >*/
{
int ix;
nx = nx_in;
nt = nt_in;
np = np_in;
nt2 = 2*kiss_fft_next_fast_size(nt_in);
nw = nt2/2+1;
dw = 2.0*SF_PI/(nt2*dt_in);
dd = sf_complexalloc(nx_in);
mm = sf_complexalloc(np_in);
tt = sf_floatalloc (nt2);
cm = sf_complexalloc2 (nw,np_in);
cd = sf_complexalloc2 (nw,nx_in);
forw = kiss_fftr_alloc(nt2,0,NULL,NULL);
invs = kiss_fftr_alloc(nt2,1,NULL,NULL);
dd = sf_complexalloc(nx_in);
mm = sf_complexalloc(np_in);
xx = sf_floatalloc(nx_in);
for (ix=0; ix < nx_in; ix++) {
xx[ix] = ox_in + ix*dx_in;
}
for (ix=0; ix < nx_in; ix++) {
if (par_in) {
xx[ix] *= xx[ix]/(x0_in*x0_in);
} else if (1. != x0_in) {
xx[ix] /= x0_in;
}
}
radon_init (nx_in, np_in, dp_in, p0_in); /* initiliaze radon operator */
}
powerspectrum::powerspectrum(
const Eigen::VectorXf& win_funct,
float hop)
{
this->win_funct = win_funct;
this->win_size = win_funct.size();
this->hop_size = hop*win_size;
// initialize kiss fft
kiss_pcm = (kiss_fft_scalar*)malloc(sizeof(kiss_fft_scalar) * win_size);
kiss_freq = (kiss_fft_cpx*)malloc(sizeof(kiss_fft_cpx) * (win_size/2 + 1));
kiss_status = kiss_fftr_alloc(win_size, 0, NULL, NULL);
}
dm_fftSetup dm_fftSetupCreate(unsigned long size_, dm_fftDirection direction_) {
fftsetup_internal* toReturn = new fftsetup_internal();
toReturn->direction = direction_;
#ifdef DSP_USE_ACCELERATE
toReturn->logFftSize = log2f(size_);
toReturn->fftSetup = vDSP_create_fftsetup(toReturn->logFftSize, FFT_RADIX2);
#else
toReturn->fftSize = size_;
toReturn->fftSetup = kiss_fftr_alloc(size_, (toReturn->direction == DM_FFT_FORWARD) ? 0 : 1, 0, 0);
toReturn->temp = new float[size_];
memset(toReturn->temp, 0, sizeof(float) * size_);
#endif
return toReturn;
}
FFT* NewIFFT( int numSamples )
{
FFT* fft = (FFT*)malloc(sizeof(FFT));
fft->direction = INVERSE;
fft->config = kiss_fftr_alloc(numSamples, 1, NULL, NULL);
fft->spectrum = NULL;
fft->realSignal = (kiss_fft_scalar*)malloc(sizeof(kiss_fft_scalar)*numSamples);
fft->numSamples = numSamples;
fft->usescale = USESCALE_YES;
fft->scale = 1.0f/numSamples;
return fft;
}
int main()
{
//complex out[8];
int size=8;
kiss_fft_cpx fft_out[size];
kiss_fftr_cfg cfg=kiss_fftr_alloc(size,0,0,0);
double in[8]={0.1,-1.1,2.0,-4.1,3.1,2.0,-4.4,1.0};
//kiss_fftr_cfg cfg = kiss_fftr_alloc( 8,0 ,0,0 );
kiss_fftr( cfg,in,fft_out);
printf("\n");
for(int j=0;j<8;j++)
printf("%f I%f\n",fft_out[j].r,fft_out[j].i);
printf("\n");
}
void AudioReader::start(char* llabel = "cloop:capture_1", char* rlabel = "cloop:capture_2") {
if(running)
return;
running = true;
// set up the history
head = 0;
history_length = 0;
sounds = new Sound[max_history_length];
if((client = jack_client_open("AudioReader", JackNoStartServer, NULL)) == 0){
fprintf(stderr, "jack server not running?\n");
exit(EXIT_FAILURE);
}
pthread_mutex_lock(&reading_mutex); // jack_client_open() links the process() callback and if process() runs before the ports are connected this will break
jack_set_process_callback(client, audio_reader_process_callback, (void *) this);
jack_on_shutdown(client, audio_reader_shutdown_callback, this);
if (jack_activate(client)) {
fprintf(stderr, "Cannot activate client");
exit(EXIT_FAILURE);
}
// register the ports to capture data on, in this case set with the JACK audio GUI
output_left = jack_port_by_name(client, llabel);
output_right = jack_port_by_name(client, rlabel);
if (output_left == NULL || output_right == NULL) {
fprintf(stderr, "Can't get ports from Jack server");
jack_client_close(client);
exit(EXIT_FAILURE);
}
// allocate space for the main audio buffer that will continuously be written to
buffer = new jack_default_audio_sample_t[nports * maxframes];
// register this program's loopback ports
input_left = jack_port_register(client, "AudioReaderLeft", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
input_right = jack_port_register(client, "AudioReaderRight", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
if (input_left == 0 || input_right == 0) {
fprintf(stderr, "Cannot register loopback port\n");
stop();
exit(EXIT_FAILURE);
}
// create the new connections to route all audio to system out through this program
int left_con = jack_connect(client, jack_port_name(output_left), jack_port_name(input_left));
int right_con = jack_connect(client, jack_port_name(output_right), jack_port_name(input_right));
if (left_con != 0 || right_con != 0) {
fprintf(stderr, "Cannot connect input to output\n");
stop();
exit(EXIT_FAILURE);
}
pthread_mutex_unlock(&reading_mutex);
// allocate the space for the fft
if ((cfg = kiss_fftr_alloc(maxframes, 0, NULL, NULL)) == NULL)
fprintf(stderr, "Out of memory!\n");
}
FFT* NewFFT( int numSamples )
{
FFT* fft = (FFT*)malloc(sizeof(FFT));
fft->direction = FORWARD;
fft->config = kiss_fftr_alloc(numSamples, 0, NULL, NULL);
fft->spectrum = (kiss_fft_cpx*) malloc(sizeof(kiss_fft_cpx) * numSamples);
fft->realSignal = NULL;
fft->numSamples = numSamples;
fft->usescale = USESCALE_NO;
fft->scale = 1;
return fft;
}
int rp_spectr_fft_init()
{
if(rp_kiss_fft_out1 || rp_kiss_fft_out2 || rp_kiss_fft_cfg) {
rp_spectr_fft_clean();
}
rp_kiss_fft_out1 =
(kiss_fft_cpx *)malloc(SPECTR_FPGA_SIG_LEN * sizeof(kiss_fft_cpx));
rp_kiss_fft_out2 =
(kiss_fft_cpx *)malloc(SPECTR_FPGA_SIG_LEN * sizeof(kiss_fft_cpx));
rp_kiss_fft_cfg = kiss_fftr_alloc(SPECTR_FPGA_SIG_LEN, 0, NULL, NULL);
return 0;
}
void AudioLightifier::sample(uint32_t offset) {
// starting from some offset, run an FFT on WINDOW_SIZE
// samples (at 1024 on 44.1kHz, this'll be ~20ms of audio)
short* pcm = reinterpret_cast<short*>(m_data->pcm);
m_sampleIntensity = 0.f;
// sample starting at offset
for (int i = 0; i < WINDOW_SIZE; ++i) {
fft_in[i] = pcm[offset / 2 + (m_data->stereo ? i * 2 : i)];
m_sampleIntensity += fabs(fft_in[i]);
}
m_sampleIntensity /= WINDOW_SIZE;
// run real fft (note that we get complex results)
kiss_fftr_cfg fft_conf = kiss_fftr_alloc(WINDOW_SIZE, 0, 0, 0);
kiss_fftr(fft_conf, fft_in, fft_out);
kiss_fft_cpx* result = fft_out;
++result; // skip DC
m_binAvg = 0.f;
m_binStdDev = 0.f;
m_bassIntensity = 0.f;
int bassSamples = 0;
// sample decibel magnitude into bins
for (int i = 0; i < WINDOW_SIZE / 2; ++i) {
m_bins[i] = log10(result->r * result->r + result->i * result->i);
if (i * (44100.f / WINDOW_SIZE) > 32.f && i * (44100.f / WINDOW_SIZE) > 512.f) {
m_bassIntensity += m_bins[i];
++bassSamples;
}
m_binAvg += m_bins[i];
m_binStdDev += m_bins[i] * m_bins[i];
++result;
}
m_bassIntensity /= static_cast<float>(bassSamples);
m_binAvg /= static_cast<float>(WINDOW_SIZE / 2);
m_binStdDev = sqrt(m_binStdDev / (WINDOW_SIZE / 2) - (m_binAvg * m_binAvg));
computeLights();
}
