mirror of https://github.com/dcoredump/dexed.git
asb2m10
9 years ago
parent
39d3c28853
commit
b2517b47dd
File diff suppressed because it is too large
Load Diff
Binary file not shown.
@ -0,0 +1,277 @@ |
|||||||
|
/*
|
||||||
|
============================================================================== |
||||||
|
|
||||||
|
This file is part of the JUCE library. |
||||||
|
Copyright (c) 2015 - ROLI Ltd. |
||||||
|
|
||||||
|
Permission is granted to use this software under the terms of either: |
||||||
|
a) the GPL v2 (or any later version) |
||||||
|
b) the Affero GPL v3 |
||||||
|
|
||||||
|
Details of these licenses can be found at: www.gnu.org/licenses |
||||||
|
|
||||||
|
JUCE is distributed in the hope that it will be useful, but WITHOUT ANY |
||||||
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR |
||||||
|
A PARTICULAR PURPOSE. See the GNU General Public License for more details. |
||||||
|
|
||||||
|
------------------------------------------------------------------------------ |
||||||
|
|
||||||
|
To release a closed-source product which uses JUCE, commercial licenses are |
||||||
|
available: visit www.juce.com for more information. |
||||||
|
|
||||||
|
============================================================================== |
||||||
|
*/ |
||||||
|
|
||||||
|
// (For the moment, we'll implement a few local operators for this complex class - one
|
||||||
|
// day we'll probably either have a juce complex class, or use the C++11 one)
|
||||||
|
static FFT::Complex operator+ (FFT::Complex a, FFT::Complex b) noexcept { FFT::Complex c = { a.r + b.r, a.i + b.i }; return c; } |
||||||
|
static FFT::Complex operator- (FFT::Complex a, FFT::Complex b) noexcept { FFT::Complex c = { a.r - b.r, a.i - b.i }; return c; } |
||||||
|
static FFT::Complex operator* (FFT::Complex a, FFT::Complex b) noexcept { FFT::Complex c = { a.r * b.r - a.i * b.i, a.r * b.i + a.i * b.r }; return c; } |
||||||
|
static FFT::Complex& operator+= (FFT::Complex& a, FFT::Complex b) noexcept { a.r += b.r; a.i += b.i; return a; } |
||||||
|
|
||||||
|
//==============================================================================
|
||||||
|
struct FFT::FFTConfig |
||||||
|
{ |
||||||
|
FFTConfig (int sizeOfFFT, bool isInverse) |
||||||
|
: fftSize (sizeOfFFT), inverse (isInverse), twiddleTable ((size_t) sizeOfFFT) |
||||||
|
{ |
||||||
|
for (int i = 0; i < fftSize; ++i) |
||||||
|
{ |
||||||
|
const double phase = (isInverse ? 2.0 : -2.0) * double_Pi * i / fftSize; |
||||||
|
twiddleTable[i].r = (float) cos (phase); |
||||||
|
twiddleTable[i].i = (float) sin (phase); |
||||||
|
} |
||||||
|
|
||||||
|
const int root = (int) std::sqrt ((double) fftSize); |
||||||
|
int divisor = 4, n = fftSize; |
||||||
|
|
||||||
|
for (int i = 0; i < numElementsInArray (factors); ++i) |
||||||
|
{ |
||||||
|
while ((n % divisor) != 0) |
||||||
|
{ |
||||||
|
if (divisor == 2) divisor = 3; |
||||||
|
else if (divisor == 4) divisor = 2; |
||||||
|
else divisor += 2; |
||||||
|
|
||||||
|
if (divisor > root) |
||||||
|
divisor = n; |
||||||
|
} |
||||||
|
|
||||||
|
n /= divisor; |
||||||
|
|
||||||
|
jassert (divisor == 1 || divisor == 2 || divisor == 4); |
||||||
|
factors[i].radix = divisor; |
||||||
|
factors[i].length = n; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void perform (const Complex* input, Complex* output) const noexcept |
||||||
|
{ |
||||||
|
perform (input, output, 1, 1, factors); |
||||||
|
} |
||||||
|
|
||||||
|
const int fftSize; |
||||||
|
const bool inverse; |
||||||
|
|
||||||
|
struct Factor { int radix, length; }; |
||||||
|
Factor factors[32]; |
||||||
|
HeapBlock<Complex> twiddleTable; |
||||||
|
|
||||||
|
void perform (const Complex* input, Complex* output, const int stride, const int strideIn, const Factor* facs) const noexcept |
||||||
|
{ |
||||||
|
const Factor factor (*facs++); |
||||||
|
Complex* const originalOutput = output; |
||||||
|
const Complex* const outputEnd = output + factor.radix * factor.length; |
||||||
|
|
||||||
|
if (stride == 1 && factor.radix <= 5) |
||||||
|
{ |
||||||
|
for (int i = 0; i < factor.radix; ++i) |
||||||
|
perform (input + stride * strideIn * i, output + i * factor.length, stride * factor.radix, strideIn, facs); |
||||||
|
|
||||||
|
butterfly (factor, output, stride); |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
if (factor.length == 1) |
||||||
|
{ |
||||||
|
do |
||||||
|
{ |
||||||
|
*output++ = *input; |
||||||
|
input += stride * strideIn; |
||||||
|
} |
||||||
|
while (output < outputEnd); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
do |
||||||
|
{ |
||||||
|
perform (input, output, stride * factor.radix, strideIn, facs); |
||||||
|
input += stride * strideIn; |
||||||
|
output += factor.length; |
||||||
|
} |
||||||
|
while (output < outputEnd); |
||||||
|
} |
||||||
|
|
||||||
|
butterfly (factor, originalOutput, stride); |
||||||
|
} |
||||||
|
|
||||||
|
void butterfly (const Factor factor, Complex* data, const int stride) const noexcept |
||||||
|
{ |
||||||
|
switch (factor.radix) |
||||||
|
{ |
||||||
|
case 1: break; |
||||||
|
case 2: butterfly2 (data, stride, factor.length); return; |
||||||
|
case 4: butterfly4 (data, stride, factor.length); return; |
||||||
|
default: jassertfalse; break; |
||||||
|
} |
||||||
|
|
||||||
|
Complex* scratch = static_cast<Complex*> (alloca (sizeof (Complex) * (size_t) factor.radix)); |
||||||
|
|
||||||
|
for (int i = 0; i < factor.length; ++i) |
||||||
|
{ |
||||||
|
for (int k = i, q1 = 0; q1 < factor.radix; ++q1) |
||||||
|
{ |
||||||
|
scratch[q1] = data[k]; |
||||||
|
k += factor.length; |
||||||
|
} |
||||||
|
|
||||||
|
for (int k = i, q1 = 0; q1 < factor.radix; ++q1) |
||||||
|
{ |
||||||
|
int twiddleIndex = 0; |
||||||
|
data[k] = scratch[0]; |
||||||
|
|
||||||
|
for (int q = 1; q < factor.radix; ++q) |
||||||
|
{ |
||||||
|
twiddleIndex += stride * k; |
||||||
|
|
||||||
|
if (twiddleIndex >= fftSize) |
||||||
|
twiddleIndex -= fftSize; |
||||||
|
|
||||||
|
data[k] += scratch[q] * twiddleTable[twiddleIndex]; |
||||||
|
} |
||||||
|
|
||||||
|
k += factor.length; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void butterfly2 (Complex* data, const int stride, const int length) const noexcept |
||||||
|
{ |
||||||
|
Complex* dataEnd = data + length; |
||||||
|
const Complex* tw = twiddleTable; |
||||||
|
|
||||||
|
for (int i = length; --i >= 0;) |
||||||
|
{ |
||||||
|
const Complex s (*dataEnd * *tw); |
||||||
|
tw += stride; |
||||||
|
*dataEnd++ = *data - s; |
||||||
|
*data++ += s; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void butterfly4 (Complex* data, const int stride, const int length) const noexcept |
||||||
|
{ |
||||||
|
const int lengthX2 = length * 2; |
||||||
|
const int lengthX3 = length * 3; |
||||||
|
|
||||||
|
const Complex* twiddle1 = twiddleTable; |
||||||
|
const Complex* twiddle2 = twiddle1; |
||||||
|
const Complex* twiddle3 = twiddle1; |
||||||
|
|
||||||
|
for (int i = length; --i >= 0;) |
||||||
|
{ |
||||||
|
const Complex s0 = data[length] * *twiddle1; |
||||||
|
const Complex s1 = data[lengthX2] * *twiddle2; |
||||||
|
const Complex s2 = data[lengthX3] * *twiddle3; |
||||||
|
const Complex s3 = s0 + s2; |
||||||
|
const Complex s4 = s0 - s2; |
||||||
|
const Complex s5 = *data - s1; |
||||||
|
*data += s1; |
||||||
|
data[lengthX2] = *data - s3; |
||||||
|
twiddle1 += stride; |
||||||
|
twiddle2 += stride * 2; |
||||||
|
twiddle3 += stride * 3; |
||||||
|
*data += s3; |
||||||
|
|
||||||
|
if (inverse) |
||||||
|
{ |
||||||
|
data[length].r = s5.r - s4.i; |
||||||
|
data[length].i = s5.i + s4.r; |
||||||
|
data[lengthX3].r = s5.r + s4.i; |
||||||
|
data[lengthX3].i = s5.i - s4.r; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
data[length].r = s5.r + s4.i; |
||||||
|
data[length].i = s5.i - s4.r; |
||||||
|
data[lengthX3].r = s5.r - s4.i; |
||||||
|
data[lengthX3].i = s5.i + s4.r; |
||||||
|
} |
||||||
|
|
||||||
|
++data; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FFTConfig) |
||||||
|
}; |
||||||
|
|
||||||
|
|
||||||
|
//==============================================================================
|
||||||
|
FFT::FFT (int order, bool inverse) : config (new FFTConfig (1 << order, inverse)), size (1 << order) {} |
||||||
|
FFT::~FFT() {} |
||||||
|
|
||||||
|
void FFT::perform (const Complex* const input, Complex* const output) const noexcept |
||||||
|
{ |
||||||
|
config->perform (input, output); |
||||||
|
} |
||||||
|
|
||||||
|
void FFT::performRealOnlyForwardTransform (float* d) const noexcept |
||||||
|
{ |
||||||
|
// This can only be called on an FFT object that was created to do forward transforms.
|
||||||
|
jassert (! config->inverse); |
||||||
|
|
||||||
|
Complex* const scratch = static_cast<Complex*> (alloca (16 + sizeof (Complex) * (size_t) size)); |
||||||
|
|
||||||
|
for (int i = 0; i < size; ++i) |
||||||
|
{ |
||||||
|
scratch[i].r = d[i]; |
||||||
|
scratch[i].i = 0; |
||||||
|
} |
||||||
|
|
||||||
|
perform (scratch, reinterpret_cast<Complex*> (d)); |
||||||
|
} |
||||||
|
|
||||||
|
void FFT::performRealOnlyInverseTransform (float* d) const noexcept |
||||||
|
{ |
||||||
|
// This can only be called on an FFT object that was created to do inverse transforms.
|
||||||
|
jassert (config->inverse); |
||||||
|
|
||||||
|
Complex* const scratch = static_cast<Complex*> (alloca (16 + sizeof (Complex) * (size_t) size)); |
||||||
|
|
||||||
|
perform (reinterpret_cast<const Complex*> (d), scratch); |
||||||
|
|
||||||
|
const float scaleFactor = 1.0f / size; |
||||||
|
|
||||||
|
for (int i = 0; i < size; ++i) |
||||||
|
{ |
||||||
|
d[i] = scratch[i].r * scaleFactor; |
||||||
|
d[i + size] = scratch[i].i * scaleFactor; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void FFT::performFrequencyOnlyForwardTransform (float* d) const noexcept |
||||||
|
{ |
||||||
|
performRealOnlyForwardTransform (d); |
||||||
|
const int twiceSize = size * 2; |
||||||
|
|
||||||
|
for (int i = 0; i < twiceSize; i += 2) |
||||||
|
{ |
||||||
|
d[i / 2] = juce_hypot (d[i], d[i + 1]); |
||||||
|
|
||||||
|
if (i >= size) |
||||||
|
{ |
||||||
|
d[i] = 0; |
||||||
|
d[i + 1] = 0; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,92 @@ |
|||||||
|
/*
|
||||||
|
============================================================================== |
||||||
|
|
||||||
|
This file is part of the JUCE library. |
||||||
|
Copyright (c) 2015 - ROLI Ltd. |
||||||
|
|
||||||
|
Permission is granted to use this software under the terms of either: |
||||||
|
a) the GPL v2 (or any later version) |
||||||
|
b) the Affero GPL v3 |
||||||
|
|
||||||
|
Details of these licenses can be found at: www.gnu.org/licenses |
||||||
|
|
||||||
|
JUCE is distributed in the hope that it will be useful, but WITHOUT ANY |
||||||
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR |
||||||
|
A PARTICULAR PURPOSE. See the GNU General Public License for more details. |
||||||
|
|
||||||
|
------------------------------------------------------------------------------ |
||||||
|
|
||||||
|
To release a closed-source product which uses JUCE, commercial licenses are |
||||||
|
available: visit www.juce.com for more information. |
||||||
|
|
||||||
|
============================================================================== |
||||||
|
*/ |
||||||
|
|
||||||
|
/**
|
||||||
|
A very minimal FFT class. |
||||||
|
|
||||||
|
This is only a simple low-footprint implementation and isn't tuned for speed - it may |
||||||
|
be useful for simple applications where one of the more complex FFT libraries would be |
||||||
|
overkill. (But in the future it may end up becoming optimised of course...) |
||||||
|
|
||||||
|
The FFT class itself contains lookup tables, so there's some overhead in creating |
||||||
|
one, you should create and cache an FFT object for each size/direction of transform |
||||||
|
that you need, and re-use them to perform the actual operation. |
||||||
|
*/ |
||||||
|
class JUCE_API FFT |
||||||
|
{ |
||||||
|
public: |
||||||
|
/** Initialises an object for performing either a forward or inverse FFT with the given size.
|
||||||
|
The the number of points the FFT will operate on will be 2 ^ order. |
||||||
|
*/ |
||||||
|
FFT (int order, bool isInverse); |
||||||
|
|
||||||
|
/** Destructor. */ |
||||||
|
~FFT(); |
||||||
|
|
||||||
|
/** A complex number, for the purposes of the FFT class. */ |
||||||
|
struct Complex |
||||||
|
{ |
||||||
|
float r; /**< Real part. */ |
||||||
|
float i; /**< Imaginary part. */ |
||||||
|
}; |
||||||
|
|
||||||
|
/** Performs an out-of-place FFT, either forward or inverse depending on the mode
|
||||||
|
that was passed to this object's constructor. |
||||||
|
|
||||||
|
The arrays must contain at least getSize() elements. |
||||||
|
*/ |
||||||
|
void perform (const Complex* input, Complex* output) const noexcept; |
||||||
|
|
||||||
|
/** Performs an in-place forward transform on a block of real data.
|
||||||
|
|
||||||
|
The size of the array passed in must be 2 * getSize(), and the first half |
||||||
|
should contain your raw input sample data. On return, the array will contain |
||||||
|
complex frequency + phase data, and can be passed to performRealOnlyInverseTransform() |
||||||
|
in order to convert it back to reals. |
||||||
|
*/ |
||||||
|
void performRealOnlyForwardTransform (float* inputOutputData) const noexcept; |
||||||
|
|
||||||
|
/** Performs a reverse operation to data created in performRealOnlyForwardTransform().
|
||||||
|
|
||||||
|
The size of the array passed in must be 2 * getSize(), containing complex |
||||||
|
frequency and phase data. On return, the first half of the array will contain |
||||||
|
the reconstituted samples. |
||||||
|
*/ |
||||||
|
void performRealOnlyInverseTransform (float* inputOutputData) const noexcept; |
||||||
|
|
||||||
|
/** Takes an array and simply transforms it to the frequency spectrum.
|
||||||
|
This may be handy for things like frequency displays or analysis. |
||||||
|
*/ |
||||||
|
void performFrequencyOnlyForwardTransform (float* inputOutputData) const noexcept; |
||||||
|
|
||||||
|
/** Returns the number of data points that this FFT was created to work with. */ |
||||||
|
int getSize() const noexcept { return size; } |
||||||
|
|
||||||
|
private: |
||||||
|
struct FFTConfig; |
||||||
|
ScopedPointer<FFTConfig> config; |
||||||
|
const int size; |
||||||
|
|
||||||
|
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FFT) |
||||||
|
}; |
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue