void FFT_Transform( FFT* fft )
{
switch( fft->direction )
{
case FORWARD:
kiss_fftr(fft->config,fft->realSignal,fft->spectrum);
scale(fft);
break;
case INVERSE:
kiss_fftri(fft->config,fft->spectrum,fft->realSignal);
scale(fft);
break;
}
}
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 HrtfData::linearPhase(float* buffer) {
//Note that this is in effect circular convolution with a truncation.
std::copy(buffer, buffer+hrir_length, fft_time_data);
std::fill(fft_time_data+hrir_length, fft_time_data+hrir_length*2, 0.0f);
kiss_fftr(fft, fft_time_data, fft_data);
for(int i = 0; i < hrir_length+1; i++) {
fft_data[i].r = cabs(fft_data[i].r, fft_data[i].i);
fft_data[i].i = 0.0f;
}
kiss_fftri(ifft, fft_data, fft_time_data);
//Apply the downscaling that kissfft requires, otherwise this is too loud.
//Also accomplish copying back to the starting piont.
scalarMultiplicationKernel(hrir_length, 1.0f/(2*hrir_length), fft_time_data, buffer);
}
int rp_resp_calc(double *cha_in, double *chb_in, int k1, double scale, int kstp, int II,
double **cha_out, double **chb_out)
{
// FFT BASED IMPLEMENTATION
double *cha_o = *cha_out;
double *chb_o = *chb_out;
int i;
if(!cha_in || !chb_in || !*cha_out || !*chb_out )
return -1;
if(!rp_kiss_fft_out1 || !rp_kiss_fft_out2 || !rp_kiss_fft_cfg) {
fprintf(stderr, "rp_spect_fft not initialized");
return -1;
}
kiss_fftr(rp_kiss_fft_cfg, (kiss_fft_scalar *)cha_in, rp_kiss_fft_out1);
kiss_fftr(rp_kiss_fft_cfg, (kiss_fft_scalar *)chb_in, rp_kiss_fft_out2);
for(i = 0; i < II; i++) {
cha_o[k1 + i] = sqrt(pow(rp_kiss_fft_out1[(k1 + i) * kstp].r, 2) +
pow(rp_kiss_fft_out1[(k1 + i) * kstp].i, 2)) * scale;
chb_o[k1 + i] = sqrt(pow(rp_kiss_fft_out2[(k1 + i) * kstp].r, 2) +
pow(rp_kiss_fft_out2[(k1 + i) * kstp].i, 2)) * scale;
/* Saturate to -200 dB */
const double c_min_response = 1e-10;
if (cha_o[k1 + i] < c_min_response)
cha_o[k1 + i] = c_min_response;
if (chb_o[k1 + i] < c_min_response)
chb_o[k1 + i] = c_min_response;
}
return 0;
}
void
fft_filt_c::work_real() {
for (uint32_t i=0;i<fft_len;i++) {
input_buf_r[i] = (i<l) ? (*in)[i] * fft_len : 0;
};
kiss_fftr(fft_fcfg_r, input_buf_r, fdom_buf);
// for (uint32_t i=0;i<fft_len/2+1;i++) { d3(i,fdom_buf[i].r,fdom_buf[i].i); }
// now we convolve with the filter.
// This should be fraction * fraction = fraction... one would hope
const bool test_mode = false;
if (test_mode) {
for (uint32_t i=0;i<fft_len/2+1;i++) {
fdom_buf[i].i *= 1;
fdom_buf[i].r *= 1;
}
} else {
for (uint32_t i=0;i<(fft_len/2+1);i++) {
int64_t i_i = fdom_buf[i].i;
int64_t i_r = fdom_buf[i].r;
int64_t f_i = filt_buf[i].i;
int64_t f_r = filt_buf[i].r;
int64_t p_r = (i_r * f_r - i_i * f_i);
int64_t p_i = (i_r * f_i + i_i * f_r);
fdom_conv_buf[i].i = p_i >> 15;
fdom_conv_buf[i].r = p_r >> 15;
}
}
// for (uint32_t i=0;i<fft_len/2+1;i++) { d7c(i,filt_buf[i].r,filt_buf[i].i, fdom_buf[i].r,fdom_buf[i].i, fdom_conv_buf[i].r, fdom_conv_buf[i].i); };
kiss_fftri(fft_icfg_r,fdom_conv_buf,output_buf_r);
// for (uint32_t i=0;i<fft_len/2+1;i++) { d3c(i,(*in)[i],output_buf_r[i]); };
uint32_t extra = fft_len - l;
for (uint32_t i=0; i<l; i++) {
int32_t vr = output_buf_r[i];
vr += (i<extra) ? last_output_buf_r[i] : 0;
(*out)[i] = vr;
}
for (uint32_t i=0;i<extra;i++) {
last_output_buf_r[i] = output_buf_r[i+l];
}
};
// ----------------------------------------------------------------------------
float * ofOpenALSoundPlayer::getSpectrum(int bands){
initFFT(bands);
bins.assign(bins.size(),0);
if(sources.empty()) return &bins[0];
int signalSize = (bands-1)*2;
getCurrentBufferSum(signalSize);
float normalizer = 2. / windowSum;
runWindow(windowedSignal);
kiss_fftr(fftCfg, &windowedSignal[0], &cx_out[0]);
for(int i= 0; i < bands; i++) {
bins[i] += sqrtf(cx_out[i].r * cx_out[i].r + cx_out[i].i * cx_out[i].i) * normalizer;
}
return &bins[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();
}
Eigen::MatrixXf
powerspectrum::from_pcm(const Eigen::VectorXf& pcm_samples)
{
MINILOG(logTRACE) << "Powerspectrum computation. input samples="
<< pcm_samples.size();
// check if inputs are sane
if ((pcm_samples.size() < win_size) || (hop_size > win_size)) {
return Eigen::MatrixXf(0, 0);
}
size_t frames = (pcm_samples.size() - (win_size-hop_size)) / hop_size;
size_t freq_bins = win_size/2 + 1;
// initialize power spectrum
Eigen::MatrixXf ps(freq_bins, frames);
// peak normalization value
float pcm_scale = std::max(fabs(pcm_samples.minCoeff()),
fabs(pcm_samples.maxCoeff()));
// scale signal to 96db (16bit)
pcm_scale = std::pow(10.0f, 96.0f/20.0f) / pcm_scale;
// compute the power spectrum
for (size_t i = 0; i < frames; i++) {
// fill pcm
for (int j = 0; j < win_size; j++) {
kiss_pcm[j] = pcm_samples(i*hop_size+j) * pcm_scale * win_funct(j);
}
// fft
kiss_fftr(kiss_status, kiss_pcm, kiss_freq);
// save powerspectrum frame
Eigen::MatrixXf::ColXpr psc(ps.col(i));
for (int j = 0; j < win_size/2+1; j++) {
psc(j) =
std::pow(kiss_freq[j].r, 2) + std::pow(kiss_freq[j].i, 2);
}
}
MINILOG(logTRACE) << "Powerspectrum finished. size=" << ps.rows() << "x"
<< ps.cols();
return ps;
}
/*
* Class: euphony_lib_receiver_KissFFT
* Method: spectrum_for_phase
* Signature: (JLjava/nio/ShortBuffer;Ljava/nio/FloatBuffer;)V
*/
JNIEXPORT void JNICALL Java_euphony_lib_receiver_KissFFT_spectrum_1for_1phase
(JNIEnv *env, jobject, jlong handle, jobject source, jobject target)
{
KissFFT* fft = (KissFFT*)handle;
kiss_fft_scalar* samples = (kiss_fft_scalar*)env->GetDirectBufferAddress( source );
float* spectrum = (float*)env->GetDirectBufferAddress( target );
kiss_fftr( fft->config, samples, fft->spectrum );
int len = fft->numSamples / 2 + 1;
int start = len * (16500.0 / 22050.0);
for( int i = start; i < len; i++ )
{
float re = scale(fft->spectrum[i].r) * fft->numSamples;
float im = scale(fft->spectrum[i].i) * fft->numSamples;
spectrum[i] = atan2(im,re) * 180 / 3.141592;
}
}
void GPAudioUtil::fft_real(kiss_fftr_cfg cfg, unsigned num_frames, const float* input, unsigned n, unsigned overlap, const float* window, kiss_fft_scalar* in_buffer, kiss_fft_cpx* out_buffer, double* magnitude, double* phase) {
unsigned fft_output_size = (n/2 + 1);
unsigned shift = n - overlap;
long int num_completed = 0;
long int num_remaining = num_frames;
long int num_fft_output_used = 0;
while (num_remaining > 0) {
// fill the input buffer
unsigned num_to_transform = num_remaining > n ? n : num_remaining;
for (size_t i = 0; i < num_to_transform; i++) {
in_buffer[i] = input[num_completed + i];
}
num_completed += shift;
num_remaining -= shift;
// 0 out rest of input buffer if we're out of frames
for (size_t i = num_to_transform; i < n; i++) {
in_buffer[i] = 0;
}
// apply window
GPAudioUtil::apply_window(n, in_buffer, window);
// perform fft
kiss_fftr(cfg, in_buffer, out_buffer + num_fft_output_used);
// analyze output
//printf("FREQ\t\tREAL\tIMAG\tMAG\tPHASE\n");
for (size_t bin = num_fft_output_used; bin < num_fft_output_used + fft_output_size; bin++) {
magnitude[bin] = sqrt(out_buffer[bin].r * out_buffer[bin].r + out_buffer[bin].i * out_buffer[bin].i);
if (out_buffer[bin].r == 0 && out_buffer[bin].i == 0) {
phase[bin] = 0;
}
else {
phase[bin] = atan(out_buffer[bin].i / out_buffer[bin].r);
}
//printf("%.1lf\t\t%.2lf\t%.2lf\t%.2lf\t%.2lf\n", (44100.0 / n) * bin, out_buffer[bin].r, out_buffer[bin].i, magnitude[bin], phase[bin]);
//std::cout << "BIN: " << bin << ", REAL: " << out_buffer[bin].r << ", IMAGINARY:" << out_buffer[bin].i << ", MAG: " << magnitude[bin] << ", PHASE: " << phase[bin] << std::endl;
}
num_fft_output_used += fft_output_size;
}
}
JNIEXPORT void JNICALL Java_com_badlogic_gdx_audio_analysis_KissFFT_spectrum(JNIEnv *env, jobject, jlong handle, jobject source, jobject target)
{
KissFFT* fft = (KissFFT*)handle;
kiss_fft_scalar* samples = (kiss_fft_scalar*)env->GetDirectBufferAddress( source );
float* spectrum = (float*)env->GetDirectBufferAddress( target );
kiss_fftr( fft->config, samples, fft->spectrum );
int len = fft->numSamples / 2 + 1;
for( int i = 0; i < len; i++ )
{
float re = scale(fft->spectrum[i].r) * fft->numSamples;
float im = scale(fft->spectrum[i].i) * fft->numSamples;
if( i > 0 )
spectrum[i] = sqrtf(re*re + im*im) / (fft->numSamples / 2);
else
spectrum[i] = sqrtf(re*re + im*im) / (fft->numSamples);
}
}
void FFT::smp2freq(){
#ifdef KISSFFT
for (int i=0;i<nsamples;i++) datar[i]=smp[i];
kiss_fftr(plankfft,datar,datac);
#else
for (int i=0;i<nsamples;i++) data[i]=smp[i];
fftwf_execute(planfftw);
#endif
for (int i=1;i<nsamples/2;i++) {
#ifdef KISSFFT
REALTYPE c=datac[i].r;
REALTYPE s=datac[i].i;
#else
REALTYPE c=data[i];
REALTYPE s=data[nsamples-i];
#endif
freq[i]=sqrt(c*c+s*s);
};
freq[0]=0.0;
};
void dm_fftSetupExecute(dm_fftSetup fftSetup_, unsigned long timeDomainLength_, float* timeDomain_, dm_fftComplexArrayT* frequency_, unsigned long offset_) {
fftsetup_internal* setup = (fftsetup_internal*)fftSetup_;
#ifdef DSP_USE_ACCELERATE
if (setup->direction == DM_FFT_FORWARD) {
frequency_->fillFromVector(timeDomain_, timeDomainLength_/2);
vDSP_fft_zrip(setup->fftSetup, (DSPSplitComplex*)frequency_, 1, setup->logFftSize, FFT_FORWARD);
} else {
vDSP_fft_zrip(setup->fftSetup, (DSPSplitComplex*)frequency_, 1, setup->logFftSize, FFT_INVERSE);
frequency_->toRealVector(timeDomain_, offset_, timeDomainLength_);
}
#else
if (setup->direction == DM_FFT_FORWARD) {
memcpy(setup->temp, timeDomain_, sizeof(float) * timeDomainLength_);
kiss_fftr(setup->fftSetup, (const kiss_fft_scalar *)setup->temp, (kiss_fft_cpx*)frequency_->data);
} else {
kiss_fftri(setup->fftSetup, (const kiss_fft_cpx*)frequency_->data, (kiss_fft_scalar *)setup->temp);
memcpy(timeDomain_, setup->temp + offset_ * 2, timeDomainLength_ * sizeof(float));
dm_vsfill(0, timeDomain_ + timeDomainLength_, frequency_->size());
}
#endif
}
// performs a hanning window function and a fft on the input
static void analyze (const char *filename) {
SNDFILE *sndFile;
SF_INFO sfInfo;
float in[BUFFER_LEN];
kiss_fftr_cfg cfg;
kiss_fft_cpx out[BUFFER_LEN];
cfg = kiss_fftr_alloc(BUFFER_LEN, 0, 0, 0);
if (! (sndFile = sf_open(filename, SFM_READ, &sfInfo))) {
printf("Could not open file %s\n", filename);
}
int i;
int buffer_channel = BUFFER_LEN * sfInfo.channels;
int count;
double window;
double mag, hz;
while ((count = sf_read_float(sndFile, in, buffer_channel)) > 0) {
for (i = 0; i < BUFFER_LEN; i++) {
// hanning window
window = 1.5 * (1 - cos(2*M_PI*i/BUFFER_LEN-1));
in[i] = window * in[i];
}
// fft
kiss_fftr(cfg, in, out);
for (i = 0; i < count/2; i++) {
// print frequency and power (linear)
mag = sqrt(pow(out[i].r, 2) + pow(out[i].i, 2));
double hz = (double)i * 44100.0 / (double)count;
printf("%f hz = %f\n", hz, mag);
}
}
sf_close(sndFile);
free(cfg);
}
/*
* Class: euphony_lib_receiver_KissFFT
* Method: spectrum
* Signature: (JLjava/nio/ShortBuffer;Ljava/nio/FloatBuffer;)V
*/
JNIEXPORT void JNICALL Java_euphony_lib_receiver_KissFFT_spectrum(JNIEnv *env, jobject, jlong handle, jobject source, jobject target)
{
KissFFT* fft = (KissFFT*)handle;
kiss_fft_scalar* samples = (kiss_fft_scalar*)env->GetDirectBufferAddress( source );
float* spectrum = (float*)env->GetDirectBufferAddress( target );
kiss_fftr( fft->config, samples, fft->spectrum ); //<--- fatal signal 11 (SIGSEV) at 0x00000400
int len = fft->numSamples / 2 + 1; // <=--- <--- fatal signal 11 (SIGSEV) at 0x00000408
// int len = 6; // <-- for debugging
int start = len * (16500.0 / 22050.0);
for( int i = start; i < len; i++ )
{
float re = scale(fft->spectrum[i].r) * fft->numSamples;
float im = scale(fft->spectrum[i].i) * fft->numSamples;
if( i > 0 )
spectrum[i] = sqrtf(re*re + im*im) / (fft->numSamples / 2);
else
spectrum[i] = sqrtf(re*re + im*im) / (fft->numSamples);
}
}
JNIEXPORT void JNICALL Java_de_jurihock_voicesmith_dsp_KissFFT_fft
(JNIEnv* env, jobject, jlong handle, jfloatArray _buffer)
{
KissFFT* fft = (KissFFT*)handle;
float* buffer = (float*)env->GetPrimitiveArrayCritical(_buffer, 0);
// Circular shift by N/2
fftshift(fft, buffer);
// fft(buffer) => spectrum
kiss_fftr(fft->forward, buffer, fft->spectrum);
// Re(Nyquist) => Im(DC)
fft->spectrum[0].i = fft->spectrum[fft->size/2].r;
// spectrum => buffer
memcpy(buffer, fft->spectrum, sizeof(float)*fft->size);
// LOG("FFT DC (%f,%f)", fft->spectrum[0].r, fft->spectrum[0].i);
// LOG("FFT Nyquist (%f,%f)", fft->spectrum[fft->size/2].r, fft->spectrum[fft->size/2].i);
env->ReleasePrimitiveArrayCritical(_buffer, buffer, 0);
}
int
main(int argc, char **argv)
{
//int nt; /* number of frequency samples per trace */
int nfft; /* For computing the FFT */
//float dw; /* time sampling interval */
//int i1; /* time sample index */
//int log; /* Check if the trace has had a log applied (for mie scattering) */
int j; /* Other indices */
const double eps = 1.e-32;
kiss_fftr_cfg forw, invs;
/* Variables for Jons example */
float *spectrum = NULL;
float *rspectrum = NULL;
complex *fft = NULL;
int n = 64;
int nw = n/2+1;
float o1 = -M_PI/2;
float d1 = M_PI/n;
nfft = n;
/* hook up getpar */
initargs(argc, argv);
//requestdoc(1);
requestdoc(0); // For now (testing), stdin is not used
/* Allocating memory */
spectrum = ealloc1float((n+1));
rspectrum = ealloc1float((n/2+1));
fft = alloc1complex(nfft/2+1);
forw = kiss_fftr_alloc(nfft,0,NULL,NULL);
invs = kiss_fftr_alloc(nfft,1,NULL,NULL);
if(NULL == forw || NULL == invs)
err("KISS FFT allocation error");
memset( (void *) tr.data, 0, (n+1) * FSIZE);
tr.dt = d1;
tr.f1 = o1;
tr.ns = n;
create_spectrum(n, o1, d1, spectrum);
/* Squaring the spectrum */
j = n/2;
for(int i = 0; i < nw; i++, j++) {
rspectrum[i] = spectrum[j]*spectrum[j];
tr.data[i] = rspectrum[i];
}
fprintf(stderr, "Created input: \n");
for(int i = 0; i < nw; i++) {
fprintf(stderr, "i=%d input=%f\n",i,rspectrum[i]);
}
fprintf(stderr, "\n");
// Take the log and create a complex type
//fprintf(stderr, "Log of spectrum: \n");
for(int i = 0; i < nw; i++) {
fft[i] = cmplx(log(rspectrum[i]+eps)/nfft,0.);
}
//for(int i = 0; i < nw; i++) {
// fprintf(stderr, "i=%d real=%f imag=%f\n",i,fft[i].r,fft[i].i);
//}
//fprintf(stderr, "\n");
// Find the inverse FFT
kiss_fftri(invs,(const kiss_fft_cpx *) fft, tr.data);
tr.data[0] *= 0.5;
tr.data[nfft/2] *= 0.5;
for(int i=1+nfft/2; i < nfft; i++) {
tr.data[i] = 0;
}
kiss_fftr(forw, tr.data, (kiss_fft_cpx *) fft);
for(int i=0; i < nw; i++) {
fft[i] = crmul(cwp_cexp(fft[i]),1./nfft);
}
kiss_fftri(invs,(const kiss_fft_cpx *) fft, tr.data);
float dt = 0.004;
for(int i = 0; i < nfft; i++) {
fprintf(stderr, "i=%d t=%f output=%f\n", i, o1+dt*i, tr.data[i]);
}
puttr(&tr);
return(CWP_Exit());
}
void UI_ZScoreWindow::startButtonClicked()
{
int i,
datrec_offset,
total_datrecs,
smpls,
smp_per_record,
smpls_in_epoch,
dftblocksize,
fft_outputbufsize,
smpls_in_inputbuf,
smpls_copied,
epochs,
f1,
f2,
f3,
f4,
power_neg_cnt,
power_pos_cnt,
progress_steps;
double *buf,
*fft_inputbuf,
*fft_outputbuf,
samplefreq,
freqstep,
power_delta,
power_theta,
power_alpha,
power_beta,
power_total,
power_neg,
power_pos;
struct edfhdrblock *hdr;
struct signalcompblock *signalcomp;
crossoverfreq = crossoverSpinbox->value();
mainwindow->z_score_var.crossoverfreq = crossoverfreq;
z_threshold = thresholdSpinbox->value();
mainwindow->z_score_var.z_threshold = z_threshold;
zscore_page_len = pagelenSpinbox->value() / 2;
mainwindow->z_score_var.zscore_page_len = zscore_page_len * 2;
// zscore_error_detection = errordetectionSpinbox->value();
// mainwindow->z_score_var.zscore_error_detection = zscore_error_detection;
z_hysteresis = hysteresisSpinbox->value();
mainwindow->z_score_var.z_hysteresis = z_hysteresis;
z_hysteresis /= 2.0;
signalcomp = mainwindow->signalcomp[signalnr];
hdr = signalcomp->edfhdr;
total_datrecs = hdr->datarecords;
smp_per_record = hdr->edfparam[signalcomp->edfsignal[0]].smp_per_record;
dftblocksize = ((long long)smp_per_record * (ZSCORE_EPOCH_LEN * TIME_DIMENSION)) / hdr->long_data_record_duration;
if(dftblocksize < (ZSCORE_EPOCH_LEN * 100))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplerate of selected signal is too low");
messagewindow.exec();
curve1->clear();
return;
}
smpls_in_epoch = dftblocksize;
epochs = (hdr->datarecords * (long long)smp_per_record) / (long long)smpls_in_epoch;
samplefreq = (double)smp_per_record / ((double)hdr->long_data_record_duration / TIME_DIMENSION);
if(samplefreq < 99.9999999)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency of the selected signal must be at least 100 Hz.");
messagewindow.exec();
curve1->clear();
return;
}
fft_outputbufsize = dftblocksize / 2;
freqstep = samplefreq / (double)dftblocksize;
if(freqstep > 1.0001)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Frequency bin of FFT is more than 1 Hz.");
messagewindow.exec();
curve1->clear();
return;
}
f2 = crossoverfreq / freqstep;
f1 = ZSCORE_F1 / freqstep;
f3 = ZSCORE_F3 / freqstep;
f4 = ZSCORE_F4 / freqstep;
fft_inputbuf = (double *)malloc(sizeof(double) * dftblocksize);
if(fft_inputbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
curve1->clear();
return;
}
fft_outputbuf = (double *)calloc(1, sizeof(double) * fft_outputbufsize);
if(fft_outputbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
curve1->clear();
free(fft_inputbuf);
return;
}
if(zscore_epoch_buf != NULL)
{
free(zscore_epoch_buf);
}
zscore_epoch_buf = (double *)calloc(1, sizeof(double) * epochs);
if(zscore_epoch_buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
curve1->clear();
free(fft_inputbuf);
free(fft_outputbuf);
return;
}
if(zscore_page_buf != NULL)
{
free(zscore_page_buf);
}
zscore_page_buf = (double *)calloc(1, sizeof(double) * ((epochs / zscore_page_len) + 1));
if(zscore_page_buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
curve1->clear();
free(fft_inputbuf);
free(fft_outputbuf);
return;
}
if(zscore_sleepstage_buf != NULL)
{
free(zscore_sleepstage_buf);
}
zscore_sleepstage_buf = (int *)calloc(1, sizeof(int) * ((epochs / zscore_page_len) + 1));
if(zscore_sleepstage_buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
curve1->clear();
free(fft_inputbuf);
free(fft_outputbuf);
return;
}
// printf("epochs / zscore_page_len is %i\n",
// epochs / zscore_page_len);
kiss_fftr_cfg cfg;
kiss_fft_cpx *kiss_fftbuf;
kiss_fftbuf = (kiss_fft_cpx *)malloc((fft_outputbufsize + 1) * sizeof(kiss_fft_cpx));
if(kiss_fftbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
curve1->clear();
free(fft_inputbuf);
free(fft_outputbuf);
return;
}
cfg = kiss_fftr_alloc(dftblocksize, 0, NULL, NULL);
FilteredBlockReadClass blockread;
buf = blockread.init_signalcomp(signalcomp, 1, 0);
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Internal error: init_signalcomp()");
messagewindow.exec();
curve1->clear();
free(fft_inputbuf);
free(fft_outputbuf);
free(cfg);
free(kiss_fftbuf);
return;
}
QProgressDialog progress("Processing ...", "Abort", 0, (int)hdr->datarecords, zscore_dialog);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = total_datrecs / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
if(progress_steps > 50)
{
progress_steps = 50;
}
// printf("total_datrecs is %i\n"
// "smp_per_record is %i\n"
// "dftblocksize is %i\n"
// "smpls_in_epoch is %i\n"
// "epochs is %i\n"
// "samplefreq is %f\n"
// "fft_outputbufsize is %i\n"
// "freqstep is %f\n"
// "f1 is %i\n"
// "f2 is %i\n"
// "f3 is %i\n"
// "f4 is %i\n"
// "z_hysteresis is %f\n",
// total_datrecs,
// smp_per_record,
// dftblocksize,
// smpls_in_epoch,
// epochs,
// samplefreq,
// fft_outputbufsize,
// freqstep,
// f1,
// f2,
// f3,
// f4,
// z_hysteresis);
epoch_cntr = 0;
smpls_in_inputbuf = 0;
// FILE *test_file1 = fopen("testfile1.dat", "wb");
// if(test_file1 == NULL)
// {
// printf("error opening file\n");
// return;
// }
//
// FILE *test_file2 = fopen("testfile2.dat", "wb");
// if(test_file2 == NULL)
// {
// printf("error opening file\n");
// return;
// }
for(datrec_offset=0; datrec_offset < total_datrecs; datrec_offset++)
// for(datrec_offset=0; datrec_offset < 2; datrec_offset++)
{
// printf("\ndatrec_offset is %i\n", datrec_offset);
// printf("smpls_in_inputbuf is %i\n", smpls_in_inputbuf);
if(!(datrec_offset % progress_steps))
{
progress.setValue(datrec_offset);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
break;
}
}
if(blockread.process_signalcomp(datrec_offset))
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read-error occurred.");
messagewindow.exec();
curve1->clear();
free(fft_inputbuf);
free(fft_outputbuf);
free(cfg);
free(kiss_fftbuf);
return;
}
smpls = blockread.samples_in_buf();
// fwrite(buf, smpls * sizeof(double), 1, test_file1);
// printf("smpls is %i\n", smpls);
// for(k=0; k<smpls; k++)
// {
// printf("%4.4f ", buf[k]);
// if((!(k%4)) && k)
// {
// putchar('\n');
// }
// }
// putchar('\n');
smpls_copied = 0;
while(smpls > 0)
{
// printf("while(smpls > 0)\n");
if(smpls < (dftblocksize - smpls_in_inputbuf))
{
memcpy(fft_inputbuf + smpls_in_inputbuf, buf, smpls * sizeof(double));
// for(j=0; j<smpls; j++)
// {
// fft_inputbuf[j + smpls_in_inputbuf] = buf[j];
// }
// printf("copy:\n");
// for(k=0; k<smpls; k++)
// {
// printf("%4.4f ", fft_inputbuf[k + smpls_in_inputbuf]);
// if((!(k%4)) && k)
// {
// putchar('\n');
// }
// }
// putchar('\n');
smpls_in_inputbuf += smpls;
smpls = 0;
// printf("break\n");
break;
}
memcpy(fft_inputbuf + smpls_in_inputbuf, buf + smpls_copied, (dftblocksize - smpls_in_inputbuf) * sizeof(double));
// for(j=0; j<(dftblocksize - smpls_in_inputbuf); j++)
// {
// fft_inputbuf[j + smpls_in_inputbuf] = buf[j + smpls_copied];
// }
// printf("smpls_copied is %i\n", smpls_copied);
smpls_copied += (dftblocksize - smpls_in_inputbuf);
// printf("smpls_copied is %i\n", smpls_copied);
smpls -= (dftblocksize - smpls_in_inputbuf);
// printf("smpls is %i\n", smpls);
smpls_in_inputbuf = 0;
// fwrite(fft_inputbuf, dftblocksize * sizeof(double), 1, test_file2);
kiss_fftr(cfg, fft_inputbuf, kiss_fftbuf);
power_delta = 0.0;
power_theta = 0.0;
power_alpha = 0.0;
power_beta = 0.0;
power_total = 0.0;
for(i=0; i<fft_outputbufsize; i++)
{
fft_outputbuf[i] = (((kiss_fftbuf[i].r * kiss_fftbuf[i].r) + (kiss_fftbuf[i].i * kiss_fftbuf[i].i)) / fft_outputbufsize);
// if(epoch_cntr == 0)
// {
// printf("fft_outputbuf[%i] is %.14f\n", i, fft_outputbuf[i]);
// }
if((i > 0) && (i < f1))
{
power_delta += fft_outputbuf[i];
}
if((i >= f1) && (i < f2))
{
power_theta += fft_outputbuf[i];
}
if((i >= f2) && (i < f3))
{
power_alpha += fft_outputbuf[i];
}
if((i >= f3) && (i <= f4))
{
power_beta += fft_outputbuf[i];
}
power_total += fft_outputbuf[i];
}
if(power_total <= 0.0)
{
zscore_epoch_buf[epoch_cntr++] = 0.0;
}
else
{
zscore_epoch_buf[epoch_cntr++] = ((power_delta + power_theta) - (power_alpha + power_beta)) / power_total;
}
// if(epoch_cntr < 3)
// {
// printf("zscore_epoch_buf[%i] is %f\n", epoch_cntr - 1, zscore_epoch_buf[epoch_cntr - 1]);
// printf("power_delta is %f\n"
// "power_theta is %f\n"
// "power_alpha is %f\n"
// "power_beta is %f\n"
// "power_total is %f\n\n",
// power_delta, power_theta, power_alpha, power_beta, power_total);
// }
if(epoch_cntr >= epochs)
{
break;
}
}
if(epoch_cntr >= epochs)
{
break;
}
}
power_pos = 0.0;
power_neg = 0.0;
power_pos_cnt = 0;
power_neg_cnt = 0;
zscore_pages = 0;
for(i=0; i<epoch_cntr; i++)
{
if(i && (!(i % zscore_page_len)))
{
if(power_neg_cnt)
{
power_neg /= power_neg_cnt;
}
if(power_pos_cnt)
{
power_pos /= power_pos_cnt;
}
if(power_neg_cnt >= power_pos_cnt)
{
zscore_page_buf[zscore_pages] = power_neg;
zscore_sleepstage_buf[zscore_pages] = 0;
}
else
{
zscore_page_buf[zscore_pages] = power_pos;
zscore_sleepstage_buf[zscore_pages] = 1;
}
zscore_pages++;
power_pos = 0.0;
power_neg = 0.0;
power_pos_cnt = 0;
power_neg_cnt = 0;
}
if(zscore_epoch_buf[i] < ZSCORE_ERRORLEVEL)
{
if(zscore_pages > 0)
{
if(zscore_sleepstage_buf[zscore_pages - 1] == 0)
{
// printf("if(zscore_sleepstage_buf[zscore_pages - 1] == 0) : %f < %f + %f\n",
// zscore_epoch_buf[i], z_threshold, z_hysteresis);
if(zscore_epoch_buf[i] < (z_threshold + z_hysteresis))
{
power_neg += zscore_epoch_buf[i];
power_neg_cnt++;
}
else
{
power_pos += zscore_epoch_buf[i];
power_pos_cnt++;
}
}
else
{
// printf("else : %f < %f + %f\n",
// zscore_epoch_buf[i], z_threshold, z_hysteresis);
if(zscore_epoch_buf[i] < (z_threshold - z_hysteresis))
{
power_neg += zscore_epoch_buf[i];
power_neg_cnt++;
}
else
{
power_pos += zscore_epoch_buf[i];
power_pos_cnt++;
}
}
}
else
{
if(zscore_epoch_buf[i] < z_threshold)
{
power_neg += zscore_epoch_buf[i];
power_neg_cnt++;
}
else
{
power_pos += zscore_epoch_buf[i];
power_pos_cnt++;
}
}
}
}
// printf("epoch_cntr is %i zscore_pages is %i\n",
// epoch_cntr, zscore_pages);
// Delta: 0.5 - 2.0 Hz
// Theta: 2.5 - 7.0 Hz
// Alpha: 7.5 - 11.5 Hz
// Beta: 12.0 - 25.0 Hz
// Stage Z ratio (mean +-SD)
// ----------------------------
// Wake -0.181 +- .055
// REM 0.156 +- .043
// 1 0.066 +- .101
// 2 0.207 +- .067
// 3 0.443 +- .034
// 4 0.527 +- .039
// ZRatio = ((Delta + Theta) - (Alpha + Beta)) / (Delta + Theta + Alpha + Beta)
progress.reset();
RadioButtonsClicked(true);
free(fft_inputbuf);
free(fft_outputbuf);
free(cfg);
free(kiss_fftbuf);
mainwindow->setup_viewbuf();
// printf("epoch_cntr is %i epochs is %i\n", epoch_cntr, epochs);
// fclose(test_file1);
// fclose(test_file2);
}
void velcon(float ** data /* [nx][nt] */,
float v0 /* initial velocity */,
float v1 /* new velocity */)
/*< apply velocity continuation >*/
{
int it, ix, i2, iw;
float *trace, k, w, t;
sf_complex shift;
for (it=0; it < nt; it++) {
sf_cosft_frw (data[0], it, nt);
}
for (ix=0; ix < nx; ix++) {
/* loop over wavenumbers */
k = ix*dx;
k *= k*(v0*v0 - v1*v1)/16;
trace = data[ix];
/* stretch t -> t^2 */
for (it=0; it < nt; it++) {
trace[it] /= nt;
}
fint1_set(str,trace);
for (i2=0; i2 < n2; i2++) {
t = o2+i2*d2;
t = sqrtf(t);
t = (t-t0)/dt;
it = t;
if (it >= 0 && it < nt) {
strace[i2] = fint1_apply(str,it,t-it,false);
} else {
strace[i2] = 0.;
}
}
for (i2=n2; i2 < n3; i2++) {
strace[i2] = 0.;
}
/* FFT */
kiss_fftr(forw,strace, (kiss_fft_cpx *) ctrace);
/* velocity continuation */
ctrace[0]=sf_cmplx(0.,0.); /* dc */
for (iw=1; iw < nw; iw++) {
w = iw*dw;
w = k/w;
shift = sf_cmplx(cosf(w)/n3,sinf(w)/n3);
#ifdef SF_HAS_COMPLEX_H
ctrace[iw] *= shift;
#else
ctrace[iw] = sf_cmul(ctrace[iw],shift);
#endif
}
/* Inverse FFT */
kiss_fftri(invs,(const kiss_fft_cpx *) ctrace, strace);
/* inverse stretch t^2->t */
fint1_set(istr,strace);
for (it=0; it < nt; it++) {
t = t0+it*dt;
t = t*t;
t = (t-o2)/d2;
i2 = t;
if (i2 >= 0 && i2 < n2) {
trace[it] = fint1_apply(istr,i2,t-i2,false);
} else {
trace[it] = 0.;
}
}
} /* ix */
/* inverse cosine FT in space */
for (it=0; it < nt; it++) {
sf_cosft_inv (data[0], it, nt);
}
}
void rfft( FFT_Tables *fft_tables, double *x, int logm )
{
#if 0
/* sur: do not use real-only optimized FFT */
double xi[1 << MAXLOGR];
int nfft;
if ( logm > MAXLOGR )
{
fprintf(stderr, "rfft size too big\n");
exit(1);
}
nfft = logm_to_nfft[logm];
if ( nfft )
{
//unsigned int i;
//for ( i = 0; i < nfft; i++ )
//{
// xi[i] = 0.0;
//}
memset( xi, 0, nfft * sizeof( xi[0] ) );
fft( fft_tables, x, xi, logm );
memcpy( x + nfft / 2, xi, ( nfft / 2 ) * sizeof(x[0]) );
}
else
{
fprintf( stderr, "bad config for logm = %d\n", logm);
exit( 1 );
}
#else
/* sur: use real-only optimized FFT */
int nfft = 0;
kiss_fft_scalar fin[1 << MAXLOGR];
kiss_fft_cpx fout[1 << MAXLOGR];
if ( logm > MAXLOGR )
{
fprintf(stderr, "fft size too big\n");
exit(1);
}
nfft = logm_to_nfft[logm];
if ( fft_tables->cfg[logm][0] == NULL )
{
if ( nfft )
{
fft_tables->cfg[logm][0] = kiss_fftr_alloc( nfft, 0, NULL, NULL );
}
else
{
fprintf(stderr, "bad logm = %d\n", logm);
exit( 1 );
}
}
if ( fft_tables->cfg[logm][0] )
{
unsigned int i;
for ( i = 0; i < nfft; i++ )
{
fin[i] = x[i];
}
kiss_fftr( (kiss_fftr_cfg)fft_tables->cfg[logm][0], fin, fout );
for ( i = 0; i < nfft / 2; i++ )
{
x[i] = fout[i].r;
x[i + nfft / 2] = fout[i].i;
}
}
else
{
fprintf( stderr, "bad config for logm = %d\n", logm);
exit( 1 );
}
#endif
}
/* real-to-complex transform in 1 dimension */
int tcl_rfft_1d(ClientData nodata, Tcl_Interp *interp,
int objc, Tcl_Obj *const objv[])
{
Tcl_Obj *result, **tdata;
const char *name;
kiss_fft_scalar *timed;
kiss_fft_cpx *freqd;
kiss_fftr_cfg work;
int dir, ndat, k;
/* thread safety */
Tcl_MutexLock(&myFftMutex);
/* set defaults: */
dir = FFT_FORWARD;
ndat = -1;
/* Parse arguments:
*
* usage: r2cfft_1d <data>
* or: c2rfft_1d <data>
*
* r2cfftf_1d : is the 1d real-to-complex forward transform.
* c2rfftb_1d : is the 1d complex-to-real backward transform.
* <data> : list containing data to be transformed. this can either a real
* or a list with two reals interpreted as complex.
*/
name = Tcl_GetString(objv[0]);
if (strcmp(name,"r2cfft_1d") == 0) {
dir = FFT_FORWARD;
} else if (strcmp(name,"c2rfft_1d") == 0) {
dir = FFT_BACKWARD;
} else {
Tcl_AppendResult(interp, name, ": unknown fft command.", NULL);
Tcl_MutexUnlock(&myFftMutex);
return TCL_ERROR;
}
if (objc != 2) {
Tcl_WrongNumArgs(interp, 1, objv, "<data>");
Tcl_MutexUnlock(&myFftMutex);
return TCL_ERROR;
}
/* get handle on data */
Tcl_IncrRefCount(objv[1]);
if (Tcl_ListObjGetElements(interp, objv[1], &ndat, &tdata) != TCL_OK) {
Tcl_DecrRefCount(objv[1]);
Tcl_MutexUnlock(&myFftMutex);
return TCL_ERROR;
}
if (ndat < 0) { /* this should not happen, but... */
Tcl_AppendResult(interp, name, ": illegal data array.", NULL);
Tcl_DecrRefCount(objv[1]);
Tcl_MutexUnlock(&myFftMutex);
return TCL_ERROR;
}
/* no effect for zero or one element */
if ((ndat == 0) || (ndat == 1)) {
Tcl_DecrRefCount(objv[1]);
Tcl_SetObjResult(interp, objv[1]);
Tcl_MutexUnlock(&myFftMutex);
return TCL_OK;
}
/* we need an even number of data points for the forward transform */
if (ndat & 1) {
if (dir == FFT_FORWARD) {
Tcl_AppendResult(interp, name, " needs an even number of data points.", NULL);
Tcl_DecrRefCount(objv[1]);
Tcl_MutexUnlock(&myFftMutex);
return TCL_ERROR;
}
}
check_thread_count(interp,"fftcmds");
/* size of data arrays for backward transform */
if (dir == FFT_BACKWARD) ndat = (ndat-1)*2;
/* get dynamic storage for passing data to the lowlevel code. */
timed = (void *)Tcl_Alloc(ndat*sizeof(kiss_fft_scalar));
freqd = (void *)Tcl_Alloc((ndat/2+1)*sizeof(kiss_fft_cpx));
work = kiss_fftr_alloc(ndat, dir, NULL, NULL);
/* parse/copy data list */
if (dir == FFT_FORWARD) {
for (k=0; k<ndat; ++k) {
if (Tcl_GetDoubleFromObj(interp, tdata[k], timed + k) != TCL_OK) {
Tcl_AppendResult(interp, name, ": illegal data array.", NULL);
Tcl_DecrRefCount(objv[1]);
Tcl_MutexUnlock(&myFftMutex);
return TCL_ERROR;
}
}
} else {
for (k=0; k<(ndat/2)+1; ++k) {
if (read_list_cpx(interp, tdata[k], freqd + k) != TCL_OK) {
Tcl_AppendResult(interp, name, ": illegal data array.", NULL);
Tcl_DecrRefCount(objv[1]);
Tcl_MutexUnlock(&myFftMutex);
return TCL_ERROR;
}
}
}
Tcl_DecrRefCount(objv[1]);
/* finally run the transform */
if (dir == FFT_FORWARD) {
kiss_fftr(work, timed, freqd);
} else {
kiss_fftri(work, freqd, timed);
}
/* prepare results */
result = Tcl_NewListObj(0, NULL);
if (dir == FFT_FORWARD) {
for (k=0; k<(ndat/2)+1; ++k) {
make_list_cpx(interp, result, freqd + k);
}
} else {
for (k=0; k<ndat; ++k) {
Tcl_ListObjAppendElement(interp, result, Tcl_NewDoubleObj(timed[k]));
}
}
Tcl_SetObjResult(interp, result);
/* free intermediate storage */
Tcl_Free((char *)timed);
Tcl_Free((char *)freqd);
kiss_fft_free(work);
kiss_fft_cleanup();
Tcl_MutexUnlock(&myFftMutex);
return TCL_OK;
}
/*
* Audio visualization,
* just HANN -> FFT -> dB scale -> pack in 8-bit
* could be used to push vocal input events to the
* main engine with little extra work for singalong-
* style controls
*/
static void generate_frame()
{
/* window size is twice the possible output,
* since the FFT will be N/2 out */
const int smpl_wndw = AUD_VIS_HRES * 2;
static float smplbuf[AUD_VIS_HRES * 2];
static kiss_fft_scalar fsmplbuf[AUD_VIS_HRES * 2];
static kiss_fft_cpx foutsmplbuf[AUD_VIS_HRES * 2];
static bool gotfft;
static kiss_fftr_cfg kfft;
if (!gotfft){
kfft = kiss_fftr_alloc(smpl_wndw, false, NULL, NULL);
gotfft = true;
}
static int smplc;
static double vptsc = 0;
int16_t* basep = (int16_t*) decctx.audp;
int counter = decctx.shmcont.addr->abufused;
while (counter){
/* could've split the window up into
* two functions and used the b and a channels
* but little point atm. */
float lv = (*basep++) / 32767.0f;
float rv = (*basep++) / 32767.0f;
float smpl = (lv + rv) / 2.0f;
smplbuf[smplc] = smpl;
/* hann window float sample before FFT */
float winv = 0.5f * ( 1.0f - cosf(2.0 * M_PI * smplc / (float) smpl_wndw));
fsmplbuf[smplc] = smpl + 1.0 * winv;
smplc++;
counter -= 4; /* 4 bytes consumed */
if (smplc == smpl_wndw){
smplc = 0;
uint8_t* base = decctx.vidp;
kiss_fftr(kfft, fsmplbuf, foutsmplbuf);
/* store FFT output in dB scale */
float low = 255.0f;
float high = 0.0f;
for (int j= 0; j < smpl_wndw / 2; j++)
{
float magnitude = sqrtf(foutsmplbuf[j].r * foutsmplbuf[j].r +
foutsmplbuf[j].i * foutsmplbuf[j].i);
fsmplbuf[j] = 10.0f * log10f(magnitude);
if (fsmplbuf[j] < low)
low = fsmplbuf[j];
if (fsmplbuf[j] > high)
high = fsmplbuf[j];
}
/* wasting a level just to get POT as the interface doesn't
* support a 1D texture format */
for (int j=0; j<smpl_wndw / 2; j++){
*base++ = 0;
*base++ = 0;
*base++ = 0;
*base++ = 0xff;
}
/* pack in output image, smooth two audio samples */
for (int j=0; j < smpl_wndw / 2; j++){
*base++ = (1.0f + ((smplbuf[j * 2] +
smplbuf[j * 2 + 1]) / 2.0)) / 2.0 * 255.0;
*base++ = (fsmplbuf[j] / high) * 255.0;
*base++ = 0x00;
*base++ = 0xff;
}
decctx.shmcont.addr->vpts = vptsc;
arcan_shmif_signal(&decctx.shmcont, SHMIF_SIGVID);
vptsc += 1000.0f / (
(double)(ARCAN_SHMPAGE_SAMPLERATE) / (double)smpl_wndw);
}
}
arcan_shmif_signal(&decctx.shmcont, SHMIF_SIGVID);
}
jdoubleArray Java_edu_cornell_audioProbe_AudioManager_features(JNIEnv* env, jobject javaThis, jshortArray array) {
//void Java_edu_cornell_audioProbe_AudioManager_features(JNIEnv* env, jobject javaThis, jshortArray array) {
(*env)->GetShortArrayRegion(env, array, 0, FRAME_LENGTH, buf);
normalize_data();
// apply window
computeHamming();
// computeFwdFFT
kiss_fftr(cfgFwd, normalizedData, fftx);
//compute power spectrum
computePowerSpec(fftx, powerSpec, FFT_LENGTH);
//compute magnitude spectrum
computeMagnitudeSpec(powerSpec, magnitudeSpec, FFT_LENGTH);
// compute total energy
energy = computeEnergy(powerSpec, FFT_LENGTH) / FFT_LENGTH;
//compute Spectral Entropy
computeSpectralEntropy2(magnitudeSpec, FFT_LENGTH);
//compute auto-correlation peaks
computeAutoCorrelationPeaks2(powerSpec, powerSpecCpx, NOISE_LEVEL, FFT_LENGTH);
//data output
////return data as variable size array caused by variable autocorrelation information.
jdoubleArray featureVector = (*env)->NewDoubleArray(env,6 + 2*numAcorrPeaks + 2 + LOOK_BACK_LENGTH);
//jdoubleArray featureVector = (*env)->NewDoubleArray(env,6 + 2*numAcorrPeaks + 2 + LOOK_BACK_LENGTH + FFT_LENGTH);
featuresValuesTemp[0] = numAcorrPeaks; //autocorrelation values
featuresValuesTemp[1] = maxAcorrPeakVal;
featuresValuesTemp[2] = maxAcorrPeakLag;
featuresValuesTemp[3] = spectral_entropy;
featuresValuesTemp[4] = rel_spectral_entropy;
featuresValuesTemp[5] = energy;
//gaussian distribution
//test the gaussian distribution with some dummy values first
x[0] = maxAcorrPeakVal;
x[1] = numAcorrPeaks;
x[2] = rel_spectral_entropy;
/*
emissionVoiced = computeMvnPdf(x,mean_voiced, inv_cov_voiced, denom_gauss_voiced);
emissionUnvoiced = computeMvnPdf(x,mean_unvoiced, inv_cov_unvoiced, denom_gauss_unvoiced);
*/
inferenceResult = getViterbiInference(x,featureAndInference);
memcpy( featuresValuesTemp+6, featureAndInference, (2+LOOK_BACK_LENGTH)*sizeof(double) ); //observation probabilities, inferences
//put auto correlation values in the string
memcpy( featuresValuesTemp+6+2+LOOK_BACK_LENGTH, acorrPeakValueArray, numAcorrPeaks*sizeof(double) );
memcpy( featuresValuesTemp+6+numAcorrPeaks+2+LOOK_BACK_LENGTH, acorrPeakLagValueArray, numAcorrPeaks*sizeof(double) );
//memcpy( featuresValuesTemp+6+numAcorrPeaks+numAcorrPeaks+2+LOOK_BACK_LENGTH, magnSpect, FFT_LENGTH*sizeof(double) );
(*env)->SetDoubleArrayRegion( env, featureVector, 0, 6 + numAcorrPeaks*2 + 2 + LOOK_BACK_LENGTH, (const jdouble*)featuresValuesTemp );
//(*env)->SetDoubleArrayRegion( env, featureVector, 0, 6 + numAcorrPeaks*2 + 2 + LOOK_BACK_LENGTH + FFT_LENGTH, (const jdouble*)featuresValuesTemp );
return featureVector;
}
void fft3(float *inp /* [n1*n2*n3] */,
sf_complex *out /* [nk*n2*n3] */)
/*< 3-D FFT >*/
{
int i1, i2, i3;
float f;
#ifdef SF_HAS_FFTW
if (NULL==cfg) {
cfg = cmplx?
fftwf_plan_dft_3d(n3,n2,n1,
(fftwf_complex *) cc[0][0],
(fftwf_complex *) out,
FFTW_FORWARD, FFTW_MEASURE):
fftwf_plan_dft_r2c_3d(n3,n2,n1,
ff[0][0], (fftwf_complex *) out,
FFTW_MEASURE);
if (NULL == cfg) sf_error("FFTW failure.");
}
#endif
/* FFT centering */
for (i3=0; i3<n3; i3++) {
for (i2=0; i2<n2; i2++) {
for (i1=0; i1<n1; i1++) {
f = inp[(i3*n2+i2)*n1+i1];
if (cmplx) {
cc[i3][i2][i1] = sf_cmplx((((i3%2==0)==(i2%2==0))==(i1%2==0))? f:-f,0.);
} else {
ff[i3][i2][i1] = ((i3%2==0)==(i2%2==0))? f:-f;
}
}
}
}
#ifdef SF_HAS_FFTW
fftwf_execute(cfg);
#else
/* FFT over first axis */
for (i3=0; i3 < n3; i3++) {
for (i2=0; i2 < n2; i2++) {
if (cmplx) {
kiss_fft_stride(cfg1,(kiss_fft_cpx *) cc[i3][i2],tmp[i3][i2],1);
} else {
kiss_fftr (cfg,ff[i3][i2],tmp[i3][i2]);
}
}
}
/* FFT over second axis */
for (i3=0; i3 < n3; i3++) {
for (i1=0; i1 < nk; i1++) {
kiss_fft_stride(cfg2,tmp[i3][0]+i1,ctrace2,nk);
for (i2=0; i2 < n2; i2++) {
tmp[i3][i2][i1]=ctrace2[i2];
}
}
}
/* FFT over third axis */
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < nk; i1++) {
kiss_fft_stride(cfg3,tmp[0][0]+i2*nk+i1,ctrace3,nk*n2);
for (i3=0; i3<n3; i3++) {
out[(i3*n2+i2)*nk+i1] = trace3[i3];
}
}
}
#endif
}
int main(int argc, char* argv[])
{
fint1 str, istr;
int i1,i2, n1,n2,n3, ix,iv,ih, ib, ie, nb, nx,nv,nh, nw, next;
float d1,o1,d2,o2, eps, w,x,k, v0,v2,v,v1,dv, dx, h0,dh,h, num, den, t, dw;
float *trace=NULL, *strace=NULL, ***stack=NULL, ***stack2=NULL, ***cont=NULL, **image=NULL;
sf_complex *ctrace=NULL, *ctrace0=NULL, shift;
char *time=NULL, *space=NULL, *unit=NULL;
size_t len;
static kiss_fftr_cfg forw, invs;
sf_file in=NULL, out=NULL;
bool sembl;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&nh)) sf_error("No n3= in input");
if (!sf_getint("nb",&nb)) nb=2;
if (!sf_getfloat("eps",&eps)) eps=0.01;
if (!sf_getint("pad",&n2)) n2=n1;
if (!sf_getint("pad2",&n3)) n3=2*kiss_fft_next_fast_size((n2+1)/2);
nw = n3/2+1;
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");
if (!sf_histfloat(in,"o1",&o1)) o1=0.;
o2 = o1*o1;
if(!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
d2 = o1+(n1-1)*d1;
d2 = (d2*d2 - o2)/(n2-1);
if (!sf_getint("nv",&nv)) sf_error("Need nv=");
if (!sf_getfloat("dv",&dv)) sf_error("Need dv=");
if (!sf_getfloat("v0",&v0) &&
!sf_histfloat(in,"v0",&v0)) sf_error("Need v0=");
if (!sf_getbool("semblance",&sembl)) sembl=true;
/* if y, compute semblance; if n, stack */
if(!sf_histfloat(in,"o3",&h0)) sf_error("No o2= in input");
if(!sf_histfloat(in,"d3",&dh)) sf_error("No d2= in input");
if(!sf_histfloat(in,"d2",&dx)) sf_error("No d3= in input");
sf_putfloat(out,"o3",v0+dv);
sf_putfloat(out,"d3",dv);
sf_putint(out,"n3",nv);
sf_putstring(out,"label3","Velocity");
if (NULL != (time = sf_histstring(in,"label1")) &&
NULL != (space = sf_histstring(in,"label2"))) {
len = strlen(time)+strlen(space)+2;
unit = sf_charalloc(len);
snprintf(unit,len,"%s/%s",space,time);
sf_putstring(out,"unit3",unit);
free(time);
free(space);
}
dx = 2*SF_PI/(2*kiss_fft_next_fast_size(nx-1)*dx);
dw = 16*SF_PI/(d2*n3); /* 2pi * 8 */
stack = sf_floatalloc3(n1,nx,nv);
stack2 = sf_floatalloc3(n1,nx,nv);
cont = sf_floatalloc3(n1,nx,nv);
image = sf_floatalloc2(n1,nx);
trace = sf_floatalloc(n1);
strace = sf_floatalloc(n3);
ctrace = sf_complexalloc(nw);
ctrace0 = sf_complexalloc(nw);
if (!sf_getint("extend",&next)) next=4;
/* trace extension */
str = fint1_init(next,n1,0);
istr = fint1_init(next,n2,0);
for (i1=0; i1 < n1*nx*nv; i1++) {
stack[0][0][i1] = 0.;
stack2[0][0][i1] = 0.;
}
sf_cosft_init(nx);
for (ih=0; ih < nh; ih++) {
sf_warning("offset %d of %d;",ih+1,nh);
h = h0 + ih*dh;
h *= h * 0.5;
sf_floatread(image[0],n1*nx,in);
for (i1=0; i1 < n1; i1++) {
sf_cosft_frw(image[0],i1,n1);
}
for (ix=0; ix < nx; ix++) {
x = ix*dx;
x *= x;
k = x * 0.5;
fint1_set(str,image[ix]);
for (i2=0; i2 < n2; i2++) {
t = o2+i2*d2;
t = sqrtf(t);
t = (t-o1)/d1;
i1 = t;
if (i1 >= 0 && i1 < n1) {
strace[i2] = fint1_apply(str,i1,t-i1,false);
} else {
strace[i2] = 0.;
}
}
for (i2=n2; i2 < n3; i2++) {
strace[i2] = 0.;
}
kiss_fftr(forw,strace, (kiss_fft_cpx *) ctrace0);
for (iv=0; iv < nv; iv++) {
v = v0 + (iv+1)* dv;
v1 = h * (1./(v*v) - 1./(v0*v0));
v2 = k * ((v0*v0) - (v*v));
ctrace[0]=sf_cmplx(0.,0.); /* dc */
for (i2=1; i2 < nw; i2++) {
w = i2*dw;
w = v2/w+(v1-0.125*o2)*w;
shift = sf_cmplx(cosf(w),sinf(w));
#ifdef SF_HAS_COMPLEX_H
ctrace[i2] = ctrace0[i2] * shift;
#else
ctrace[i2] = sf_cmul(ctrace0[i2],shift);
#endif
} /* w */
kiss_fftri(invs,(const kiss_fft_cpx *) ctrace, strace);
fint1_set(istr,strace);
for (i1=0; i1 < n1; i1++) {
t = o1+i1*d1;
t = t*t;
t = (t-o2)/d2;
i2 = t;
if (i2 >= 0 && i2 < n2) {
cont[iv][ix][i1] = fint1_apply(istr,i2,t-i2,false);
} else {
cont[iv][ix][i1] = 0.;
}
}
} /* v */
} /* x */
for (iv=0; iv < nv; iv++) {
for (i1=0; i1 < n1; i1++) {
sf_cosft_inv(cont[0][0],i1+iv*nx*n1,n1);
}
}
for (iv=0; iv < nv; iv++) {
for (ix=0; ix < nx; ix++) {
for (i1=0; i1 < n1; i1++) {
t = cont[iv][ix][i1];
stack[iv][ix][i1] += t;
stack2[iv][ix][i1] += t*t;
} /* i1 */
} /* x */
} /* v */
} /* h */
sf_warning(".");
for (iv=0; iv < nv; iv++) {
for (ix=0; ix < nx; ix++) {
for (i1=0; i1 < n1; i1++) {
ib = i1-nb > 0? i1-nb: 0;
ie = i1+nb+1 < n1? i1+nb+1: n1;
num = 0.;
den = 0.;
if (sembl) {
for (i2=ib; i2 < ie; i2++) {
t = stack[iv][ix][i2];
num += t*t;
den += stack2[iv][ix][i2];
}
den *= nh;
trace[i1] = den > 0.? num/den: 0.;
} else {
for (i2=ib; i2 < ie; i2++) {
t = stack[iv][ix][i2];
num += t;
}
den = nh;
trace[i1] = num/(den+ FLT_EPSILON);
}
}
sf_floatwrite (trace,n1,out);
}
}
exit(0);
}
int main (int argc, char* argv[])
{
bool opt, comp, phase, verb;
double n1;
float nw1, b, a, dw, pi;
int nt, nw, i, j, N, m1, M, k, f;
float *TDEx,*TDEy,*TDHx,*TDHy,*outp,*ExHyres,*EyHxres,*ExHypha,*EyHxpha;
float *bb, *pp, *qq, *dd;
sf_file in, out, Ey, Hx, Hy;
kiss_fft_cpx *FDEx=NULL,*FDEy=NULL,*FDHx=NULL,*FDHy=NULL;
kiss_fft_cpx *A=NULL,*B=NULL,*ExAs1=NULL,*HyBs1=NULL,*ExBs1=NULL;
kiss_fft_cpx *HyAs1=NULL,*HxAs1=NULL,*HxBs1=NULL;
kiss_fft_cpx *EyAs1=NULL,*EyBs1=NULL,*ExAs2=NULL;
kiss_fft_cpx *HyBs2=NULL,*ExBs2=NULL,*HyAs2=NULL,*HxAs2=NULL;
kiss_fft_cpx *HxBs2=NULL,*EyAs2=NULL,*EyBs2=NULL,*ExAs3=NULL;
kiss_fft_cpx *HyBs3=NULL,*ExBs3=NULL,*HyAs3=NULL,*HxAs3=NULL;
kiss_fft_cpx *HxBs3=NULL,*EyAs3=NULL,*EyBs3=NULL,*ExAs4=NULL;
kiss_fft_cpx *HyBs4=NULL,*ExBs4=NULL,*HyAs4=NULL,*HxAs4=NULL;
kiss_fft_cpx *HxBs4=NULL,*EyAs4=NULL,*EyBs4=NULL,*ExA1=NULL;
kiss_fft_cpx *HyB1=NULL,*ExB1=NULL,*HyA1=NULL,*HxA1=NULL,*HxB1=NULL;
kiss_fft_cpx *EyA1=NULL,*EyB1=NULL,*ExA2=NULL,*HyB2=NULL,*ExB2=NULL;
kiss_fft_cpx *HyA2=NULL,*HxA2=NULL,*HxB2=NULL,*EyA2=NULL,*EyB2=NULL;
kiss_fft_cpx *ExA3=NULL,*HyB3=NULL,*ExB3=NULL,*HyA3=NULL,*HxA3=NULL;
kiss_fft_cpx *HxB3=NULL,*EyA3=NULL,*EyB3=NULL,*ExA4=NULL,*HyB4=NULL;
kiss_fft_cpx *ExB4=NULL,*HyA4=NULL,*HxA4=NULL,*HxB4=NULL,*EyA4=NULL;
kiss_fft_cpx *EyB4=NULL,*Zxys1=NULL,*Zyxs1=NULL,*Zxys2=NULL,*Zyxs2=NULL;
kiss_fft_cpx *Zxys3=NULL,*Zyxs3=NULL,*Zxys4=NULL,*Zyxs4=NULL;
kiss_fft_cpx *Zxy=NULL,*Zyx=NULL;
kiss_fftr_cfg cfg;
sf_init (argc, argv);
in= sf_input("in");
Ey=sf_input("Ey");
Hx=sf_input("Hx");
Hy=sf_input("Hy");
out = sf_output("out");
if (!sf_getbool("opt",&opt)) opt=true;
/* if y, determine optimal size for efficiency */
if (!sf_getbool("comp",&comp)) comp=true;
/* component selection */
if (!sf_getbool("verb",&verb)) verb = false;
/* verbosity flag */
if (!sf_getbool("phase",&phase)) phase=false;
/* if y, calculate apparent resistivity, otherwise calculate phase */
if (!sf_histdouble(in,"n1",&n1)) sf_error("No n1= in input");
bb= sf_floatalloc(n1);
pp= sf_floatalloc(n1);
qq= sf_floatalloc(n1);
dd= sf_floatalloc(n1);
sf_floatread(bb,n1,in);
sf_floatread(pp,n1,Ey);
sf_floatread(qq,n1,Hx);
sf_floatread(dd,n1,Hy);
M=49;
outp =sf_floatalloc(M);
pi=3.14;
f=1;
b=-3;
for(k=0;k<M;k++) {
a=pow(10,b);
nw=(int)(128000./(a*1000));
nt = opt? 2*kiss_fft_next_fast_size((nw+1)/2): nw;
if (nt%2) nt++;
nw1 = nt/2+1;
dw = 128./nt;
m1=n1;
if(m1%nw) N=m1/nw+1;
else N=m1/nw;
if(verb) sf_warning("slice %d of %d, freq=%f, stack=%d;",k+1,M,a,N);
FDEx= (kiss_fft_cpx*)sf_complexalloc(nt);
FDEy= (kiss_fft_cpx*)sf_complexalloc(nt);
FDHx= (kiss_fft_cpx*)sf_complexalloc(nt);
FDHy= (kiss_fft_cpx*)sf_complexalloc(nt);
TDEx= sf_floatalloc(nt);
TDEy= sf_floatalloc(nt);
TDHx= sf_floatalloc(nt);
TDHy= sf_floatalloc(nt);
sf_putint(out,"n1",M);
sf_putfloat(out,"d1",0.1);
sf_putfloat(out,"o1",-3);
ExAs1=(kiss_fft_cpx*)sf_complexalloc(nt);
HyBs1=(kiss_fft_cpx*)sf_complexalloc(nt);
ExBs1=(kiss_fft_cpx*)sf_complexalloc(nt);
HyAs1=(kiss_fft_cpx*)sf_complexalloc(nt);
HxAs1=(kiss_fft_cpx*)sf_complexalloc(nt);
HxBs1=(kiss_fft_cpx*)sf_complexalloc(nt);
EyAs1=(kiss_fft_cpx*)sf_complexalloc(nt);
EyBs1=(kiss_fft_cpx*)sf_complexalloc(nt);
ExAs2=(kiss_fft_cpx*)sf_complexalloc(nt);
HyBs2=(kiss_fft_cpx*)sf_complexalloc(nt);
ExBs2=(kiss_fft_cpx*)sf_complexalloc(nt);
HyAs2=(kiss_fft_cpx*)sf_complexalloc(nt);
HxAs2=(kiss_fft_cpx*)sf_complexalloc(nt);
HxBs2=(kiss_fft_cpx*)sf_complexalloc(nt);
EyAs2=(kiss_fft_cpx*)sf_complexalloc(nt);
EyBs2=(kiss_fft_cpx*)sf_complexalloc(nt);
ExAs3=(kiss_fft_cpx*)sf_complexalloc(nt);
HyBs3=(kiss_fft_cpx*)sf_complexalloc(nt);
ExBs3=(kiss_fft_cpx*)sf_complexalloc(nt);
HyAs3=(kiss_fft_cpx*)sf_complexalloc(nt);
HxAs3=(kiss_fft_cpx*)sf_complexalloc(nt);
HxBs3=(kiss_fft_cpx*)sf_complexalloc(nt);
EyAs3=(kiss_fft_cpx*)sf_complexalloc(nt);
EyBs3=(kiss_fft_cpx*)sf_complexalloc(nt);
ExAs4=(kiss_fft_cpx*)sf_complexalloc(nt);
HyBs4=(kiss_fft_cpx*)sf_complexalloc(nt);
ExBs4=(kiss_fft_cpx*)sf_complexalloc(nt);
HyAs4=(kiss_fft_cpx*)sf_complexalloc(nt);
HxAs4=(kiss_fft_cpx*)sf_complexalloc(nt);
HxBs4=(kiss_fft_cpx*)sf_complexalloc(nt);
EyAs4=(kiss_fft_cpx*)sf_complexalloc(nt);
EyBs4=(kiss_fft_cpx*)sf_complexalloc(nt);
ExA1=(kiss_fft_cpx*)sf_complexalloc(nt);
HyB1=(kiss_fft_cpx*)sf_complexalloc(nt);
ExB1=(kiss_fft_cpx*)sf_complexalloc(nt);
HyA1=(kiss_fft_cpx*)sf_complexalloc(nt);
HxA1=(kiss_fft_cpx*)sf_complexalloc(nt);
HxB1=(kiss_fft_cpx*)sf_complexalloc(nt);
EyA1=(kiss_fft_cpx*)sf_complexalloc(nt);
EyB1=(kiss_fft_cpx*)sf_complexalloc(nt);
ExA2=(kiss_fft_cpx*)sf_complexalloc(nt);
HyB2=(kiss_fft_cpx*)sf_complexalloc(nt);
ExB2=(kiss_fft_cpx*)sf_complexalloc(nt);
HyA2=(kiss_fft_cpx*)sf_complexalloc(nt);
HxA2=(kiss_fft_cpx*)sf_complexalloc(nt);
HxB2=(kiss_fft_cpx*)sf_complexalloc(nt);
EyA2=(kiss_fft_cpx*)sf_complexalloc(nt);
EyB2=(kiss_fft_cpx*)sf_complexalloc(nt);
ExA3=(kiss_fft_cpx*)sf_complexalloc(nt);
HyB3=(kiss_fft_cpx*)sf_complexalloc(nt);
ExB3=(kiss_fft_cpx*)sf_complexalloc(nt);
HyA3=(kiss_fft_cpx*)sf_complexalloc(nt);
HxA3=(kiss_fft_cpx*)sf_complexalloc(nt);
HxB3=(kiss_fft_cpx*)sf_complexalloc(nt);
EyA3=(kiss_fft_cpx*)sf_complexalloc(nt);
EyB3=(kiss_fft_cpx*)sf_complexalloc(nt);
ExA4=(kiss_fft_cpx*)sf_complexalloc(nt);
HyB4=(kiss_fft_cpx*)sf_complexalloc(nt);
ExB4=(kiss_fft_cpx*)sf_complexalloc(nt);
HyA4=(kiss_fft_cpx*)sf_complexalloc(nt);
HxA4=(kiss_fft_cpx*)sf_complexalloc(nt);
HxB4=(kiss_fft_cpx*)sf_complexalloc(nt);
EyA4=(kiss_fft_cpx*)sf_complexalloc(nt);
EyB4=(kiss_fft_cpx*)sf_complexalloc(nt);
Zxys1=(kiss_fft_cpx*)sf_complexalloc(nt);
Zyxs1=(kiss_fft_cpx*)sf_complexalloc(nt);
Zxys2=(kiss_fft_cpx*)sf_complexalloc(nt);
Zyxs2=(kiss_fft_cpx*)sf_complexalloc(nt);
Zxys3=(kiss_fft_cpx*)sf_complexalloc(nt);
Zyxs3=(kiss_fft_cpx*)sf_complexalloc(nt);
Zxys4=(kiss_fft_cpx*)sf_complexalloc(nt);
Zyxs4=(kiss_fft_cpx*)sf_complexalloc(nt);
Zxy=(kiss_fft_cpx*)sf_complexalloc(nt);
Zyx=(kiss_fft_cpx*)sf_complexalloc(nt);
ExHyres=sf_floatalloc(nt);
EyHxres=sf_floatalloc(nt);
ExHypha=sf_floatalloc(nt);
EyHxpha=sf_floatalloc(nt);
cfg = kiss_fftr_alloc(nt,0,NULL,NULL);
for(j=0;j<N;j++) {
for(i=0;i<nt;i++){
if((i<nw)&&((j*nw+i)<n1)) {
TDEx[i]=bb[j*nw+i]*0.5*(1-cos(2*pi*i/nt));
}
else {
TDEx[i]=0.;
}
}
kiss_fftr(cfg,TDEx,FDEx);
for(i=0;i<nt;i++){
if((i<nw)&&((j*nw+i)<n1)) {
TDEy[i]=pp[j*nw+i]*0.5*(1-cos(2*pi*i/nt));
}
else{
TDEy[i]=0.;
}
}
kiss_fftr(cfg,TDEy,FDEy);
for(i=0;i<nt;i++){
if((i<nw)&&((j*nw+i)<n1)) {
TDHx[i]=qq[j*nw+i]*0.5*(1-cos(2*pi*i/nt));
}
else{TDHx[i]=0.;}
}
kiss_fftr(cfg,TDHx,FDHx);
for(i=0;i<nt;i++){
if((i<nw)&&((j*nw+i)<n1)) {
TDHy[i]=dd[j*nw+i]*0.5*(1-cos(2*pi*i/nt));
}
else{
TDHy[i]=0.;
}
}
kiss_fftr(cfg,TDHy,FDHy);
A=FDEx;B=FDEy;
ExAs1[f]=sf_cadd(ExAs1[f],sf_cmul(FDEx[f],sf_conjf(A[f])));
HyBs1[f]=sf_cadd(HyBs1[f],sf_cmul(FDHy[f],sf_conjf(B[f])));
ExBs1[f]=sf_cadd(ExBs1[f],sf_cmul(FDEx[f],sf_conjf(B[f])));
HyAs1[f]=sf_cadd(HyAs1[f],sf_cmul(FDHy[f],sf_conjf(A[f])));
HxAs1[f]=sf_cadd(HxAs1[f],sf_cmul(FDHx[f],sf_conjf(A[f])));
HxBs1[f]=sf_cadd(HxBs1[f],sf_cmul(FDHx[f],sf_conjf(B[f])));
EyAs1[f]=sf_cadd(EyAs1[f],sf_cmul(FDEy[f],sf_conjf(A[f])));
EyBs1[f]=sf_cadd(EyBs1[f],sf_cmul(FDEy[f],sf_conjf(B[f])));
A=FDEx;B=FDHx;
ExAs2[f]= sf_cadd(ExAs2[f],sf_cmul(FDEx[f],sf_conjf(A[f])));
HyBs2[f]= sf_cadd(HyBs2[f],sf_cmul(FDHy[f],sf_conjf(B[f])));
ExBs2[f]= sf_cadd(ExBs2[f],sf_cmul(FDEx[f],sf_conjf(B[f])));
HyAs2[f]= sf_cadd(HyAs2[f],sf_cmul(FDHy[f],sf_conjf(A[f])));
HxAs2[f]= sf_cadd(HxAs2[f],sf_cmul(FDHx[f],sf_conjf(A[f])));
HxBs2[f]= sf_cadd(HxBs2[f],sf_cmul(FDHx[f],sf_conjf(B[f])));
EyAs2[f]= sf_cadd(EyAs2[f],sf_cmul(FDEy[f],sf_conjf(A[f])));
EyBs2[f]= sf_cadd(EyBs2[f],sf_cmul(FDEy[f],sf_conjf(B[f])));
A=FDEy;B=FDHy;
ExAs3[f]= sf_cadd(ExAs3[f],sf_cmul(FDEx[f],sf_conjf(A[f])));
HyBs3[f]= sf_cadd(HyBs3[f],sf_cmul(FDHy[f],sf_conjf(B[f])));
ExBs3[f]= sf_cadd(ExBs3[f],sf_cmul(FDEx[f],sf_conjf(B[f])));
HyAs3[f]= sf_cadd(HyAs3[f],sf_cmul(FDHy[f],sf_conjf(A[f])));
HxAs3[f]= sf_cadd(HxAs3[f],sf_cmul(FDHx[f],sf_conjf(A[f])));
HxBs3[f]= sf_cadd(HxBs3[f],sf_cmul(FDHx[f],sf_conjf(B[f])));
EyAs3[f]= sf_cadd(EyAs3[f],sf_cmul(FDEy[f],sf_conjf(A[f])));
EyBs3[f]= sf_cadd(EyBs3[f],sf_cmul(FDEy[f],sf_conjf(B[f])));
A=FDHx;B=FDHy;
ExAs4[f]= sf_cadd(ExAs4[f],sf_cmul(FDEx[f],sf_conjf(A[f])));
HyBs4[f]= sf_cadd(HyBs4[f],sf_cmul(FDHy[f],sf_conjf(B[f])));
ExBs4[f]= sf_cadd(ExBs4[f],sf_cmul(FDEx[f],sf_conjf(B[f])));
HyAs4[f]= sf_cadd(HyAs4[f],sf_cmul(FDHy[f],sf_conjf(A[f])));
HxAs4[f]= sf_cadd(HxAs4[f],sf_cmul(FDHx[f],sf_conjf(A[f])));
HxBs4[f]= sf_cadd(HxBs4[f],sf_cmul(FDHx[f],sf_conjf(B[f])));
EyAs4[f]= sf_cadd(EyAs4[f],sf_cmul(FDEy[f],sf_conjf(A[f])));
EyBs4[f]= sf_cadd(EyBs4[f],sf_cmul(FDEy[f],sf_conjf(B[f])));
}
ExA1[f]=sf_crmul(ExAs1[f],1./N);
HyB1[f]=sf_crmul(HyBs1[f],1./N);
ExB1[f]=sf_crmul(ExBs1[f],1./N);
HyA1[f]=sf_crmul(HyAs1[f],1./N);
HxA1[f]=sf_crmul(HxAs1[f],1./N);
HxB1[f]=sf_crmul(HxBs1[f],1./N);
EyA1[f]=sf_crmul(EyAs1[f],1./N);
EyB1[f]=sf_crmul(EyBs1[f],1./N);
ExA2[f]=sf_crmul(ExAs2[f],1./N);
HyB2[f]=sf_crmul(HyBs2[f],1./N);
ExB2[f]=sf_crmul(ExBs2[f],1./N);
HyA2[f]=sf_crmul(HyAs2[f],1./N);
HxA2[f]=sf_crmul(HxAs2[f],1./N);
HxB2[f]=sf_crmul(HxBs2[f],1./N);
EyA2[f]=sf_crmul(EyAs2[f],1./N);
EyB2[f]=sf_crmul(EyBs2[f],1./N);
ExA3[f]=sf_crmul(ExAs3[f],1./N);
HyB3[f]=sf_crmul(HyBs3[f],1./N);
ExB3[f]=sf_crmul(ExBs3[f],1./N);
HyA3[f]=sf_crmul(HyAs3[f],1./N);
HxA3[f]=sf_crmul(HxAs3[f],1./N);
HxB3[f]=sf_crmul(HxBs3[f],1./N);
EyA3[f]=sf_crmul(EyAs3[f],1./N);
EyB3[f]=sf_crmul(EyBs3[f],1./N);
ExA4[f]=sf_crmul(ExAs4[f],1./N);
HyB4[f]=sf_crmul(HyBs4[f],1./N);
ExB4[f]=sf_crmul(ExBs4[f],1./N);
HyA4[f]=sf_crmul(HyAs4[f],1./N);
HxA4[f]=sf_crmul(HxAs4[f],1./N);
HxB4[f]=sf_crmul(HxBs4[f],1./N);
EyA4[f]=sf_crmul(EyAs4[f],1./N);
EyB4[f]=sf_crmul(EyBs4[f],1./N);
Zxys1[f]=sf_cdiv((sf_csub(sf_cmul(ExA1[f],HxB1[f]),
sf_cmul(ExB1[f],HxA1[f]))),
(sf_csub(sf_cmul(HyA1[f],HxB1[f]),
sf_cmul(HyB1[f],HxA1[f]))));
Zyxs1[f]=sf_cdiv((sf_csub(sf_cmul(EyA1[f],HyB1[f]),
sf_cmul(EyB1[f],HyA1[f]))),
(sf_csub(sf_cmul(HxA1[f],HyB1[f]),
sf_cmul(HxB1[f],HyA1[f]))));
Zxys2[f]=sf_cdiv((sf_csub(sf_cmul(ExA2[f],HxB2[f]),
sf_cmul(ExB2[f],HxA2[f]))),
(sf_csub(sf_cmul(HyA2[f],HxB2[f]),
sf_cmul(HyB2[f],HxA2[f]))));
Zyxs2[f]=sf_cdiv((sf_csub(sf_cmul(EyA2[f],HyB2[f]),
sf_cmul(EyB2[f],HyA2[f]))),
(sf_csub(sf_cmul(HxA2[f],HyB2[f]),
sf_cmul(HxB2[f],HyA2[f]))));
Zxys3[f]=sf_cdiv((sf_csub(sf_cmul(ExA3[f],HxB3[f]),
sf_cmul(ExB3[f],HxA3[f]))),
(sf_csub(sf_cmul(HyA3[f],HxB3[f]),
sf_cmul(HyB3[f],HxA3[f]))));
Zyxs3[f]=sf_cdiv((sf_csub(sf_cmul(EyA3[f],HyB3[f]),
sf_cmul(EyB3[f],HyA3[f]))),
(sf_csub(sf_cmul(HxA3[f],HyB3[f]),
sf_cmul(HxB3[f],HyA3[f]))));
Zxys4[f]=sf_cdiv((sf_csub(sf_cmul(ExA4[f],HxB4[f]),
sf_cmul(ExB4[f],HxA4[f]))),
(sf_csub(sf_cmul(HyA4[f],HxB4[f]),
sf_cmul(HyB4[f],HxA4[f]))));
Zyxs4[f]=sf_cdiv((sf_csub(sf_cmul(EyA4[f],HyB4[f]),
sf_cmul(EyB4[f],HyA4[f]))),
(sf_csub(sf_cmul(HxA4[f],HyB4[f]),
sf_cmul(HxB4[f],HyA4[f]))));
Zxy[f]=sf_crmul(sf_cadd(sf_cadd(Zxys1[f],Zxys2[f]),
sf_cadd(Zxys3[f],Zxys4[f])),0.25);
Zyx[f]=sf_crmul(sf_cadd(sf_cadd(Zyxs1[f],Zyxs2[f]),
sf_cadd(Zyxs3[f],Zyxs4[f])),0.25);
ExHyres[f]=0.2*sf_cabsf(Zxy[f])*sf_cabsf(Zxy[f])/a;
EyHxres[f]=0.2*sf_cabsf(Zyx[f])*sf_cabsf(Zyx[f])/a;
ExHypha[f]=sf_cargf(Zxy[f]);
EyHxpha[f]=sf_cargf(Zyx[f]);
if(phase) {
if(comp) {
outp[k]= ExHypha[f];
} else {
outp[k]= EyHxpha[f];
}
} else {
if(comp) {
outp[k]= ExHyres[f];
} else {
outp[k]= EyHxres[f];
}
}
b=b+0.1;
}
sf_floatwrite(outp,M,out);
exit(0);
}
void UI_FreqSpectrumWindow::update_curve()
{
int i, j, k,
dftblocksize,
dftblocks,
samplesleft,
fft_outputbufsize;
long long s, s2;
char str[512];
double dig_value=0.0,
f_tmp=0.0;
union {
unsigned int one;
signed int one_signed;
unsigned short two[2];
signed short two_signed[2];
unsigned char four[4];
} var;
if(signalcomp == NULL)
{
return;
}
if(busy)
{
return;
}
viewbuf = mainwindow->viewbuf;
if(viewbuf == NULL)
{
return;
}
busy = 1;
curve1->setUpdatesEnabled(false);
samples = signalcomp->samples_on_screen;
if(signalcomp->samples_on_screen > signalcomp->sample_stop)
{
samples = signalcomp->sample_stop;
}
samples -= signalcomp->sample_start;
if((samples < 10) || (viewbuf == NULL))
{
curve1->setUpdatesEnabled(true);
busy = 0;
curve1->clear();
return;
}
if(buf1 != NULL)
{
free(buf1);
}
buf1 = (double *)malloc(sizeof(double) * signalcomp->samples_on_screen);
if(buf1 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.\n"
"Decrease the timescale and try again.");
messagewindow.exec();
return;
}
samples = 0;
for(s=signalcomp->sample_start; s<signalcomp->samples_on_screen; s++)
{
if(s>signalcomp->sample_stop) break;
dig_value = 0.0;
s2 = s + signalcomp->sample_timeoffset - signalcomp->sample_start;
for(j=0; j<signalcomp->num_of_signals; j++)
{
if(signalcomp->edfhdr->bdf)
{
var.two[0] = *((unsigned short *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset
+ ((s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record) * 3)));
var.four[2] = *((unsigned char *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset
+ ((s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record) * 3)
+ 2));
if(var.four[2]&0x80)
{
var.four[3] = 0xff;
}
else
{
var.four[3] = 0x00;
}
f_tmp = var.one_signed;
}
if(signalcomp->edfhdr->edf)
{
f_tmp = *(((short *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset))
+ (s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record));
}
f_tmp += signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].offset;
f_tmp *= signalcomp->factor[j];
dig_value += f_tmp;
}
if(signalcomp->spike_filter)
{
if(s==signalcomp->sample_start)
{
spike_filter_restore_buf(signalcomp->spike_filter);
}
dig_value = run_spike_filter(dig_value, signalcomp->spike_filter);
}
for(k=0; k<signalcomp->filter_cnt; k++)
{
dig_value = first_order_filter(dig_value, signalcomp->filter[k]);
}
for(k=0; k<signalcomp->ravg_filter_cnt; k++)
{
if(s==signalcomp->sample_start)
{
ravg_filter_restore_buf(signalcomp->ravg_filter[k]);
}
dig_value = run_ravg_filter(dig_value, signalcomp->ravg_filter[k]);
}
for(k=0; k<signalcomp->fidfilter_cnt; k++)
{
if(s==signalcomp->sample_start)
{
memcpy(signalcomp->fidbuf[k], signalcomp->fidbuf2[k], fid_run_bufsize(signalcomp->fid_run[k]));
}
dig_value = signalcomp->fidfuncp[k](signalcomp->fidbuf[k], dig_value);
}
if(signalcomp->ecg_filter != NULL)
{
if(s==signalcomp->sample_start)
{
ecg_filter_restore_buf(signalcomp->ecg_filter);
}
dig_value = run_ecg_filter(dig_value, signalcomp->ecg_filter);
}
if(s>=signalcomp->sample_start)
{
buf1[samples++] = dig_value * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue;
}
}
samplefreq = (double)signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record / ((double)signalcomp->edfhdr->long_data_record_duration / TIME_DIMENSION);
dftblocksize = mainwindow->maxdftblocksize;
if(dftblocksize & 1)
{
dftblocksize--;
}
dftblocks = 1;
if(dftblocksize < samples)
{
dftblocks = samples / dftblocksize;
}
else
{
dftblocksize = samples;
}
if(dftblocksize & 1)
{
dftblocksize--;
}
samplesleft = samples % dftblocksize;
if(samplesleft & 1)
{
samplesleft--;
}
freqstep = samplefreq / (double)dftblocksize;
fft_outputbufsize = dftblocksize / 2;
steps = fft_outputbufsize;
if(buf2 != NULL)
{
free(buf2);
}
buf2 = (double *)calloc(1, sizeof(double) * fft_outputbufsize);
if(buf2 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
buf1 = NULL;
return;
}
if(buf3 != NULL)
{
free(buf3);
}
buf3 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf3 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
buf1 = NULL;
buf2 = NULL;
return;
}
if(buf4 != NULL)
{
free(buf4);
}
buf4 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf4 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
return;
}
if(buf5 != NULL)
{
free(buf5);
}
buf5 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf5 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
free(buf4);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
buf4 = NULL;
return;
}
maxvalue = 0.000001;
maxvalue_sqrt = 0.000001;
maxvalue_vlog = 0.000001;
maxvalue_sqrt_vlog = 0.000001;
minvalue_vlog = 0.0;
minvalue_sqrt_vlog = 0.0;
#ifdef CHECK_POWERSPECTRUM
printf("samples is %i dftblocksize is %i dftblocks is %i samplesleft is %i fft_outputbufsize is %i steps is %i\n", samples, dftblocksize, dftblocks, samplesleft, fft_outputbufsize, steps);
double power1=0.0, power2=0.0;
for(i=0; i<samples; i++)
{
power1 += (buf1[i] * buf1[i]);
}
#endif
kiss_fftr_cfg cfg;
kiss_fft_cpx *kiss_fftbuf;
kiss_fftbuf = (kiss_fft_cpx *)malloc((fft_outputbufsize + 1) * sizeof(kiss_fft_cpx));
if(kiss_fftbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
free(buf4);
free(buf5);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
buf4 = NULL;
buf5 = NULL;
return;
}
cfg = kiss_fftr_alloc(dftblocksize, 0, NULL, NULL);
for(j=0; j<dftblocks; j++)
{
kiss_fftr(cfg, buf1 + (j * dftblocksize), kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] += (((kiss_fftbuf[i].r * kiss_fftbuf[i].r) + (kiss_fftbuf[i].i * kiss_fftbuf[i].i)) / fft_outputbufsize);
}
}
if(samplesleft)
{
kiss_fftr(cfg, buf1 + (((j-1) * dftblocksize) + samplesleft), kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] += (((kiss_fftbuf[i].r * kiss_fftbuf[i].r) + (kiss_fftbuf[i].i * kiss_fftbuf[i].i)) / fft_outputbufsize);
buf2[i] /= (dftblocks + 1);
}
}
else
{
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] /= dftblocks;
}
}
if(signalcomp->ecg_filter == NULL)
{
buf2[0] /= 2.0; // DC!
}
else
{
buf2[0] = 0.0; // Remove DC because heart rate is always a positive value
}
free(cfg);
free(kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] /= samplefreq;
#ifdef CHECK_POWERSPECTRUM
power2 += buf2[i];
#endif
buf3[i] = sqrt(buf2[i] * freqstep);
if(buf2[i] <= SPECT_LOG_MINIMUM)
{
buf4[i] = log10(SPECT_LOG_MINIMUM);
}
else
{
buf4[i] = log10(buf2[i]);
}
if(buf3[i] <= SPECT_LOG_MINIMUM)
{
buf5[i] = log10(SPECT_LOG_MINIMUM);
}
else
{
buf5[i] = log10(buf3[i]);
}
if(i) // don't use the dc-bin for the autogain of the screen
{
if(buf2[i] > maxvalue)
{
maxvalue = buf2[i];
}
if(buf3[i] > maxvalue_sqrt)
{
maxvalue_sqrt = buf3[i];
}
if(buf4[i] > maxvalue_vlog)
{
maxvalue_vlog = buf4[i];
}
if(buf5[i] > maxvalue_sqrt_vlog)
{
maxvalue_sqrt_vlog = buf5[i];
}
if((buf4[i] < minvalue_vlog) && (buf4[i] >= SPECT_LOG_MINIMUM_LOG))
{
minvalue_vlog = buf4[i];
}
if((buf5[i] < minvalue_sqrt_vlog) && (buf5[i] >= SPECT_LOG_MINIMUM_LOG))
{
minvalue_sqrt_vlog = buf5[i];
}
}
}
if(minvalue_vlog < SPECT_LOG_MINIMUM_LOG)
minvalue_vlog = SPECT_LOG_MINIMUM_LOG;
if(minvalue_sqrt_vlog < SPECT_LOG_MINIMUM_LOG)
minvalue_sqrt_vlog = SPECT_LOG_MINIMUM_LOG;
if(samplesleft)
{
dftblocks++;
}
#ifdef CHECK_POWERSPECTRUM
power1 /= samples;
power2 *= freqstep;
printf("\n power1 is %f\n power2 is %f\n\n", power1, power2);
#endif
if(buf1 != NULL)
{
free(buf1);
buf1 = NULL;
}
sprintf(str, "FFT resolution: %f Hz %i blocks of %i samples", freqstep, dftblocks, dftblocksize);
remove_trailing_zeros(str);
curve1->setUpperLabel1(str);
curve1->setUpperLabel2(signallabel);
sliderMoved(0);
curve1->setUpdatesEnabled(true);
busy = 0;
}
void freqfilt4pi_lop (bool adj, bool add, int nx, int ny, float* x, float* y)
/*< linear filtering operator >*/
{
int iw, ik;
kiss_fft_cpx temp;
int verb; // just outputting values to check when I get zeroes
sf_adjnull(adj,add,nx,ny,x,y);
for (ik=0; ik < m2; ik++) {
for (iw=0; iw < m1; iw++) {
trace[iw] = adj? y[ik*m1+iw]: x[ik*m1+iw];
/*if(trace[iw] == 0.0){
sf_warning("trace[%d] = %f",iw,trace[iw]);
}*/
}
for (iw=m1; iw < nfft; iw++) {
trace[iw]=0.;
}
kiss_fftr (tfor,trace,ctrace);
for (iw=0; iw < nw; iw++) {
fft[ik][iw] = ik%2? sf_cneg(ctrace[iw]): ctrace[iw];
}
}
for (iw=0; iw < nw; iw++) {
kiss_fft_stride(xfor,fft[0]+iw,ctrace2,nw);
for (ik=0; ik < m2; ik++) {
//double creal( double complex z );
//transform to kiss fft cpx
//creal are double complex functions - what should we
//do when double complex is not supported???
if (adj){
temp.r = creal(shape[iw][ik]);
temp.i = (-1.0)*cimag(shape[iw][ik]);
} else {
temp.r = creal(shape[iw][ik]);
temp.i = cimag(shape[iw][ik]);
}
ctrace2[ik] = sf_cmul(ctrace2[ik],temp);
}
kiss_fft(xinv,ctrace2,ctrace2);
for (ik=0; ik < m2; ik++) {
fft[ik][iw] = ik%2? sf_cneg(ctrace2[ik]): ctrace2[ik];
}
}
for (ik=0; ik < m2; ik++) {
kiss_fftri (tinv,fft[ik],trace);
for (iw=0; iw < m1; iw++) {
if (adj) {
x[ik*m1+iw] += trace[iw];
} else {
y[ik*m1+iw] += trace[iw];
}
}
}
}
int main(int argc, char ** argv)
{
int k;
int nfft[32];
int ndims = 1;
int isinverse = 0;
int numffts = 1000, i;
kiss_fft_cpx * buf;
kiss_fft_cpx * bufout;
int real = 0;
nfft[0] = 1024;// default
while (1) {
int c = getopt(argc, argv, "n:ix:r");
if (c == -1)
break;
switch (c) {
case 'r':
real = 1;
break;
case 'n':
ndims = getdims(nfft, optarg);
if (nfft[0] != kiss_fft_next_fast_size(nfft[0])) {
int ng = kiss_fft_next_fast_size(nfft[0]);
fprintf(stderr, "warning: %d might be a better choice for speed than %d\n", ng, nfft[0]);
}
break;
case 'x':
numffts = atoi(optarg);
break;
case 'i':
isinverse = 1;
break;
}
}
int nbytes = sizeof(kiss_fft_cpx);
for (k = 0; k < ndims; ++k)
nbytes *= nfft[k];
#ifdef USE_SIMD
numffts /= 4;
fprintf(stderr, "since SIMD implementation does 4 ffts at a time, numffts is being reduced to %d\n", numffts);
#endif
buf = (kiss_fft_cpx*)KISS_FFT_MALLOC(nbytes);
bufout = (kiss_fft_cpx*)KISS_FFT_MALLOC(nbytes);
memset(buf, 0, nbytes);
pstats_init();
if (ndims == 1) {
if (real) {
kiss_fftr_cfg st = kiss_fftr_alloc(nfft[0] , isinverse , 0, 0);
if (isinverse)
for (i = 0; i < numffts; ++i)
kiss_fftri(st , (kiss_fft_cpx*)buf, (kiss_fft_scalar*)bufout);
else
for (i = 0; i < numffts; ++i)
kiss_fftr(st , (kiss_fft_scalar*)buf, (kiss_fft_cpx*)bufout);
free(st);
} else {
kiss_fft_cfg st = kiss_fft_alloc(nfft[0] , isinverse , 0, 0);
for (i = 0; i < numffts; ++i)
kiss_fft(st , buf, bufout);
free(st);
}
} else {
if (real) {
kiss_fftndr_cfg st = kiss_fftndr_alloc(nfft, ndims , isinverse , 0, 0);
if (isinverse)
for (i = 0; i < numffts; ++i)
kiss_fftndri(st , (kiss_fft_cpx*)buf, (kiss_fft_scalar*)bufout);
else
for (i = 0; i < numffts; ++i)
kiss_fftndr(st , (kiss_fft_scalar*)buf, (kiss_fft_cpx*)bufout);
free(st);
} else {
kiss_fftnd_cfg st = kiss_fftnd_alloc(nfft, ndims, isinverse , 0, 0);
for (i = 0; i < numffts; ++i)
kiss_fftnd(st , buf, bufout);
free(st);
}
}
free(buf); free(bufout);
fprintf(stderr, "KISS\tnfft=");
for (k = 0; k < ndims; ++k)
fprintf(stderr, "%d,", nfft[k]);
fprintf(stderr, "\tnumffts=%d\n" , numffts);
pstats_report();
kiss_fft_cleanup();
return 0;
}
void main(void){
int sum,average,level,level_last,count;
char interval =0;
int max_timeout ;
float ratio;
int r,g,b;
int lights;
int peak[5];
int peak_last[5];
int avg[5];
int max[5];
int filt_out[5];
int color[5];
int i,j;
int bytes_read;
int temp_val;
bytes_read = BUFFER_SIZE;
setvbuf(stdout, NULL, _IONBF, 0);
printf("Hello World!\n");
SERIAL = fopen("/dev/ttyO1","w");
setvbuf(SERIAL, NULL, _IONBF, 0);
kiss_fftr_state = kiss_fftr_alloc(BUFFER_SIZE,0,0,0);
sendColor(4,255,0,0,0);
sendColor(9,0,255,0,0);
color[0] = max[0] = avg[0] = 0;
color[1] = max[1] =avg[1] = 0;
color[2] = max[2] =avg[2] = 0;
color[3] = max[3] =avg[3] = 0;
color[4] = max[4] =avg[4] = 0;
interval =0;
max_timeout = 50;
while(bytes_read==BUFFER_SIZE){
// bytes_read = fread(&audio_data,sizeof(short),512,stdin);
bytes_read = fread(&audio_data,sizeof(short),BUFFER_SIZE,stdin);
for(i = 0; i< BUFFER_SIZE;i++){
rin[i] = (audio_data[i]*hamming_window512[i])/16384;
}
// for(i = 0;i<bytes_read; i++){
// //sum +=audio_data[i];
// filt_out[0] = calculate_FIR(&filter0,audio_data[i]);
// filt_out[1] = calculate_FIR(&filter1,audio_data[i]);
// filt_out[2] = calculate_FIR(&filter2,audio_data[i]);
// filt_out[3] = calculate_FIR(&filter3,audio_data[i]);
// filt_out[4] = calculate_FIR(&filter4,audio_data[i]);
// for(j=0;j<5;j++){
// filt_out[j] = abs(filt_out[j]);
// peak[j] = (filt_out[j] > peak[j])? filt_out[j]: peak[j];
// }
//
// }
if(interval == 0){
kiss_fftr( kiss_fftr_state, rin, sout );
for(lights = 0;lights<NUM_LIGHTS; lights++){
sum = 0;
count = 0;
for(i = band_min[lights];i<=band_max[lights];i++){
sum += sqrt(sout[i].r*sout[i].r + sout[i].i*sout[i].i);
count ++;
}
peak[lights] = sum/ count ;
avg[lights] = calculate_average(&(averages[lights]),peak[lights]);
}
for(j=0;j<NUM_LIGHTS;j++){
if(peak[j]>max[j]){
max[j] = peak[j];
}
ratio =(avg[j])? ((float)peak[j])/avg[j]:0;
level =(int)(threshold[j]*ratio);
if(level > 12) level = 12;
ratio =(avg[j])? ((float)peak_last[j])/avg[j]:0;
level_last =(int)(threshold[j]*ratio);
if(level_last > 12) level_last = 12;
if(level <1 && level_last >1){
color[j] ++;
color[j] %=12;
}
peak_last[j] = peak[j];
level = (max[j])? (12*peak[j])/max[j]:0;
printf("%d:%8d ",level,avg[j]);
r = color_array[12-level][color_order[color[j]]][0];
g = color_array[12-level][color_order[color[j]]][1];
b = color_array[12-level][color_order[color[j]]][2];
// if(level>1){
sendColor(address_table[j],r,g,b,0);
// }else{
// sendColor(address_table[j],0,0,0,0);
// }
//sendColor(9,0,255,0,0);
if(max_timeout == 0){
printf("Avg[%d]=%d ",j,avg[j]);
max[j]= (max[j]/4 > avg[j])? max[j]-(max[j]-avg[j])/2: max[j];
}
}
printf ("\n");
if(max_timeout == 0){
max_timeout = 300;
}
max_timeout --;
}
interval ++;
interval %=2;
//printf("%8d:%8d:%8d:%8d:%8d\n", peak[0],peak[1],peak[2],peak[3],peak[4]);
//printf("%d,%d,%d,%d,%d\n", peak[0],peak[1],peak[2],peak[3],peak[4]);
}
free(kiss_fftr_state);
}
