Udhay wrote:
How to get the frequency of an audio file and how to separate the low
and high frequency of an audio file
Look at "Discrete Fourier Transform" and the implementations of a "Fast
Fourier Transform".
Here is some code I toyed with - I lifted it from somewhere, I don't
know exactly where and then I templateized it a little.
The FFT is done in the complex number space.... You could also look up
the DCT (discrete cosine transform) which I think operates in the real
number space but it's not as accurate - I really don't know much about
DCT's.
#define PI 3.1415926535897932384626
inline long revbin_update(long r,long n)
{
do {
n=n>>1;
r=r^n;
} while ((r&n)==0);
return r;
}
template <typename TranType>
inline void revbin_permute(TranType *a,long n)
{
if (n<=2) return;
long r=0;
for (long x=1; x<n; x++)
{
r=revbin_update(r,n);
if (r>x) swap(a[x],a[r]);
}
}
template <typename TranType>
TranType omega(double theta)
{ return TranType(cos(theta),sin(theta)); }
template <int is, typename TranType>
void fft(TranType *a, long ldn)
// O(N log N)
//
// a[] is the TranType input data set, lsb in 0 and msb in N
// ldn is the power of 2 which contains the entire data set, try to
// align the data to a power of 2 by padding with zeroes.
// is is the direction of the transform, +1 = forward, -1 = backward
//
// result is a[]
{
long n=1 << ldn;
revbin_permute(a,n);
for (long ldm=1; ldm<=ldn; ldm++)
{
long m=1 << ldm;
long mh=m/2;
for (long j=0; j<mh; j++)
{
TranType e=omega<TranType>(is*2*PI*j/m);
for (long r=0; r<=n-m; r+=m)
{
TranType u=a[r+j];
TranType v=a[r+j+mh]*e;
a[r+j]=(u+v);
a[r+j+mh]=(u-v);
}
}
}
}
template <typename TranType>
void fft_convolution(TranType *x,TranType *y, long n)
// x[], y[] are the two input TranType data sets.
// n is the power of 2 which contains the entire data set.
//
// result is y[]
{
long pw=1 << n;
fft<1>(x,n); // forward transform of x[]
fft<1>(y,n); // forward transfomr of y[]
for (int i=0; i<pw; i++)
y[i]=y[i]*x[i]; // element wise multiplication
fft<-1>(y,n); // backward transform of y[]
for (int i=0; i<pw; i++)
y[i]=y[i]/TranType(pw,0); // normalize
}
#include <complex>
/// example of use
int main()
{
static std::complex<double a[1<<21];
// revbin_permute( a, 1<<21 );
fft<1>( a, 21 );
}
