summaryrefslogtreecommitdiff
path: root/sndobj
diff options
context:
space:
mode:
Diffstat (limited to 'sndobj')
-rw-r--r--sndobj/AdSyn.cpp10
-rw-r--r--sndobj/AdSyn.h4
-rw-r--r--sndobj/FFT.cpp40
-rw-r--r--sndobj/FFT.h20
-rw-r--r--sndobj/HammingTable.cpp12
-rw-r--r--sndobj/HammingTable.h6
-rw-r--r--sndobj/HarmTable.cpp18
-rw-r--r--sndobj/HarmTable.h6
-rw-r--r--sndobj/IFAdd.cpp12
-rw-r--r--sndobj/IFAdd.h4
-rw-r--r--sndobj/IFFT.cpp40
-rw-r--r--sndobj/IFFT.h12
-rw-r--r--sndobj/IFGram.cpp40
-rw-r--r--sndobj/IFGram.h16
-rw-r--r--sndobj/PVA.cpp24
-rw-r--r--sndobj/PVA.h14
-rw-r--r--sndobj/PVS.cpp18
-rw-r--r--sndobj/PVS.h10
-rw-r--r--sndobj/ReSyn.cpp16
-rw-r--r--sndobj/ReSyn.h16
-rw-r--r--sndobj/SinAnal.cpp178
-rw-r--r--sndobj/SinAnal.h40
-rw-r--r--sndobj/SinSyn.cpp28
-rw-r--r--sndobj/SinSyn.h28
-rw-r--r--sndobj/SndIO.cpp4
-rw-r--r--sndobj/SndIO.h12
-rw-r--r--sndobj/SndObj.cpp6
-rw-r--r--sndobj/SndObj.h44
-rw-r--r--sndobj/Table.h6
-rw-r--r--sndobj/rfftw/fftw.h2
-rw-r--r--sndobj/sndobj.i16
31 files changed, 351 insertions, 351 deletions
diff --git a/sndobj/AdSyn.cpp b/sndobj/AdSyn.cpp
index 2b534d7..28fa209 100644
--- a/sndobj/AdSyn.cpp
+++ b/sndobj/AdSyn.cpp
@@ -26,7 +26,7 @@ AdSyn::AdSyn(){
}
AdSyn::AdSyn(SinAnal* input, int maxtracks, Table* table,
- float pitch, float scale, int vecsize, float sr)
+ double pitch, double scale, int vecsize, double sr)
:ReSyn(input, maxtracks, table, pitch, scale, 1.f, vecsize, sr){
}
@@ -38,15 +38,15 @@ AdSyn::DoProcess() {
if(m_input){
- float ampnext,amp,freq,freqnext,phase;
+ double ampnext,amp,freq,freqnext,phase;
int i3, i, j, ID, track;
int notcontin = 0;
bool contin = false;
int oldtracks = m_tracks;
- float* tab = m_ptable->GetTable();
+ double* tab = m_ptable->GetTable();
if((m_tracks = ((SinAnal *)m_input)->GetTracks()) >
m_maxtracks) m_tracks = m_maxtracks;
- memset(m_output, 0, sizeof(float)*m_vecsize);
+ memset(m_output, 0, sizeof(double)*m_vecsize);
// for each track
i = j = 0;
@@ -89,7 +89,7 @@ AdSyn::DoProcess() {
}
// interpolation & track synthesis loop
- float a,f,frac,incra,incrph;
+ double a,f,frac,incra,incrph;
int ndx;
a = amp;
f = freq;
diff --git a/sndobj/AdSyn.h b/sndobj/AdSyn.h
index 61750e4..1d62d01 100644
--- a/sndobj/AdSyn.h
+++ b/sndobj/AdSyn.h
@@ -31,8 +31,8 @@ class AdSyn : public ReSyn {
AdSyn();
AdSyn(SinAnal* input, int maxtracks, Table* table,
- float pitch = 1.f, float scale=1.f,
- int vecsize=DEF_VECSIZE, float sr=DEF_SR);
+ double pitch = 1.f, double scale=1.f,
+ int vecsize=DEF_VECSIZE, double sr=DEF_SR);
~AdSyn();
short DoProcess();
};
diff --git a/sndobj/FFT.cpp b/sndobj/FFT.cpp
index 8aff622..cee737d 100644
--- a/sndobj/FFT.cpp
+++ b/sndobj/FFT.cpp
@@ -45,16 +45,16 @@ FFT::FFT(){
m_frames = m_fftsize/m_hopsize;
- m_sigframe = new float*[m_frames];
- m_ffttmp = new float[m_fftsize];
+ m_sigframe = new double*[m_frames];
+ m_ffttmp = new double[m_fftsize];
m_counter = new int[m_frames];
m_halfsize = m_fftsize/2;
m_fund = m_sr/m_fftsize;
- memset(m_ffttmp, 0, m_fftsize*sizeof(float));
+ memset(m_ffttmp, 0, m_fftsize*sizeof(double));
int i;
for(i = 0; i < m_frames; i++){
- m_sigframe[i] = new float[m_fftsize];
- memset(m_sigframe[i], 0, m_fftsize*sizeof(float));
+ m_sigframe[i] = new double[m_fftsize];
+ memset(m_sigframe[i], 0, m_fftsize*sizeof(double));
m_counter[i] = i*m_hopsize;
}
@@ -70,8 +70,8 @@ FFT::FFT(){
}
-FFT::FFT(Table* window, SndObj* input, float scale,
- int fftsize, int hopsize, float sr):
+FFT::FFT(Table* window, SndObj* input, double scale,
+ int fftsize, int hopsize, double sr):
SndObj(input, fftsize, sr){
m_table = window;
@@ -80,16 +80,16 @@ FFT::FFT(Table* window, SndObj* input, float scale,
m_fftsize = fftsize;
m_frames = m_fftsize/m_hopsize;
- m_sigframe = new float*[m_frames];
- m_ffttmp = new float[m_fftsize];
+ m_sigframe = new double*[m_frames];
+ m_ffttmp = new double[m_fftsize];
m_counter = new int[m_frames];
m_halfsize = m_fftsize/2;
m_fund = m_sr/m_fftsize;
- memset(m_ffttmp, 0, m_fftsize*sizeof(float));
+ memset(m_ffttmp, 0, m_fftsize*sizeof(double));
int i;
for(i = 0; i < m_frames; i++){
- m_sigframe[i] = new float[m_fftsize];
- memset(m_sigframe[i], 0, m_fftsize*sizeof(float));
+ m_sigframe[i] = new double[m_fftsize];
+ memset(m_sigframe[i], 0, m_fftsize*sizeof(double));
m_counter[i] = i*m_hopsize;
}
@@ -135,7 +135,7 @@ FFT::ReInit(){
delete[] m_ffttmp;
delete[] m_output;
- if(!(m_output = new float[m_vecsize])){
+ if(!(m_output = new double[m_vecsize])){
m_error = 1;
#ifdef DEBUG
cout << ErrorMessage();
@@ -145,15 +145,15 @@ FFT::ReInit(){
m_frames = m_fftsize/m_hopsize;
- m_sigframe = new float*[m_frames];
- m_ffttmp = new float[m_fftsize];
+ m_sigframe = new double*[m_frames];
+ m_ffttmp = new double[m_fftsize];
m_counter = new int[m_frames];
m_halfsize = m_fftsize/2;
m_fund = m_sr/m_fftsize;
int i;
for(i = 0; i < m_frames; i++){
- m_sigframe[i] = new float[m_fftsize];
- memset(m_sigframe[i], 0, m_fftsize*sizeof(float));
+ m_sigframe[i] = new double[m_fftsize];
+ memset(m_sigframe[i], 0, m_fftsize*sizeof(double));
m_counter[i] = i*m_hopsize;
}
@@ -164,7 +164,7 @@ FFT::ReInit(){
int
-FFT::Set(char* mess, float value){
+FFT::Set(char* mess, double value){
switch(FindMsg(mess)){
@@ -208,7 +208,7 @@ FFT::DoProcess(){
if(!m_error){
if(m_input && m_table){
if(m_enable){
- int i; float sig = 0.f;
+ int i; double sig = 0.f;
for(m_vecpos = 0; m_vecpos < m_hopsize; m_vecpos++) {
// signal input
sig = m_input->Output(m_vecpos);
@@ -243,7 +243,7 @@ FFT::DoProcess(){
}
void
-FFT::fft(float* signal){
+FFT::fft(double* signal){
// FFT function
rfftw_one(m_plan, signal, m_ffttmp);
diff --git a/sndobj/FFT.h b/sndobj/FFT.h
index 9858fa4..f8aa97e 100644
--- a/sndobj/FFT.h
+++ b/sndobj/FFT.h
@@ -45,20 +45,20 @@ class FFT : public SndObj {
int m_halfsize; // 1/2 fftsize
int *m_counter; // counter
rfftw_plan m_plan; // FFTW initialisation
- float m_fund;
+ double m_fund;
- float m_scale; // scaling factor
- float m_norm; // norm factor
+ double m_scale; // scaling factor
+ double m_norm; // norm factor
int m_frames; // frame overlaps
- float** m_sigframe; // signal frames
- float* m_ffttmp; // tmp vector for fft transform
+ double** m_sigframe; // signal frames
+ double* m_ffttmp; // tmp vector for fft transform
int m_cur; // index into current frame
Table* m_table; // window
private:
// fft wrapper method
- void inline fft(float* signal);
+ void inline fft(double* signal);
// reset memory and initialisation
void ReInit();
@@ -66,9 +66,9 @@ class FFT : public SndObj {
public:
FFT();
- FFT(Table* window, SndObj* input, float scale=1.f,
+ FFT(Table* window, SndObj* input, double scale=1.f,
int fftsize=DEF_FFTSIZE, int hopsize=DEF_VECSIZE,
- float m_sr=DEF_SR);
+ double m_sr=DEF_SR);
~FFT();
@@ -76,8 +76,8 @@ class FFT : public SndObj {
int GetHopSize() { return m_hopsize; }
void SetWindow(Table* window){ m_table = window;}
int Connect(char* mess, void* input);
- int Set(char* mess, float value);
- void SetScale(float scale){ m_scale = scale; m_norm = m_fftsize/m_scale;}
+ int Set(char* mess, double value);
+ void SetScale(double scale){ m_scale = scale; m_norm = m_fftsize/m_scale;}
virtual void SetFFTSize(int fftsize);
virtual void SetHopSize(int hopsize);
diff --git a/sndobj/HammingTable.cpp b/sndobj/HammingTable.cpp
index b10301e..20c37b5 100644
--- a/sndobj/HammingTable.cpp
+++ b/sndobj/HammingTable.cpp
@@ -32,16 +32,16 @@ HammingTable :: HammingTable(){
m_L = 1024;
m_alpha = .54f;
- m_table = new float[m_L+1];
+ m_table = new double[m_L+1];
MakeTable();
}
-HammingTable :: HammingTable(long L, float alpha){
+HammingTable :: HammingTable(long L, double alpha){
m_L = L;
m_alpha = alpha;
- m_table = new float [m_L+1];
+ m_table = new double [m_L+1];
MakeTable();
}
@@ -56,18 +56,18 @@ HammingTable :: ~HammingTable(){
///////////// OPERATIONS ////////////////////////////////////
void
-HammingTable :: SetParam(long L, float alpha){
+HammingTable :: SetParam(long L, double alpha){
m_alpha = alpha;
m_L = L;
delete[] m_table;
- m_table = new float[m_L+1];
+ m_table = new double[m_L+1];
}
short
HammingTable :: MakeTable(){
for(long n = 0; n < m_L; n++)
- m_table[n]= (float)(m_alpha - (1-m_alpha)*
+ m_table[n]= (double)(m_alpha - (1-m_alpha)*
cos(n*TWOPI/(m_L-1.)));
m_table[m_L] = m_table[m_L-1];
return 1;
diff --git a/sndobj/HammingTable.h b/sndobj/HammingTable.h
index fe940c6..9a054ec 100644
--- a/sndobj/HammingTable.h
+++ b/sndobj/HammingTable.h
@@ -33,15 +33,15 @@
class HammingTable : public Table {
protected :
- float m_alpha;
+ double m_alpha;
public:
- void SetParam(long L, float alpha=.54);
+ void SetParam(long L, double alpha=.54);
char* ErrorMessage();
short MakeTable();
HammingTable();
- HammingTable(long L, float alpha);
+ HammingTable(long L, double alpha);
~HammingTable();
};
diff --git a/sndobj/HarmTable.cpp b/sndobj/HarmTable.cpp
index 562ed63..28fcd09 100644
--- a/sndobj/HarmTable.cpp
+++ b/sndobj/HarmTable.cpp
@@ -37,20 +37,20 @@ HarmTable :: HarmTable(){
m_harm = 1;
m_typew = SINE;
m_phase = 0.f;
- m_table = new float[m_L+1];
+ m_table = new double[m_L+1];
MakeTable();
}
-HarmTable :: HarmTable(long L, int harm, int type, float phase){
+HarmTable :: HarmTable(long L, int harm, int type, double phase){
m_L = L;
m_harm = harm;
m_typew = type;
- m_phase = (float)(phase*TWOPI);
+ m_phase = (double)(phase*TWOPI);
- m_table = new float [m_L+1];
+ m_table = new double [m_L+1];
MakeTable();
}
@@ -76,20 +76,20 @@ HarmTable::SetHarm(int harm, int type)
short
HarmTable :: MakeTable(){
- float max = 1.f;
+ double max = 1.f;
int n = 1, harm = m_harm, i;
switch (m_typew){
case SINE:
for(i=0; i < m_L; i++)
- m_table[i] = (float)(sin(i*TWOPI/m_L + m_phase));
+ m_table[i] = (double)(sin(i*TWOPI/m_L + m_phase));
break;
case SAW:
ZeroTable();
for(i=0; i < m_L; i++){
for(n = 1 ; n <= harm ; n++)
- m_table[i] += (float)((1/(float)n)*sin(n*i*TWOPI/m_L + m_phase));
+ m_table[i] += (double)((1/(double)n)*sin(n*i*TWOPI/m_L + m_phase));
max = (fabs((double)max) < fabs((double)m_table[i])) ? m_table[i] : max;
}
break;
@@ -98,7 +98,7 @@ HarmTable :: MakeTable(){
ZeroTable();
for(i=0; i < m_L; i++){
for(n = 1 ; n <= harm ; n+=2)
- m_table[i] += (float)((1/(float)n)*sin(n*TWOPI*i/m_L + m_phase));
+ m_table[i] += (double)((1/(double)n)*sin(n*TWOPI*i/m_L + m_phase));
max = (fabs((double)max) < fabs((double)m_table[i])) ? m_table[i] : max;
}
break;
@@ -107,7 +107,7 @@ HarmTable :: MakeTable(){
ZeroTable();
for(i=0; i < m_L; i++){
for(n = 1 ; n <= harm ; n++)
- m_table[i] += (float) sin(n*TWOPI*i/m_L + m_phase);
+ m_table[i] += (double) sin(n*TWOPI*i/m_L + m_phase);
max = (fabs((double)max) < fabs((double)m_table[i])) ? m_table[i] : max;
}
break;
diff --git a/sndobj/HarmTable.h b/sndobj/HarmTable.h
index da4e360..98671df 100644
--- a/sndobj/HarmTable.h
+++ b/sndobj/HarmTable.h
@@ -37,7 +37,7 @@ class HarmTable : public Table {
protected :
int m_harm;
- float m_phase;
+ double m_phase;
int m_typew;
public:
@@ -47,8 +47,8 @@ class HarmTable : public Table {
char* ErrorMessage();
short MakeTable();
HarmTable();
- void SetPhase(float phase){ m_phase = (float)(phase*TWOPI); }
- HarmTable(long L, int harm, int type, float phase=0.f);
+ void SetPhase(double phase){ m_phase = (double)(phase*TWOPI); }
+ HarmTable(long L, int harm, int type, double phase=0.f);
~HarmTable();
};
diff --git a/sndobj/IFAdd.cpp b/sndobj/IFAdd.cpp
index 4a03491..c962e31 100644
--- a/sndobj/IFAdd.cpp
+++ b/sndobj/IFAdd.cpp
@@ -26,7 +26,7 @@ IFAdd::IFAdd(){
}
IFAdd::IFAdd(IFGram* input, int bins, Table* table,
- float pitch, float scale, float tscal, int vecsize, float sr)
+ double pitch, double scale, double tscal, int vecsize, double sr)
: ReSyn((SinAnal *)input, bins, table, pitch, scale, tscal, vecsize, sr){
}
@@ -38,13 +38,13 @@ IFAdd::DoProcess() {
if(m_input){
- float ampnext,amp,freq, freqnext, phase;
- float inc1, inc2, a, ph, cnt, frac;
- float a2, a3, phasediff, phasenext, cph, shf;
+ double ampnext,amp,freq, freqnext, phase;
+ double inc1, inc2, a, ph, cnt, frac;
+ double a2, a3, phasediff, phasenext, cph, shf;
bool lock;
int i2, i, bins = m_maxtracks, ndx;
- float* tab = m_ptable->GetTable();
- memset(m_output, 0, sizeof(float)*m_vecsize);
+ double* tab = m_ptable->GetTable();
+ memset(m_output, 0, sizeof(double)*m_vecsize);
shf = m_tscal*m_pitch;
if(shf - Ftoi(shf)) lock = false;
diff --git a/sndobj/IFAdd.h b/sndobj/IFAdd.h
index b8d7cbd..57a0ec6 100644
--- a/sndobj/IFAdd.h
+++ b/sndobj/IFAdd.h
@@ -35,8 +35,8 @@ class IFAdd : public ReSyn {
public:
IFAdd();
- IFAdd(IFGram* input, int bins, Table* table, float pitch=1.f, float scale=1.f,
- float tscal=1.f, int vecsize=DEF_VECSIZE, float sr=DEF_SR);
+ IFAdd(IFGram* input, int bins, Table* table, double pitch=1.f, double scale=1.f,
+ double tscal=1.f, int vecsize=DEF_VECSIZE, double sr=DEF_SR);
~IFAdd();
short DoProcess();
diff --git a/sndobj/IFFT.cpp b/sndobj/IFFT.cpp
index 0b33372..01f693b 100644
--- a/sndobj/IFFT.cpp
+++ b/sndobj/IFFT.cpp
@@ -40,16 +40,16 @@ IFFT::IFFT(){
m_fftsize = DEF_FFTSIZE;
m_frames = m_fftsize/m_hopsize;
- m_sigframe = new float*[m_frames];
- m_ffttmp = new float[m_fftsize];
+ m_sigframe = new double*[m_frames];
+ m_ffttmp = new double[m_fftsize];
m_counter = new int[m_frames];
m_halfsize = m_fftsize/2;
m_fund = m_sr/m_fftsize;
int i;
- memset(m_ffttmp, 0, m_fftsize*sizeof(float));
+ memset(m_ffttmp, 0, m_fftsize*sizeof(double));
for(i = 0; i < m_frames; i++){
- m_sigframe[i] = new float[m_fftsize];
- memset(m_sigframe[i], 0, m_fftsize*sizeof(float));
+ m_sigframe[i] = new double[m_fftsize];
+ memset(m_sigframe[i], 0, m_fftsize*sizeof(double));
m_counter[i] = i*m_hopsize;
}
@@ -63,7 +63,7 @@ IFFT::IFFT(){
}
IFFT::IFFT(Table* window, SndObj* input, int fftsize, int hopsize,
- float sr):
+ double sr):
SndObj(input,hopsize, sr)
{
@@ -75,16 +75,16 @@ IFFT::IFFT(Table* window, SndObj* input, int fftsize, int hopsize,
if(m_fftsize){
m_frames = m_fftsize/m_hopsize;
- m_sigframe = new float*[m_frames];
- m_ffttmp = new float[m_fftsize];
+ m_sigframe = new double*[m_frames];
+ m_ffttmp = new double[m_fftsize];
m_counter = new int[m_frames];
m_halfsize = m_fftsize/2;
m_fund = m_sr/m_fftsize;
- memset(m_ffttmp, 0, m_fftsize*sizeof(float));
+ memset(m_ffttmp, 0, m_fftsize*sizeof(double));
int i;
for(i = 0; i < m_frames; i++){
- m_sigframe[i] = new float[m_fftsize];
- memset(m_sigframe[i], 0, m_fftsize*sizeof(float));
+ m_sigframe[i] = new double[m_fftsize];
+ memset(m_sigframe[i], 0, m_fftsize*sizeof(double));
m_counter[i] = i*m_hopsize;
}
@@ -131,7 +131,7 @@ IFFT::ReInit(){
delete[] m_ffttmp;
delete[] m_output;
- if(!(m_output = new float[m_vecsize])){
+ if(!(m_output = new double[m_vecsize])){
m_error = 1;
#ifdef DEBUG
cout << ErrorMessage();
@@ -141,15 +141,15 @@ IFFT::ReInit(){
m_frames = m_fftsize/m_hopsize;
- m_sigframe = new float*[m_frames];
- m_ffttmp = new float[m_fftsize];
+ m_sigframe = new double*[m_frames];
+ m_ffttmp = new double[m_fftsize];
m_counter = new int[m_frames];
m_halfsize = m_fftsize/2;
m_fund = m_sr/m_fftsize;
int i;
for(i = 0; i < m_frames; i++){
- m_sigframe[i] = new float[m_fftsize];
- memset(m_sigframe[i], 0, m_fftsize*sizeof(float));
+ m_sigframe[i] = new double[m_fftsize];
+ memset(m_sigframe[i], 0, m_fftsize*sizeof(double));
m_counter[i] = i*m_hopsize;
}
@@ -160,7 +160,7 @@ IFFT::ReInit(){
int
-IFFT::Set(char* mess, float value){
+IFFT::Set(char* mess, double value){
switch(FindMsg(mess)){
@@ -201,7 +201,7 @@ IFFT::DoProcess(){
if(!m_error){
if(m_input && m_table){
if(m_enable){
- int i; float out = 0.;
+ int i; double out = 0.;
// Put the input fftframe into
// the current (free) signal frame
// and transform it
@@ -218,7 +218,7 @@ IFFT::DoProcess(){
m_counter[i]++;
}
// output it.
- m_output[m_vecpos] = (float) out;
+ m_output[m_vecpos] = (double) out;
out = 0.;
}
@@ -241,7 +241,7 @@ IFFT::DoProcess(){
void
-IFFT::ifft(float* signal) {
+IFFT::ifft(double* signal) {
// get input FFT frame and
// prepare data for fftw
diff --git a/sndobj/IFFT.h b/sndobj/IFFT.h
index b7ae3ff..e748a68 100644
--- a/sndobj/IFFT.h
+++ b/sndobj/IFFT.h
@@ -46,11 +46,11 @@ class IFFT : public SndObj {
int m_halfsize; // 1/2 fftsize
int *m_counter; // counter
rfftw_plan m_plan; // FFTW initialisation
- float m_fund;
+ double m_fund;
int m_frames; // frame overlaps
- float** m_sigframe; // signal frames
- float* m_ffttmp; // tmp vector for fft transform
+ double** m_sigframe; // signal frames
+ double* m_ffttmp; // tmp vector for fft transform
int m_cur; // index into current frame
Table* m_table; // window
@@ -60,7 +60,7 @@ class IFFT : public SndObj {
private:
// ifft wrapper method
- void inline ifft(float* signal);
+ void inline ifft(double* signal);
@@ -68,7 +68,7 @@ class IFFT : public SndObj {
IFFT();
IFFT(Table* window, SndObj* input, int fftsize = DEF_FFTSIZE,
- int hopsize=DEF_VECSIZE, float sr=DEF_SR);
+ int hopsize=DEF_VECSIZE, double sr=DEF_SR);
~IFFT();
@@ -76,7 +76,7 @@ class IFFT : public SndObj {
int GetHopSize() { return m_hopsize; }
void SetWindow(Table* window){ m_table = window;}
int Connect(char* mess, void* input);
- int Set(char* mess, float value);
+ int Set(char* mess, double value);
virtual void SetFFTSize(int fftsize);
virtual void SetHopSize(int hopsize);
diff --git a/sndobj/IFGram.cpp b/sndobj/IFGram.cpp
index eb6684a..fcd73b1 100644
--- a/sndobj/IFGram.cpp
+++ b/sndobj/IFGram.cpp
@@ -29,22 +29,22 @@
#include "IFGram.h"
IFGram::IFGram(){
- m_diffwin = new float[m_fftsize];
- m_fftdiff = new float[m_fftsize];
- m_diffsig = new float[m_fftsize];
+ m_diffwin = new double[m_fftsize];
+ m_fftdiff = new double[m_fftsize];
+ m_diffsig = new double[m_fftsize];
m_factor = m_sr/TWOPI;
- m_pdiff = new float[m_halfsize];
+ m_pdiff = new double[m_halfsize];
}
-IFGram::IFGram(Table* window, SndObj* input, float scale,
- int fftsize, int hopsize, float sr)
+IFGram::IFGram(Table* window, SndObj* input, double scale,
+ int fftsize, int hopsize, double sr)
:PVA(window, input, scale, fftsize, hopsize, sr)
{
- m_diffwin = new float[m_fftsize];
- m_fftdiff = new float[m_fftsize];
- m_diffsig = new float[m_fftsize];
- m_pdiff = new float[m_halfsize];
+ m_diffwin = new double[m_fftsize];
+ m_fftdiff = new double[m_fftsize];
+ m_diffsig = new double[m_fftsize];
+ m_pdiff = new double[m_halfsize];
for(int i=0; i<m_fftsize; i++)
m_diffwin[i] = m_table->Lookup(i) - m_table->Lookup(i+1);
m_factor = m_sr/TWOPI;
@@ -60,7 +60,7 @@ IFGram::~IFGram(){
int
-IFGram::Set(char* mess, float value){
+IFGram::Set(char* mess, double value){
switch(FindMsg(mess)){
@@ -103,9 +103,9 @@ IFGram::SetFFTSize(int fftsize){
delete[] m_phases;
m_factor = m_sr*TWOPI/m_fftsize;
- m_diffwin = new float[m_fftsize];
- m_fftdiff = new float[m_fftsize];
- m_phases = new float[m_halfsize];
+ m_diffwin = new double[m_fftsize];
+ m_fftdiff = new double[m_fftsize];
+ m_phases = new double[m_halfsize];
for(int i=0; i<m_fftsize; i++)
m_diffwin[i] = m_table->Lookup(i) - m_table->Lookup(i+1);
@@ -113,7 +113,7 @@ IFGram::SetFFTSize(int fftsize){
}
void
-IFGram::IFAnalysis(float* signal){
+IFGram::IFAnalysis(double* signal){
double powerspec, da,db, a, b, ph,d;
int i2, i;
@@ -123,7 +123,7 @@ IFGram::IFAnalysis(float* signal){
signal[i] = signal[i]*m_table->Lookup(i);
}
- float tmp1, tmp2;
+ double tmp1, tmp2;
for(i=0; i<m_halfsize; i++){
tmp1 = m_diffsig[i+m_halfsize];
tmp2 = m_diffsig[i];
@@ -152,9 +152,9 @@ IFGram::IFAnalysis(float* signal){
db = m_fftdiff[m_fftsize-(i2)]*2/m_norm;
powerspec = a*a+b*b;
- if((m_output[i] = (float)sqrt(powerspec)) != 0.f){
+ if((m_output[i] = (double)sqrt(powerspec)) != 0.f){
m_output[i+1] = ((a*db - b*da)/powerspec)*m_factor + i2*m_fund;
- ph = (float) atan2(b, a);
+ ph = (double) atan2(b, a);
d = ph - m_phases[i2];
while(d > PI) d -= TWOPI;
while(d < -PI) d += TWOPI;
@@ -174,14 +174,14 @@ IFGram::DoProcess(){
if(!m_error){
if(m_input){
if(m_enable){
- int i; float sig = 0.f;
+ int i; double sig = 0.f;
for(m_vecpos = 0; m_vecpos < m_hopsize; m_vecpos++) {
// signal input
sig = m_input->Output(m_vecpos);
// distribute to the signal input frames
// according to a time pointer (kept by counter[n])
for(i=0;i < m_frames; i++){
- m_sigframe[i][m_counter[i]]= (float) sig;
+ m_sigframe[i][m_counter[i]]= (double) sig;
m_counter[i]++;
}
}
diff --git a/sndobj/IFGram.h b/sndobj/IFGram.h
index aab5c44..c404190 100644
--- a/sndobj/IFGram.h
+++ b/sndobj/IFGram.h
@@ -36,24 +36,24 @@ class IFGram : public PVA {
protected:
- float* m_diffwin; // difference window
- float* m_fftdiff; // holds fft of diff window
- float* m_diffsig;
- float* m_pdiff;
+ double* m_diffwin; // difference window
+ double* m_fftdiff; // holds fft of diff window
+ double* m_diffsig;
+ double* m_pdiff;
private:
- void inline IFAnalysis(float* signal);
+ void inline IFAnalysis(double* signal);
public:
IFGram();
- IFGram(Table* window, SndObj* input, float scale=1.f,
- int fftsize=DEF_FFTSIZE, int hopsize=DEF_VECSIZE, float sr=DEF_SR);
+ IFGram(Table* window, SndObj* input, double scale=1.f,
+ int fftsize=DEF_FFTSIZE, int hopsize=DEF_VECSIZE, double sr=DEF_SR);
~IFGram();
- int Set(char* mess, float value);
+ int Set(char* mess, double value);
int Connect(char* mess, void* input);
void SetFFTSize(int fftsize);
short DoProcess();
diff --git a/sndobj/PVA.cpp b/sndobj/PVA.cpp
index b4cda0d..59dc9c2 100644
--- a/sndobj/PVA.cpp
+++ b/sndobj/PVA.cpp
@@ -29,19 +29,19 @@
PVA::PVA(){
m_rotcount = 0;
- m_phases = new float[m_halfsize];
- memset(m_phases, 0, sizeof(float)*m_halfsize);
+ m_phases = new double[m_halfsize];
+ memset(m_phases, 0, sizeof(double)*m_halfsize);
m_factor = m_sr/(m_hopsize*TWOPI);
}
-PVA::PVA(Table* window, SndObj* input, float scale,
- int fftsize, int hopsize, float sr)
+PVA::PVA(Table* window, SndObj* input, double scale,
+ int fftsize, int hopsize, double sr)
:FFT(window, input, scale, fftsize, hopsize, sr)
{
m_rotcount = 0;
- m_phases = new float[m_halfsize];
- memset(m_phases, 0, sizeof(float)*m_halfsize);
+ m_phases = new double[m_halfsize];
+ memset(m_phases, 0, sizeof(double)*m_halfsize);
m_factor = m_sr/(m_hopsize*TWOPI);
}
@@ -53,7 +53,7 @@ PVA::~PVA(){
int
-PVA::Set(char* mess, float value){
+PVA::Set(char* mess, double value){
switch(FindMsg(mess)){
@@ -84,7 +84,7 @@ PVA::SetHopSize(int hopsize){
}
void
-PVA::pvanalysis(float* signal){
+PVA::pvanalysis(double* signal){
double re, im, pha, diff;
int i2;
@@ -105,12 +105,12 @@ PVA::pvanalysis(float* signal){
else {
pha = atan2(im,re);
diff = pha - m_phases[i2];
- m_phases[i2] = (float) pha;
+ m_phases[i2] = (double) pha;
while(diff > PI) diff -= TWOPI;
while(diff < -PI) diff += TWOPI;
}
- m_output[i+1] = (float) diff*m_factor + i2*m_fund;
+ m_output[i+1] = (double) diff*m_factor + i2*m_fund;
}
@@ -123,7 +123,7 @@ PVA::DoProcess(){
if(!m_error){
if(m_input){
if(m_enable){
- int i; float sig = 0.f;
+ int i; double sig = 0.f;
for(m_vecpos = 0; m_vecpos < m_hopsize; m_vecpos++) {
// signal input
sig = m_input->Output(m_vecpos);
@@ -131,7 +131,7 @@ PVA::DoProcess(){
// according to a time pointer (kept by counter[n])
// input is also rotated according to the input time.
for(i=0;i < m_frames; i++){
- m_sigframe[i][m_rotcount]= (float) sig*m_table->Lookup(m_counter[i]);
+ m_sigframe[i][m_rotcount]= (double) sig*m_table->Lookup(m_counter[i]);
m_counter[i]++;
}
m_rotcount++;
diff --git a/sndobj/PVA.h b/sndobj/PVA.h
index d53f760..0826f99 100644
--- a/sndobj/PVA.h
+++ b/sndobj/PVA.h
@@ -36,22 +36,22 @@ class PVA : public FFT {
protected:
int m_rotcount; // rotation counter
- float m_factor; // conversion factor
- float* m_phases;
+ double m_factor; // conversion factor
+ double* m_phases;
private:
- void inline pvanalysis(float* signal);
+ void inline pvanalysis(double* signal);
public:
PVA();
- PVA(Table* window, SndObj* input, float scale=1.f,
- int fftsize=DEF_FFTSIZE, int hopsize=DEF_VECSIZE, float sr=DEF_SR);
+ PVA(Table* window, SndObj* input, double scale=1.f,
+ int fftsize=DEF_FFTSIZE, int hopsize=DEF_VECSIZE, double sr=DEF_SR);
~PVA();
- float Outphases(int pos){ return m_phases[pos]; } // reads phase output.
- int Set(char* mess, float value);
+ double Outphases(int pos){ return m_phases[pos]; } // reads phase output.
+ int Set(char* mess, double value);
void SetFFTSize(int fftsize);
void SetHopSize(int hopsize);
short DoProcess();
diff --git a/sndobj/PVS.cpp b/sndobj/PVS.cpp
index cec0313..d38f4e5 100644
--- a/sndobj/PVS.cpp
+++ b/sndobj/PVS.cpp
@@ -31,20 +31,20 @@
PVS::PVS(){
m_rotcount = m_vecsize;
- m_phases = new float[m_halfsize];
- memset(m_phases, 0, sizeof(float)*m_halfsize);
+ m_phases = new double[m_halfsize];
+ memset(m_phases, 0, sizeof(double)*m_halfsize);
m_factor = (m_hopsize*TWOPI)/m_sr;
m_first = true;
}
PVS::PVS(Table* window, SndObj* input, int fftsize,
- int hopsize, float sr)
+ int hopsize, double sr)
:IFFT(window, input,fftsize,hopsize,sr)
{
m_rotcount = m_vecsize;
if(m_halfsize){
- m_phases = new float[m_halfsize];
- memset(m_phases, 0, sizeof(float)*m_halfsize);
+ m_phases = new double[m_halfsize];
+ memset(m_phases, 0, sizeof(double)*m_halfsize);
}
m_factor = (m_hopsize*TWOPI)/m_sr;
m_first = true;
@@ -57,7 +57,7 @@ PVS::~PVS(){
int
-PVS::Set(char* mess, float value){
+PVS::Set(char* mess, double value){
switch(FindMsg(mess)){
@@ -89,7 +89,7 @@ PVS::SetHopSize(int hopsize){
}
void
-PVS::pvsynthesis(float* signal){
+PVS::pvsynthesis(double* signal){
double pha;
int i2;
@@ -113,7 +113,7 @@ PVS::DoProcess(){
if(!m_error){
if(m_input){
if(m_enable){
- int i; float out = 0.;
+ int i; double out = 0.;
// phase vocoder synthesis
if(m_first) {
@@ -138,7 +138,7 @@ PVS::DoProcess(){
}
m_rotcount++;
// output it.
- m_output[m_vecpos] = (float) out;
+ m_output[m_vecpos] = (double) out;
out = 0.;
}
m_rotcount %= m_fftsize;
diff --git a/sndobj/PVS.h b/sndobj/PVS.h
index 7347440..6108055 100644
--- a/sndobj/PVS.h
+++ b/sndobj/PVS.h
@@ -37,22 +37,22 @@ class PVS : public IFFT {
protected:
int m_rotcount; // rotation counter
- float m_factor; // conversion factor
- float* m_phases; // old phases
+ double m_factor; // conversion factor
+ double* m_phases; // old phases
private:
- void inline pvsynthesis(float* signal);
+ void inline pvsynthesis(double* signal);
bool m_first;
public:
PVS();
PVS(Table* window, SndObj* input, int fftsize=DEF_FFTSIZE,
- int hopsize=DEF_VECSIZE, float sr=DEF_SR);
+ int hopsize=DEF_VECSIZE, double sr=DEF_SR);
~PVS();
- int Set(char* mess, float value);
+ int Set(char* mess, double value);
void SetFFTSize(int fftsize);
void SetHopSize(int hopsize);
diff --git a/sndobj/ReSyn.cpp b/sndobj/ReSyn.cpp
index f81871a..9d72b12 100644
--- a/sndobj/ReSyn.cpp
+++ b/sndobj/ReSyn.cpp
@@ -30,8 +30,8 @@ ReSyn::ReSyn(){
}
-ReSyn::ReSyn(SinAnal* input, int maxtracks, Table* table, float pitch, float scale, float tscal,
- int vecsize, float sr)
+ReSyn::ReSyn(SinAnal* input, int maxtracks, Table* table, double pitch, double scale, double tscal,
+ int vecsize, double sr)
: SinSyn(input, maxtracks, table, scale, vecsize, sr){
m_pitch = pitch;
AddMsg("pitch", 31);
@@ -42,7 +42,7 @@ ReSyn::~ReSyn(){
}
int
-ReSyn::Set(char* mess, float value){
+ReSyn::Set(char* mess, double value){
switch(FindMsg(mess)){
@@ -67,17 +67,17 @@ ReSyn::DoProcess() {
if(m_input){
- float ampnext,amp,freq, freqnext, phase,phasenext;
- float a2, a3, phasediff, cph;
+ double ampnext,amp,freq, freqnext, phase,phasenext;
+ double a2, a3, phasediff, cph;
int i3, i, j, ID;
int notcontin = 0;
bool contin = false;
int oldtracks = m_tracks;
- float* tab = m_ptable->GetTable();
+ double* tab = m_ptable->GetTable();
if((m_tracks = ((SinAnal *)m_input)->GetTracks()) >
m_maxtracks) m_tracks = m_maxtracks;
- memset(m_output, 0, sizeof(float)*m_vecsize);
+ memset(m_output, 0, sizeof(double)*m_vecsize);
// for each track
i = j = 0;
@@ -132,7 +132,7 @@ ReSyn::DoProcess() {
a3 = 1./(3*m_facsqr) * (freqnext - freq - 2*a2*m_factor);
// interpolation resynthesis loop
- float inc1, inc2, a, ph, cnt, frac;
+ double inc1, inc2, a, ph, cnt, frac;
int ndx;
a = amp;
ph = phase;
diff --git a/sndobj/ReSyn.h b/sndobj/ReSyn.h
index 6233aee..d7525f8 100644
--- a/sndobj/ReSyn.h
+++ b/sndobj/ReSyn.h
@@ -29,18 +29,18 @@ class ReSyn : public SinSyn {
protected:
- float m_pitch;
- float m_tscal;
+ double m_pitch;
+ double m_tscal;
public:
ReSyn();
- ReSyn(SinAnal* input, int maxtracks, Table* table, float pitch=1.f,
- float scale=1.f, float tscal=1.f, int vecsize=DEF_VECSIZE,
- float sr=DEF_SR);
- void SetPitch(float pitch){ m_pitch = pitch; }
- void SetTimeScale(float scale) { m_tscal = scale; }
- int Set(char* mess, float value);
+ ReSyn(SinAnal* input, int maxtracks, Table* table, double pitch=1.f,
+ double scale=1.f, double tscal=1.f, int vecsize=DEF_VECSIZE,
+ double sr=DEF_SR);
+ void SetPitch(double pitch){ m_pitch = pitch; }
+ void SetTimeScale(double scale) { m_tscal = scale; }
+ int Set(char* mess, double value);
~ReSyn();
short DoProcess();
diff --git a/sndobj/SinAnal.cpp b/sndobj/SinAnal.cpp
index 3a38488..c4e609f 100644
--- a/sndobj/SinAnal.cpp
+++ b/sndobj/SinAnal.cpp
@@ -45,8 +45,8 @@ SinAnal::SinAnal(){
AddMsg("threshold", 22);
}
-SinAnal::SinAnal(SndObj* input, float threshold, int maxtracks,
- int minpoints, int maxgap, float sr)
+SinAnal::SinAnal(SndObj* input, double threshold, int maxtracks,
+ int minpoints, int maxgap, double sr)
:SndObj(input,maxtracks*3,sr){
m_minpoints = (minpoints > 1 ? minpoints : 1) - 1;
@@ -59,20 +59,20 @@ SinAnal::SinAnal(SndObj* input, float threshold, int maxtracks,
m_numpeaks = 0;
m_numbins = ((FFT *)m_input)->GetFFTSize()/2 + 1;
- m_bndx = new float*[minpoints+2];
- m_pkmags = new float*[minpoints+2];
- m_adthresh = new float*[minpoints+2];
+ m_bndx = new double*[minpoints+2];
+ m_pkmags = new double*[minpoints+2];
+ m_adthresh = new double*[minpoints+2];
m_tstart = new unsigned int*[minpoints+2];
m_lastpk = new unsigned int*[minpoints+2];
m_trkid = new unsigned int*[minpoints+2];
int i;
for(i=0; i<minpoints+2; i++){
- m_bndx[i] = new float[m_maxtracks];
- memset(m_bndx[i],0,sizeof(float)*m_maxtracks);
- m_pkmags[i] = new float[m_maxtracks];
- memset(m_pkmags[i],0,sizeof(float)*m_maxtracks);
- m_adthresh[i] = new float[m_maxtracks];
- memset(m_pkmags[i],0,sizeof(float)*m_maxtracks);
+ m_bndx[i] = new double[m_maxtracks];
+ memset(m_bndx[i],0,sizeof(double)*m_maxtracks);
+ m_pkmags[i] = new double[m_maxtracks];
+ memset(m_pkmags[i],0,sizeof(double)*m_maxtracks);
+ m_adthresh[i] = new double[m_maxtracks];
+ memset(m_pkmags[i],0,sizeof(double)*m_maxtracks);
m_tstart[i] = new unsigned int[m_maxtracks];
memset(m_tstart[i],0,sizeof(unsigned int)*m_maxtracks);
m_lastpk[i] = new unsigned int[m_maxtracks];
@@ -82,29 +82,29 @@ SinAnal::SinAnal(SndObj* input, float threshold, int maxtracks,
}
- m_bins = new float[m_maxtracks];
- memset(m_bins, 0, sizeof(float) * m_maxtracks);
+ m_bins = new double[m_maxtracks];
+ memset(m_bins, 0, sizeof(double) * m_maxtracks);
m_trndx = new int[m_maxtracks];
memset(m_trndx, 0, sizeof(int) * m_maxtracks);
m_contflag = new bool[m_maxtracks];
memset(m_contflag, 0, sizeof(bool) * m_maxtracks);
- m_phases = new float[m_numbins];
- memset(m_phases, 0, sizeof(float) * m_numbins);
- m_freqs = new float[m_numbins];
- memset(m_freqs, 0, sizeof(float) * m_numbins);
- m_mags = new float[m_numbins];
- memset(m_mags, 0, sizeof(float) * m_numbins);
+ m_phases = new double[m_numbins];
+ memset(m_phases, 0, sizeof(double) * m_numbins);
+ m_freqs = new double[m_numbins];
+ memset(m_freqs, 0, sizeof(double) * m_numbins);
+ m_mags = new double[m_numbins];
+ memset(m_mags, 0, sizeof(double) * m_numbins);
- m_binmax = new float[m_numbins];
- memset(m_binmax, 0, sizeof(float) * m_numbins);
- m_magmax = new float[m_numbins];
- memset(m_magmax, 0, sizeof(float) * m_numbins);
- m_diffs = new float[m_numbins];
- memset(m_diffs, 0, sizeof(float) * m_numbins);
+ m_binmax = new double[m_numbins];
+ memset(m_binmax, 0, sizeof(double) * m_numbins);
+ m_magmax = new double[m_numbins];
+ memset(m_magmax, 0, sizeof(double) * m_numbins);
+ m_diffs = new double[m_numbins];
+ memset(m_diffs, 0, sizeof(double) * m_numbins);
m_maxix = new int[m_numbins];
- memset(m_maxix, 0, sizeof(float) * m_numbins);
+ memset(m_maxix, 0, sizeof(double) * m_numbins);
m_timecount = 0;
m_phases[0] = 0.f;
@@ -120,8 +120,8 @@ SinAnal::SinAnal(SndObj* input, float threshold, int maxtracks,
}
-SinAnal::SinAnal(SndObj* input, int numbins, float threshold, int maxtracks,
- int minpoints, int maxgap, float sr)
+SinAnal::SinAnal(SndObj* input, int numbins, double threshold, int maxtracks,
+ int minpoints, int maxgap, double sr)
:SndObj(input,maxtracks*3,sr){
m_minpoints = (minpoints > 1 ? minpoints : 1) - 1;
@@ -134,20 +134,20 @@ SinAnal::SinAnal(SndObj* input, int numbins, float threshold, int maxtracks,
m_numpeaks = 0;
m_numbins = numbins;
- m_bndx = new float*[minpoints+2];
- m_pkmags = new float*[minpoints+2];
- m_adthresh = new float*[minpoints+2];
+ m_bndx = new double*[minpoints+2];
+ m_pkmags = new double*[minpoints+2];
+ m_adthresh = new double*[minpoints+2];
m_tstart = new unsigned int*[minpoints+2];
m_lastpk = new unsigned int*[minpoints+2];
m_trkid = new unsigned int*[minpoints+2];
int i;
for(i=0; i<minpoints+2; i++){
- m_bndx[i] = new float[m_maxtracks];
- memset(m_bndx[i],0,sizeof(float)*m_maxtracks);
- m_pkmags[i] = new float[m_maxtracks];
- memset(m_pkmags[i],0,sizeof(float)*m_maxtracks);
- m_adthresh[i] = new float[m_maxtracks];
- memset(m_pkmags[i],0,sizeof(float)*m_maxtracks);
+ m_bndx[i] = new double[m_maxtracks];
+ memset(m_bndx[i],0,sizeof(double)*m_maxtracks);
+ m_pkmags[i] = new double[m_maxtracks];
+ memset(m_pkmags[i],0,sizeof(double)*m_maxtracks);
+ m_adthresh[i] = new double[m_maxtracks];
+ memset(m_pkmags[i],0,sizeof(double)*m_maxtracks);
m_tstart[i] = new unsigned int[m_maxtracks];
memset(m_tstart[i],0,sizeof(unsigned int)*m_maxtracks);
m_lastpk[i] = new unsigned int[m_maxtracks];
@@ -157,29 +157,29 @@ SinAnal::SinAnal(SndObj* input, int numbins, float threshold, int maxtracks,
}
- m_bins = new float[m_maxtracks];
- memset(m_bins, 0, sizeof(float) * m_maxtracks);
+ m_bins = new double[m_maxtracks];
+ memset(m_bins, 0, sizeof(double) * m_maxtracks);
m_trndx = new int[m_maxtracks];
memset(m_trndx, 0, sizeof(int) * m_maxtracks);
m_contflag = new bool[m_maxtracks];
memset(m_contflag, 0, sizeof(bool) * m_maxtracks);
- m_phases = new float[m_numbins];
- memset(m_phases, 0, sizeof(float) * m_numbins);
- m_freqs = new float[m_numbins];
- memset(m_freqs, 0, sizeof(float) * m_numbins);
- m_mags = new float[m_numbins];
- memset(m_mags, 0, sizeof(float) * m_numbins);
+ m_phases = new double[m_numbins];
+ memset(m_phases, 0, sizeof(double) * m_numbins);
+ m_freqs = new double[m_numbins];
+ memset(m_freqs, 0, sizeof(double) * m_numbins);
+ m_mags = new double[m_numbins];
+ memset(m_mags, 0, sizeof(double) * m_numbins);
- m_binmax = new float[m_numbins];
- memset(m_binmax, 0, sizeof(float) * m_numbins);
- m_magmax = new float[m_numbins];
- memset(m_magmax, 0, sizeof(float) * m_numbins);
- m_diffs = new float[m_numbins];
- memset(m_diffs, 0, sizeof(float) * m_numbins);
+ m_binmax = new double[m_numbins];
+ memset(m_binmax, 0, sizeof(double) * m_numbins);
+ m_magmax = new double[m_numbins];
+ memset(m_magmax, 0, sizeof(double) * m_numbins);
+ m_diffs = new double[m_numbins];
+ memset(m_diffs, 0, sizeof(double) * m_numbins);
m_maxix = new int[m_numbins];
- memset(m_maxix, 0, sizeof(float) * m_numbins);
+ memset(m_maxix, 0, sizeof(double) * m_numbins);
m_timecount = 0;
m_phases[0] = 0.f;
@@ -234,23 +234,23 @@ SinAnal::SetMaxTracks(int maxtracks){
}
m_contflag = new bool[m_maxtracks];
- m_bins = new float[m_maxtracks];
+ m_bins = new double[m_maxtracks];
m_trndx = new int[m_maxtracks];
m_prev = m_minpoints+1; m_cur = 0;
- m_bndx = new float*[2];
- m_pkmags = new float*[2];
- m_adthresh = new float*[2];
+ m_bndx = new double*[2];
+ m_pkmags = new double*[2];
+ m_adthresh = new double*[2];
m_tstart = new unsigned int*[2];
m_lastpk = new unsigned int*[2];
m_trkid = new unsigned int*[2];
int i;
for(i=0; i<m_minpoints+2; i++){
- m_bndx[i] = new float[m_maxtracks];
- memset(m_bndx[i],0,sizeof(float)*m_maxtracks);
- m_pkmags[i] = new float[m_maxtracks];
- memset(m_pkmags[i],0,sizeof(float)*m_maxtracks);
- m_adthresh[i] = new float[m_maxtracks];
- memset(m_pkmags[i],0,sizeof(float)*m_maxtracks);
+ m_bndx[i] = new double[m_maxtracks];
+ memset(m_bndx[i],0,sizeof(double)*m_maxtracks);
+ m_pkmags[i] = new double[m_maxtracks];
+ memset(m_pkmags[i],0,sizeof(double)*m_maxtracks);
+ m_adthresh[i] = new double[m_maxtracks];
+ memset(m_pkmags[i],0,sizeof(double)*m_maxtracks);
m_tstart[i] = new unsigned int[m_maxtracks];
memset(m_tstart[i],0,sizeof(unsigned int)*m_maxtracks);
m_lastpk[i] = new unsigned int[m_maxtracks];
@@ -284,12 +284,12 @@ SinAnal::SetIFGram(SndObj* input){
SetInput(input);
m_numbins = ((FFT *)m_input)->GetFFTSize()/2 + 1;
- m_phases = new float[m_numbins];
- m_freqs = new float[m_numbins];
- m_mags = new float[m_numbins];
- m_binmax = new float[m_numbins];
- m_magmax = new float[m_numbins];
- m_diffs = new float[m_numbins];
+ m_phases = new double[m_numbins];
+ m_freqs = new double[m_numbins];
+ m_mags = new double[m_numbins];
+ m_binmax = new double[m_numbins];
+ m_magmax = new double[m_numbins];
+ m_diffs = new double[m_numbins];
m_maxix = new int[m_numbins];
m_phases[0] = 0.f;
@@ -302,7 +302,7 @@ SinAnal::SetIFGram(SndObj* input){
int
-SinAnal::Set(char* mess, float value){
+SinAnal::Set(char* mess, double value){
switch(FindMsg(mess)){
@@ -339,9 +339,9 @@ SinAnal::Connect(char* mess, void *input){
int
SinAnal::peakdetection(){
- float logthresh;
+ double logthresh;
int i = 0, n = 0;
- float max = 0.f;
+ double max = 0.f;
double y1, y2, a, b, ftmp;
for(i=0; i<m_numbins;i++)
@@ -383,8 +383,8 @@ SinAnal::peakdetection(){
a = (y2 - 2*y1)/2.f;
b = 1.f - y1/a;
- m_binmax[i] = (float) (rmax - 1. + b/2.);
- m_magmax[i] = (float) exp(ftmp - a*b*b/4.);
+ m_binmax[i] = (double) (rmax - 1. + b/2.);
+ m_magmax[i] = (double) exp(ftmp - a*b*b/4.);
}
return n;
@@ -414,7 +414,7 @@ SinAnal::FindPeaks(){
// output peaks
for(m_vecpos=0; m_vecpos < m_vecsize; m_vecpos += 3){
int pos = m_vecpos/3, ndx;
- float frac, a, b;
+ double frac, a, b;
if((pos < n) && (pos < m_maxtracks)){
// bin number
ndx = Ftoi(m_binmax[pos]);
@@ -455,9 +455,9 @@ SinAnal::FindPeaks(){
}
void
-SinAnal::SetPeaks(int numamps, float* amps, int numfreqs,
- float* freqs, int numphases, float* phases){
- float binwidth = (m_sr / 2) / m_numbins;
+SinAnal::SetPeaks(int numamps, double* amps, int numfreqs,
+ double* freqs, int numphases, double* phases){
+ double binwidth = (m_sr / 2) / m_numbins;
m_numpeaks = numamps;
for(int i = 0; i < m_numbins; i++){
if(i < m_numpeaks){
@@ -474,7 +474,7 @@ SinAnal::SetPeaks(int numamps, float* amps, int numfreqs,
void
SinAnal::PartialTracking(){
int bestix, count=0, i = 0, n = 0, j = 0;
- float dbstep;
+ double dbstep;
// reset allowcont flags
for(i=0; i < m_maxtracks; i++){
@@ -490,7 +490,7 @@ SinAnal::PartialTracking(){
if(m_numpeaks > 0){ // check for peaks; m_numpeaks will be > 0
- float F = m_bndx[m_prev][j];
+ double F = m_bndx[m_prev][j];
for(i=0; i < m_numbins; i++){
m_diffs[i] = m_binmax[i] - F; //differences
@@ -503,7 +503,7 @@ SinAnal::PartialTracking(){
if(m_diffs[i] < m_diffs[bestix]) bestix = i;
// if difference smaller than 1 bin
- float tempf = F - m_binmax[bestix];
+ double tempf = F - m_binmax[bestix];
tempf = (tempf < 0 ? -tempf : tempf);
if(tempf < 1.){
@@ -525,8 +525,8 @@ SinAnal::PartialTracking(){
count++;
// update the adaptive mag threshold
- float tmp1 = dbstep*1.5f;
- float tmp2 = m_adthresh[m_prev][j] -
+ double tmp1 = dbstep*1.5f;
+ double tmp2 = m_adthresh[m_prev][j] -
(m_adthresh[m_prev][j] - 1.5f)*0.048770575f;
m_adthresh[m_prev][j] = (tmp1 > tmp2 ? tmp1 : tmp2);
@@ -631,7 +631,7 @@ SinAnal::PartialTracking(){
if(!m_error){
if(m_input){
if(m_enable){
- float binwidth = (m_sr / 2) / m_numbins;
+ double binwidth = (m_sr / 2) / m_numbins;
for(m_vecpos=0; m_vecpos < m_vecsize; m_vecpos += 3){
int pos = m_vecpos/3;
@@ -664,7 +664,7 @@ void
SinAnal::sinanalysis(){
int bestix, count=0, i = 0, n = 0, j = 0;
- float dbstep;
+ double dbstep;
n = peakdetection();
@@ -684,7 +684,7 @@ SinAnal::sinanalysis(){
if(n > 0){ // check for peaks; n will be > 0
- float F = m_bndx[m_prev][j];
+ double F = m_bndx[m_prev][j];
for(i=0; i < m_numbins; i++){
m_diffs[i] = m_binmax[i] - F; //differences
@@ -697,7 +697,7 @@ SinAnal::sinanalysis(){
if(m_diffs[i] < m_diffs[bestix]) bestix = i;
// if difference smaller than 1 bin
- float tempf = F - m_binmax[bestix];
+ double tempf = F - m_binmax[bestix];
tempf = (tempf < 0 ? -tempf : tempf);
if(tempf < 1.){
@@ -719,8 +719,8 @@ SinAnal::sinanalysis(){
count++;
// update the adaptive mag threshold
- float tmp1 = dbstep*1.5f;
- float tmp2 = m_adthresh[m_prev][j] -
+ double tmp1 = dbstep*1.5f;
+ double tmp2 = m_adthresh[m_prev][j] -
(m_adthresh[m_prev][j] - 1.5f)*0.048770575f;
m_adthresh[m_prev][j] = (tmp1 > tmp2 ? tmp1 : tmp2);
@@ -854,7 +854,7 @@ SinAnal::DoProcess(){
for(m_vecpos=0; m_vecpos < m_vecsize; m_vecpos+=3){
int pos = m_vecpos/3, ndx;
- float frac,a,b;
+ double frac,a,b;
if(pos < m_tracks){
// magnitudes
ndx = Ftoi(m_bins[pos]);
diff --git a/sndobj/SinAnal.h b/sndobj/SinAnal.h
index e8f9f43..ee46a44 100644
--- a/sndobj/SinAnal.h
+++ b/sndobj/SinAnal.h
@@ -30,30 +30,30 @@ class SinAnal : public SndObj {
protected:
- float** m_bndx; // bin indexes
- float** m_pkmags; // peak mags
- float** m_adthresh; // thresholds
+ double** m_bndx; // bin indexes
+ double** m_pkmags; // peak mags
+ double** m_adthresh; // thresholds
unsigned int** m_tstart; // start times
unsigned int** m_lastpk; // end times
unsigned int** m_trkid; // track ids
- float* m_phases; // phases
- float* m_freqs; // frequencies
- float* m_mags; // magnitudes
- float* m_bins; // track bin indexes
+ double* m_phases; // phases
+ double* m_freqs; // frequencies
+ double* m_mags; // magnitudes
+ double* m_bins; // track bin indexes
int* m_trndx; // track IDs
- float* m_binmax; // peak bin indexes
- float* m_magmax; // peak mags
- float* m_diffs; // differences
+ double* m_binmax; // peak bin indexes
+ double* m_magmax; // peak mags
+ double* m_diffs; // differences
int* m_maxix; // max peak locations
bool* m_contflag; // continuation flags
int m_numbins; // number of bins
int m_maxtracks; // max number of tracks
- float m_startupThresh; // startup threshold
- float m_thresh; // threshold
+ double m_startupThresh; // startup threshold
+ double m_thresh; // threshold
int m_tracks; // tracks in a frame
int m_prev;
@@ -72,25 +72,25 @@ class SinAnal : public SndObj {
public:
SinAnal();
- SinAnal(SndObj* input, float threshold, int maxtracks, int minpoints=1,
- int maxgap=3, float sr=DEF_SR);
- SinAnal(SndObj* input, int numbins, float threshold, int maxtracks, int minpoints=1,
- int maxgap=3, float sr=DEF_SR);
+ SinAnal(SndObj* input, double threshold, int maxtracks, int minpoints=1,
+ int maxgap=3, double sr=DEF_SR);
+ SinAnal(SndObj* input, int numbins, double threshold, int maxtracks, int minpoints=1,
+ int maxgap=3, double sr=DEF_SR);
~SinAnal();
virtual int GetTrackID(int track){ return m_trndx[track]; }
virtual int GetTracks(){ return m_tracks;}
- int Set(char* mess, float value);
+ int Set(char* mess, double value);
int Connect(char* mess, void* input);
- void SetThreshold(float threshold){ m_thresh = threshold; }
+ void SetThreshold(double threshold){ m_thresh = threshold; }
void SetIFGram(SndObj* input);
void SetMaxTracks(int maxtracks);
int FindPeaks();
- void SetPeaks(int numamps, float* amps, int numfreqs, float* freqs,
- int numphases, float* phases);
+ void SetPeaks(int numamps, double* amps, int numfreqs, double* freqs,
+ int numphases, double* phases);
void PartialTracking();
short DoProcess();
};
diff --git a/sndobj/SinSyn.cpp b/sndobj/SinSyn.cpp
index 61b39f8..7452b95 100644
--- a/sndobj/SinSyn.cpp
+++ b/sndobj/SinSyn.cpp
@@ -43,7 +43,7 @@ SinSyn::SinSyn(){
}
SinSyn::SinSyn(SinAnal* input, int maxtracks, Table* table,
- float scale, int vecsize, float sr)
+ double scale, int vecsize, double sr)
:SndObj(input, vecsize, sr){
m_ptable = table;
@@ -56,12 +56,12 @@ SinSyn::SinSyn(SinAnal* input, int maxtracks, Table* table,
m_tracks = 0;
m_scale = scale;
m_input = input;
- m_freqs = new float[m_maxtracks];
- m_amps = new float[m_maxtracks];
- m_phases = new float[m_maxtracks];
+ m_freqs = new double[m_maxtracks];
+ m_amps = new double[m_maxtracks];
+ m_phases = new double[m_maxtracks];
m_trackID = new int[m_maxtracks];
- memset(m_phases, 0, sizeof(float)*m_maxtracks);
+ memset(m_phases, 0, sizeof(double)*m_maxtracks);
m_incr = 0.f;
m_ratio = m_size/m_sr;
@@ -109,7 +109,7 @@ SinSyn::Connect(char* mess, void* input){
int
-SinSyn::Set(char* mess, float value){
+SinSyn::Set(char* mess, double value){
switch(FindMsg(mess)){
@@ -141,9 +141,9 @@ SinSyn::SetMaxTracks(int maxtracks){
}
m_maxtracks = maxtracks;
- m_freqs = new float[m_maxtracks];
- m_amps = new float[m_maxtracks];
- m_phases = new float[m_maxtracks];
+ m_freqs = new double[m_maxtracks];
+ m_amps = new double[m_maxtracks];
+ m_phases = new double[m_maxtracks];
m_trackID = new int[m_maxtracks];
}
@@ -153,17 +153,17 @@ SinSyn::DoProcess() {
if(m_input){
- float ampnext,amp,freq, freqnext, phase,phasenext;
- float a2, a3, phasediff, cph;
+ double ampnext,amp,freq, freqnext, phase,phasenext;
+ double a2, a3, phasediff, cph;
int i3, i, j, ID, track;
int notcontin = 0;
bool contin = false;
int oldtracks = m_tracks;
- float* tab = m_ptable->GetTable();
+ double* tab = m_ptable->GetTable();
if((m_tracks = ((SinAnal *)m_input)->GetTracks()) >
m_maxtracks) m_tracks = m_maxtracks;
- memset(m_output, 0, sizeof(float)*m_vecsize);
+ memset(m_output, 0, sizeof(double)*m_vecsize);
// for each track
i = j = 0;
@@ -220,7 +220,7 @@ SinSyn::DoProcess() {
a3 = 1./(3*m_facsqr) * (freqnext - freq - 2*a2*m_factor);
// interpolation resynthesis loop
- float inc1, inc2, a, ph, cnt, frac;
+ double inc1, inc2, a, ph, cnt, frac;
int ndx;
a = amp;
ph = phase;
diff --git a/sndobj/SinSyn.h b/sndobj/SinSyn.h
index 30c81e4..6d9e519 100644
--- a/sndobj/SinSyn.h
+++ b/sndobj/SinSyn.h
@@ -31,35 +31,35 @@ class SinSyn : public SndObj {
protected:
- float m_size;
+ double m_size;
Table* m_ptable;
- float m_factor;
- float m_facsqr;
- float m_LoTWOPI;
- float m_scale;
- float m_incr;
- float m_ratio;
+ double m_factor;
+ double m_facsqr;
+ double m_LoTWOPI;
+ double m_scale;
+ double m_incr;
+ double m_ratio;
int m_tracks;
int* m_trackID;
int m_maxtracks;
- float* m_phases;
- float* m_freqs;
- float* m_amps;
+ double* m_phases;
+ double* m_freqs;
+ double* m_amps;
public:
SinSyn();
- SinSyn(SinAnal* input, int maxtracks, Table* table, float scale=1.f,
- int vecsize=DEF_VECSIZE, float sr=DEF_SR);
+ SinSyn(SinAnal* input, int maxtracks, Table* table, double scale=1.f,
+ int vecsize=DEF_VECSIZE, double sr=DEF_SR);
~SinSyn();
void SetTable(Table* table);
void SetMaxTracks(int maxtracks);
- void SetScale(float scale) { m_scale = scale; }
- int Set(char* mess, float value);
+ void SetScale(double scale) { m_scale = scale; }
+ int Set(char* mess, double value);
int Connect(char* mess, void* input);
short DoProcess();
diff --git a/sndobj/SndIO.cpp b/sndobj/SndIO.cpp
index 1e7b72c..6f79feb 100644
--- a/sndobj/SndIO.cpp
+++ b/sndobj/SndIO.cpp
@@ -31,7 +31,7 @@
SndIO::SndIO(short channels, short bits, SndObj** inputlist,
- int vecsize, float sr){
+ int vecsize, double sr){
int n;
m_channels = channels;
@@ -78,7 +78,7 @@ SndIO::SndIO(short channels, short bits, SndObj** inputlist,
SndIO::SetVectorSize(int vecsize){
m_samples = vecsize*m_channels;
if(m_output) delete[] m_output;
- if(!(m_output = new float[m_samples])){
+ if(!(m_output = new double[m_samples])){
m_error = 1;
#ifdef DEBUG
cout << ErrorMessage();
diff --git a/sndobj/SndIO.h b/sndobj/SndIO.h
index 2516880..ad9456e 100644
--- a/sndobj/SndIO.h
+++ b/sndobj/SndIO.h
@@ -82,8 +82,8 @@ class SndIO {
protected:
SndObj** m_IOobjs;
- float* m_output;
- float m_sr;
+ double* m_output;
+ double m_sr;
short m_channels;
short m_bits;
int m_vecsize;
@@ -100,7 +100,7 @@ class SndIO {
public:
short m_sampsize;
- float GetSr(){ return m_sr; }
+ double GetSr(){ return m_sr; }
int GetVectorSize() { return m_vecsize; }
void SetVectorSize(int vecsize);
void LimitVectorSize(int limit) {
@@ -112,8 +112,8 @@ class SndIO {
void RestoreVectorSize(){ m_vecsize = m_vecsize_max; }
short GetChannels() { return m_channels; }
short GetSize() { return m_bits; }
- float Output(int pos){ return m_output[pos]; }
- float Output(int pos, int channel){
+ double Output(int pos){ return m_output[pos]; }
+ double Output(int pos, int channel){
return m_output[(pos*m_channels)+(channel-1)];
}
short SetOutput(short channel, SndObj* input){
@@ -124,7 +124,7 @@ class SndIO {
}
SndIO(short channels=1, short bits=16,SndObj** inputlist=0,
- int vecsize = DEF_VECSIZE, float sr = DEF_SR);
+ int vecsize = DEF_VECSIZE, double sr = DEF_SR);
virtual ~SndIO();
virtual short Read();
virtual short Write();
diff --git a/sndobj/SndObj.cpp b/sndobj/SndObj.cpp
index cc02494..a111426 100644
--- a/sndobj/SndObj.cpp
+++ b/sndobj/SndObj.cpp
@@ -46,7 +46,7 @@ SndObj::SndObj(){
}
-SndObj::SndObj(SndObj* input, int vecsize, float sr){
+SndObj::SndObj(SndObj* input, int vecsize, double sr){
m_output = NULL;
SetVectorSize(vecsize);
m_input = input;
@@ -135,7 +135,7 @@ SndObj::Connect(char* mess, void *input){
}
int
-SndObj::Set(char* mess, float value){
+SndObj::Set(char* mess, double value){
switch (FindMsg(mess)){
@@ -159,7 +159,7 @@ SndObj::Set(char* mess, float value){
void
SndObj::SetVectorSize(int vecsize){
if(m_output) delete[] m_output;
- if(!(m_output = new float[vecsize])){
+ if(!(m_output = new double[vecsize])){
m_error = 1;
#ifdef DEBUG
cout << ErrorMessage();
diff --git a/sndobj/SndObj.h b/sndobj/SndObj.h
index 0b8c80e..ce1986e 100644
--- a/sndobj/SndObj.h
+++ b/sndobj/SndObj.h
@@ -44,7 +44,7 @@ class SndIO;
const double PI = 4.*atan(1.);
const int DEF_FFTSIZE = 1024;
const int DEF_VECSIZE = 256;
-const float DEF_SR = 44100.f;
+const double DEF_SR = 44100.f;
struct msg_link {
string msg;
@@ -56,9 +56,9 @@ class SndObj {
protected:
- float* m_output; // output samples
+ double* m_output; // output samples
SndObj* m_input; // input object
- float m_sr; // sampling rate
+ double m_sr; // sampling rate
int m_vecsize; //vector size
int m_vecpos; // vector pos counter
int m_vecsize_max; // for limiting operation
@@ -72,9 +72,9 @@ class SndObj {
void AddMsg(const char* mess, int ID);
#if defined (WIN) && !defined(GCC)
- int Ftoi(float x){
+ int Ftoi(double x){
union {
- float f;
+ double f;
int i;
} u;
unsigned int tmp;
@@ -107,8 +107,8 @@ class SndObj {
return temp;
}
#else
- int Ftoi(float fval) { return (int) fval; }
int Ftoi(double fval) { return (int) fval; }
+ int Ftoi(float fval) { return (int) fval; }
#endif
public:
@@ -142,17 +142,17 @@ class SndObj {
return *this;
}
- SndObj& operator+=(float val){
+ SndObj& operator+=(double val){
for(int n = 0; n < m_vecsize; n++) m_output[n] = m_output[n]+val;
return *this;
}
- SndObj& operator-=(float val){
+ SndObj& operator-=(double val){
for(int n = 0; n < m_vecsize; n++) m_output[n] = m_output[n]-val;
return *this;
}
- SndObj& operator*=(float val){
+ SndObj& operator*=(double val){
for(int n = 0; n < m_vecsize; n++) m_output[n] = m_output[n]*val;
return *this;
}
@@ -175,30 +175,30 @@ class SndObj {
return temp;
}
- SndObj operator+(float val){
+ SndObj operator+(double val){
SndObj temp(0, m_vecsize, m_sr);
for(int n = 0; n < m_vecsize; n++) temp.m_output[n] = m_output[n]+val;
return temp;
}
- SndObj operator-(float val){
+ SndObj operator-(double val){
SndObj temp(0, m_vecsize, m_sr);
for(int n = 0; n < m_vecsize; n++) temp.m_output[n] = m_output[n]-val;
return temp;
}
- SndObj operator*(float val){
+ SndObj operator*(double val){
SndObj temp(0, m_vecsize, m_sr);
for(int n = 0; n < m_vecsize; n++) temp.m_output[n] = m_output[n]*val;
return temp;
}
- void operator<<(float val){
+ void operator<<(double val){
if(m_vecpos >= m_vecsize) m_vecpos=0;
m_output[m_vecpos++] = val;
}
- void operator<<(float* vector){
+ void operator<<(double* vector){
for(m_vecpos=0;m_vecpos<m_vecsize;m_vecpos++)
m_output[m_vecpos] = vector[m_vecpos];
}
@@ -208,7 +208,7 @@ class SndObj {
#endif
- int PushIn(float *in_vector, int size){
+ int PushIn(double *in_vector, int size){
for(int i = 0; i<size; i++){
if(m_vecpos >= m_vecsize) m_vecpos = 0;
m_output[m_vecpos++] = in_vector[i];
@@ -216,7 +216,7 @@ class SndObj {
return m_vecpos;
}
- int PopOut(float *out_vector, int size){
+ int PopOut(double *out_vector, int size){
for(int i = 0; i<size; i++){
if(m_altvecpos >= m_vecsize) m_altvecpos = 0;
out_vector[i] = m_output[m_altvecpos++];
@@ -225,7 +225,7 @@ class SndObj {
}
- int AddOut(float *vector, int size){
+ int AddOut(double *vector, int size){
for(int i = 0; i<size; i++){
if(m_altvecpos >= m_vecsize) m_altvecpos = 0;
vector[i] += m_output[m_altvecpos++];
@@ -237,7 +237,7 @@ class SndObj {
void GetMsgList(string* list);
void Enable(){ m_enable = 1; }
void Disable(){ m_enable = 0; }
- virtual float Output(int pos){ return m_output[pos%m_vecsize];}
+ virtual double Output(int pos){ return m_output[pos%m_vecsize];}
int GetVectorSize() { return m_vecsize; }
void SetVectorSize(int vecsize);
@@ -246,9 +246,9 @@ class SndObj {
m_vecsize = limit;
}
void RestoreVectorSize(){ m_vecsize = m_vecsize_max; }
- float GetSr(){ return m_sr;}
- virtual void SetSr(float sr){ m_sr = sr;}
- virtual int Set(char* mess, float value);
+ double GetSr(){ return m_sr;}
+ virtual void SetSr(double sr){ m_sr = sr;}
+ virtual int Set(char* mess, double value);
virtual int Connect(char* mess, void* input);
@@ -258,7 +258,7 @@ class SndObj {
SndObj* GetInput(){ return m_input; }
- SndObj(SndObj* input, int vecsize = DEF_VECSIZE, float sr = DEF_SR);
+ SndObj(SndObj* input, int vecsize = DEF_VECSIZE, double sr = DEF_SR);
SndObj();
#if !defined (SWIGPYTHON) && !defined(SWIGCFFI)
SndObj(SndObj& obj);
diff --git a/sndobj/Table.h b/sndobj/Table.h
index 6f0bede..f20a2bd 100644
--- a/sndobj/Table.h
+++ b/sndobj/Table.h
@@ -35,7 +35,7 @@ class Table {
protected:
long m_L; // size;
- float* m_table; // table
+ double* m_table; // table
int m_error; // error code
void ZeroTable ()
{
@@ -47,8 +47,8 @@ class Table {
public:
long GetLen() { return m_L; }
- float* GetTable(){ return m_table; }
- float Lookup(int pos){
+ double* GetTable(){ return m_table; }
+ double Lookup(int pos){
return m_table[pos%m_L];
}
diff --git a/sndobj/rfftw/fftw.h b/sndobj/rfftw/fftw.h
index 92d04e9..41af839 100644
--- a/sndobj/rfftw/fftw.h
+++ b/sndobj/rfftw/fftw.h
@@ -37,7 +37,7 @@ extern "C" {
* flag directly
*/
/* #undef FFTW_ENABLE_FLOAT*/
-#define FFTW_ENABLE_FLOAT
+//#define FFTW_ENABLE_FLOAT
/* our real numbers */
#ifdef FFTW_ENABLE_FLOAT
diff --git a/sndobj/sndobj.i b/sndobj/sndobj.i
index bfec06a..413e7ae 100644
--- a/sndobj/sndobj.i
+++ b/sndobj/sndobj.i
@@ -30,11 +30,11 @@
%ignore SndObj::SndObj(SndObj &);
%ignore SndObj::operator=(SndObj);
-%apply(float* IN_ARRAY1, int DIM1) {(float* in_vector, int size)};
-%apply(float* INPLACE_ARRAY1, int DIM1) {(float* out_vector, int size)};
+%apply(double* IN_ARRAY1, int DIM1) {(double* in_vector, int size)};
+%apply(double* INPLACE_ARRAY1, int DIM1) {(double* out_vector, int size)};
%include "SndObj.h"
-%clear(float* in_vector, int size);
-%clear(float* out_vector, int size);
+%clear(double* in_vector, int size);
+%clear(double* out_vector, int size);
%include "SndIO.h"
%include "Table.h"
@@ -44,11 +44,11 @@
%include "PVS.h"
%include "IFGram.h"
-%apply (int DIM1, float* IN_ARRAY1)
+%apply (int DIM1, double* IN_ARRAY1)
{
- (int numamps, float* amps),
- (int numfreqs, float* freqs),
- (int numphases, float* phases)
+ (int numamps, double* amps),
+ (int numfreqs, double* freqs),
+ (int numphases, double* phases)
}
%include "SinAnal.h"
%include "SinSyn.h"
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-05 21:17:47 +0000