mirror/musikcube
1
0
Fork 0
mirror of https://github.com/clangen/musikcube.git synced 2024-10-02 04:52:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replaced VLC/xmms FFT with the one used by Milkdrop.

Browse Source
This commit is contained in:
casey langen 2016-11-28 00:20:15 -08:00
parent ed1fd578e5
commit d14fc89721
7 changed files with 378 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
src/3rdparty/include/fft.h vendored
View File

@ -1,53 +1,60 @@
/***************************************************************************** /*
* fft.h: Headers for iterative implementation of a FFT LICENSE
***************************************************************************** -------
* $Id$ Copyright 2005-2013 Nullsoft, Inc.
* All rights reserved.
* Mainly taken from XMMS's code
* Redistribution and use in source and binary forms, with or without modification,
* Authors: Richard Boulton <richard@tartarus.org> are permitted provided that the following conditions are met:
*
* This program is free software; you can redistribute it and/or modify * Redistributions of source code must retain the above copyright notice,
* it under the terms of the GNU General Public License as published by this list of conditions and the following disclaimer.
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* This program is distributed in the hope that it will be useful, and/or other materials provided with the distribution.
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * Neither the name of Nullsoft nor the names of its contributors may be used to
* GNU General Public License for more details. endorse or promote products derived from this software without specific prior written permission.
*
* You should have received a copy of the GNU General Public License THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* along with this program; if not, write to the Free Software IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
*****************************************************************************/ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once #pragma once
#define FFT_BUFFER_SIZE_LOG 9 #define FFT_BUFFER_SIZE 512
#define FFT_BUFFER_SIZE (1 << FFT_BUFFER_SIZE_LOG)
extern "C" { class FFT {
/* sound sample - should be an signed 16 bit value */ public:
typedef float sound_sample; FFT();
struct _struct_fft_state { ~FFT();
/* Temporary data stores to perform FFT in. */ void Init(int samplesIn, int samplesOut, int equalize = 1, float envelopePower = 1.0f);
float real[FFT_BUFFER_SIZE]; void TimeToFrequencyDomain(float *in, float *out);
float imag[FFT_BUFFER_SIZE];
/* */ private:
unsigned int bitReverse[FFT_BUFFER_SIZE]; void CleanUp();
/* The next two tables could be made to use less space in memory, since they int ready;
* overlap hugely, but hey. */ int samplesIn;
float sintable[FFT_BUFFER_SIZE / 2]; int NFREQ;
float costable[FFT_BUFFER_SIZE / 2];
};
/* FFT prototypes */ void InitEnvelopeTable(float power);
typedef struct _struct_fft_state fft_state; void InitEqualizeTable();
fft_state *visual_fft_init(void); void InitBitRevTable();
void fft_perform(const sound_sample *input, float *output, fft_state *state); void InitCosSinTable();
void fft_close(fft_state *state);
} int *bitrevtable;
float *envelope;
float *equalize;
float *temp1;
float *temp2;
float(*cossintable)[2];
};

452
src/3rdparty/src/fft.cpp vendored
View File

@ -1,211 +1,295 @@
/***************************************************************************** /*
* fft.c: Iterative implementation of a FFT LICENSE
***************************************************************************** -------
* $Id$ Copyright 2005-2013 Nullsoft, Inc.
* All rights reserved.
* Mainly taken from XMMS's code
*
* Authors: Richard Boulton <richard@tartarus.org>
* Ralph Loader <suckfish@ihug.co.nz>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#include <stdlib.h> Redistribution and use in source and binary forms, with or without modification,
#include <fft.h> are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of Nullsoft nor the names of its contributors may be used to
endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <math.h> #include <math.h>
#ifndef PI #include <memory.h>
#ifdef M_PI #include <fft.h>
#define PI M_PI
#else
#define PI 3.14159265358979323846 /* pi */
#endif
#endif
#define MAX_SIGNED_SHORT 32767 #define PI 3.141592653589793238462643383279502884197169399f
/****************************************************************************** #define SafeDeleteArray(x) { if (x) { delete [] x; x = 0; } }
* Local prototypes
*****************************************************************************/
static void fft_prepare(const sound_sample *input, float * re, float * im,
const unsigned int *bitReverse);
static void fft_calculate(float * re, float * im,
const float *costable, const float *sintable );
static void fft_output(const float *re, const float *im, float *output);
static int reverseBits(unsigned int initial);
/***************************************************************************** FFT::FFT() {
* These functions are the ones called externally NFREQ = 0;
*****************************************************************************/ envelope = 0;
equalize = 0;
bitrevtable = 0;
cossintable = 0;
temp1 = 0;
temp2 = 0;
}
/* FFT::~FFT() {
* Initialisation routine - sets up tables and space to work in. CleanUp();
* Returns a pointer to internal state, to be used when performing calls. }
* On error, returns NULL.
* The pointer should be freed when it is finished with, by fft_close(). void FFT::Init(int samplesIn, int samplesOut, int equalize, float envelopePower) {
*/ // samples_in: # of waveform samples you'll feed into the FFT
extern fft_state *visual_fft_init(void) // samples_out: # of frequency samples you want out; MUST BE A POWER OF 2.
// bEqualize: set to 1 if you want the magnitude of the basses and trebles
// to be roughly equalized; 0 to leave them untouched.
// envelope_power: set to -1 to disable the envelope; otherwise, specify
// the envelope power you want here. See InitEnvelopeTable for more info.
CleanUp();
this->samplesIn = samplesIn;
NFREQ = samplesOut * 2;
InitBitRevTable();
InitCosSinTable();
if (envelopePower > 0) {
InitEnvelopeTable(envelopePower);
}
if (equalize) {
InitEqualizeTable();
}
temp1 = new float[NFREQ];
temp2 = new float[NFREQ];
}
void FFT::CleanUp() {
SafeDeleteArray(envelope);
SafeDeleteArray(equalize);
SafeDeleteArray(bitrevtable);
SafeDeleteArray(cossintable);
SafeDeleteArray(temp1);
SafeDeleteArray(temp2);
}
void FFT::InitEqualizeTable() {
int i;
float scaling = -0.02f;
float inv_half_nfreq = 1.0f / (float)(NFREQ / 2);
equalize = new float[NFREQ / 2];
for (i = 0; i < NFREQ / 2; i++) {
equalize[i] = scaling * logf((float)(NFREQ / 2 - i) * inv_half_nfreq);
}
}
void FFT::InitEnvelopeTable(float power)
{ {
fft_state *p_state; // this precomputation is for multiplying the waveform sample
unsigned int i; // by a bell-curve-shaped envelope, so we don't see the ugly
// frequency response (oscillations) of a square filter.
p_state = (fft_state*) malloc( sizeof(*p_state) ); // a power of 1.0 will compute the FFT with exactly one convolution.
if(! p_state ) // a power of 2.0 is like doing it twice; the resulting frequency
return NULL; // output will be smoothed out and the peaks will be "fatter".
// a power of 0.5 is closer to not using an envelope, and you start
// to get the frequency response of the square filter as 'power'
// approaches zero; the peaks get tighter and more precise, but
// you also see small oscillations around their bases.
for(i = 0; i < FFT_BUFFER_SIZE; i++) int i;
{ float mult = 1.0f / (float) this->samplesIn * 6.2831853f;
p_state->bitReverse[i] = reverseBits(i);
envelope = new float[this->samplesIn];
if (power == 1.0f) {
for (i = 0; i < this->samplesIn; i++) {
envelope[i] = 0.5f + 0.5f*sinf(i * mult - 1.5707963268f);
}
} }
for(i = 0; i < FFT_BUFFER_SIZE / 2; i++) else {
{ for (i = 0; i < this->samplesIn; i++) {
float j = 2 * PI * i / FFT_BUFFER_SIZE; envelope[i] = powf(0.5f + 0.5f * sinf(i * mult - 1.5707963268f), power);
p_state->costable[i] = cos(j); }
p_state->sintable[i] = sin(j);
}
return p_state;
}
/*
* Do all the steps of the FFT, taking as input sound data (as described in
* sound.h) and returning the intensities of each frequency as floats in the
* range 0 to ((FFT_BUFFER_SIZE / 2) * 32768) ^ 2
*
* The input array is assumed to have FFT_BUFFER_SIZE elements,
* and the output array is assumed to have (FFT_BUFFER_SIZE / 2 + 1) elements.
* state is a (non-NULL) pointer returned by visual_fft_init.
*/
extern void fft_perform(const sound_sample *input, float *output, fft_state *state) {
/* Convert data from sound format to be ready for FFT */
fft_prepare(input, state->real, state->imag, state->bitReverse );
/* Do the actual FFT */
fft_calculate(state->real, state->imag, state->costable, state->sintable);
/* Convert the FFT output into intensities */
fft_output(state->real, state->imag, output);
}
/*
* Free the state.
*/
extern void fft_close(fft_state *state) {
free( state );
}
/*****************************************************************************
* These functions are called from the other ones
*****************************************************************************/
/*
* Prepare data to perform an FFT on
*/
static void fft_prepare( const sound_sample *input, float * re, float * im,
const unsigned int *bitReverse ) {
unsigned int i;
float *p_real = re;
float *p_imag = im;
short v;
/* Get input, in reverse bit order */
for(i = 0; i < FFT_BUFFER_SIZE; i++)
{
*p_real++ = (input[bitReverse[i]] * MAX_SIGNED_SHORT * 2) - MAX_SIGNED_SHORT;
*p_imag++ = 0;
} }
} }
/* void FFT::InitBitRevTable() {
* Take result of an FFT and calculate the intensities of each frequency int i, j, m, temp;
* Note: only produces half as many data points as the input had. bitrevtable = new int[NFREQ];
*/
static void fft_output(const float * re, const float * im, float *output)
{
float *p_output = output;
const float *p_real = re;
const float *p_imag = im;
float *p_end = output + (FFT_BUFFER_SIZE / 2) - 1;
while(p_output <= p_end) for (i = 0; i < NFREQ; i++) {
{ bitrevtable[i] = i;
*p_output = (*p_real * *p_real) + (*p_imag * *p_imag);
p_output++; p_real++; p_imag++;
} }
/* Do divisions to keep the constant and highest frequency terms in scale for (i = 0, j = 0; i < NFREQ; i++) {
* with the other terms. */ if (j > i) {
*output /= 4; temp = bitrevtable[i];
*p_end /= 4; bitrevtable[i] = bitrevtable[j];
bitrevtable[j] = temp;
}
m = NFREQ >> 1;
while (m >= 1 && j >= m) {
j -= m;
m >>= 1;
}
j += m;
}
} }
void FFT::InitCosSinTable() {
int i, dftsize, tabsize;
float theta;
/* dftsize = 2;
* Actually perform the FFT tabsize = 0;
*/ while (dftsize <= NFREQ) {
static void fft_calculate(float * re, float * im, const float *costable, const float *sintable ) tabsize++;
{ dftsize <<= 1;
unsigned int i, j, k; }
unsigned int exchanges;
float fact_real, fact_imag;
float tmp_real, tmp_imag;
unsigned int factfact;
/* Set up some variables to reduce calculation in the loops */ cossintable = new float[tabsize][2];
exchanges = 1;
factfact = FFT_BUFFER_SIZE / 2;
/* Loop through the divide and conquer steps */ dftsize = 2;
for(i = FFT_BUFFER_SIZE_LOG; i != 0; i--) { i = 0;
/* In this step, we have 2 ^ (i - 1) exchange groups, each with while (dftsize <= NFREQ) {
* 2 ^ (FFT_BUFFER_SIZE_LOG - i) exchanges theta = (float)(-2.0f*PI / (float)dftsize);
*/ cossintable[i][0] = (float)cosf(theta);
/* Loop through the exchanges in a group */ cossintable[i][1] = (float)sinf(theta);
for(j = 0; j != exchanges; j++) { i++;
/* Work out factor for this exchange dftsize <<= 1;
* factor ^ (exchanges) = -1 }
* So, real = cos(j * PI / exchanges), }
* imag = sin(j * PI / exchanges)
*/
fact_real = costable[j * factfact];
fact_imag = sintable[j * factfact];
/* Loop through all the exchange groups */ void FFT::TimeToFrequencyDomain(float *in, float *out) {
for(k = j; k < FFT_BUFFER_SIZE; k += exchanges << 1) { // Converts time-domain samples from in_wavedata[]
int k1 = k + exchanges; // into frequency-domain samples in out_spectraldata[].
tmp_real = fact_real * re[k1] - fact_imag * im[k1]; // The array lengths are the two parameters to Init().
tmp_imag = fact_real * im[k1] + fact_imag * re[k1];
re[k1] = re[k] - tmp_real; // The last sample of the output data will represent the frequency
im[k1] = im[k] - tmp_imag; // that is 1/4th of the input sampling rate. For example,
re[k] += tmp_real; // if the input wave data is sampled at 44,100 Hz, then the last
im[k] += tmp_imag; // sample of the spectral data output will represent the frequency
// 11,025 Hz. The first sample will be 0 Hz; the frequencies of
// the rest of the samples vary linearly in between.
// Note that since human hearing is limited to the range 200 - 20,000
// Hz. 200 is a low bass hum; 20,000 is an ear-piercing high shriek.
// Each time the frequency doubles, that sounds like going up an octave.
// That means that the difference between 200 and 300 Hz is FAR more
// than the difference between 5000 and 5100, for example!
// So, when trying to analyze bass, you'll want to look at (probably)
// the 200-800 Hz range; whereas for treble, you'll want the 1,400 -
// 11,025 Hz range.
// If you want to get 3 bands, try it this way:
// a) 11,025 / 200 = 55.125
// b) to get the number of octaves between 200 and 11,025 Hz, solve for n:
// 2^n = 55.125
// n = log 55.125 / log 2
// n = 5.785
// c) so each band should represent 5.785/3 = 1.928 octaves; the ranges are:
// 1) 200 - 200*2^1.928 or 200 - 761 Hz
// 2) 200*2^1.928 - 200*2^(1.928*2) or 761 - 2897 Hz
// 3) 200*2^(1.928*2) - 200*2^(1.928*3) or 2897 - 11025 Hz
// A simple sine-wave-based envelope is convolved with the waveform
// data before doing the FFT, to emeliorate the bad frequency response
// of a square (i.e. nonexistent) filter.
// You might want to slightly damp (blur) the input if your signal isn't
// of a very high quality, to reduce high-frequency noise that would
// otherwise show up in the output.
int j, m, i, dftsize, hdftsize, t;
float wr, wi, wpi, wpr, wtemp, tempr, tempi;
if (!bitrevtable) return;
if (!temp1) return;
if (!temp2) return;
if (!cossintable) return;
// 1. set up input to the fft
if (envelope) {
for (i = 0; i<NFREQ; i++) {
int idx = bitrevtable[i];
if (idx < this->samplesIn) {
temp1[i] = in[idx] * envelope[idx];
}
else {
temp1[i] = 0;
} }
} }
exchanges <<= 1; }
factfact >>= 1; else {
for (i = 0; i<NFREQ; i++) {
int idx = bitrevtable[i];
if (idx < this->samplesIn) {
temp1[i] = in[idx];// * envelope[idx];
}
else {
temp1[i] = 0;
}
}
}
memset(temp2, 0, sizeof(float) * NFREQ);
// 2. perform FFT
float *real = temp1;
float *imag = temp2;
dftsize = 2;
t = 0;
while (dftsize <= NFREQ) {
wpr = cossintable[t][0];
wpi = cossintable[t][1];
wr = 1.0f;
wi = 0.0f;
hdftsize = dftsize >> 1;
for (m = 0; m < hdftsize; m += 1) {
for (i = m; i < NFREQ; i += dftsize) {
j = i + hdftsize;
tempr = wr*real[j] - wi*imag[j];
tempi = wr*imag[j] + wi*real[j];
real[j] = real[i] - tempr;
imag[j] = imag[i] - tempi;
real[i] += tempr;
imag[i] += tempi;
}
wr = (wtemp = wr)*wpr - wi*wpi;
wi = wi*wpr + wtemp*wpi;
}
dftsize <<= 1;
t++;
}
// 3. take the magnitude & equalize it (on a log10 scale) for output
if (equalize) {
for (i = 0; i < NFREQ / 2; i++) {
out[i] = equalize[i] * sqrtf(temp1[i] * temp1[i] + temp2[i] * temp2[i]);
}
}
else {
for (i = 0; i < NFREQ / 2; i++) {
out[i] = sqrtf(temp1[i] * temp1[i] + temp2[i] * temp2[i]);
}
} }
} }
static int reverseBits(unsigned int initial)
{
unsigned int reversed = 0, loop;
for(loop = 0; loop < FFT_BUFFER_SIZE_LOG; loop++) {
reversed <<= 1;
reversed += (initial & 1);
initial >>= 1;
}
return reversed;
}

47
src/core/audio/Buffer.cpp
View File

@ -165,51 +165,4 @@ void Buffer::Append(float* src, long samples) {
} }
this->sampleSize = newBufferSize; this->sampleSize = newBufferSize;
}
bool Buffer::Fft(float* output, int outputSize) {
if (this->sampleSize / this->channels < FFT_BUFFER_SIZE ||
outputSize != FFT_BUFFER_SIZE / 2)
{
return false;
}
int count = this->sampleSize / FFT_BUFFER_SIZE;
/* de-interleave the audio first */
float* deinterleaved = new float[FFT_BUFFER_SIZE * count];
for (int i = 0; i < count * FFT_BUFFER_SIZE; i++) {
const int to = ((i % this->channels) * FFT_BUFFER_SIZE) + (i / count);
deinterleaved[to] = this->buffer[i];
}
/* if there's more than one set of interleaved data then
allocate a scratch buffer. we'll use this for averaging
the result */
float* scratch = nullptr;
if (count > 1) {
scratch = new float[outputSize];
}
fft_state* state = visual_fft_init();
/* first FFT will go directly to the output buffer */
fft_perform(this->buffer, output, state);
for (int i = 1; i < count; i++) {
fft_perform(deinterleaved + (i * FFT_BUFFER_SIZE), scratch, state);
/* average with the previous read */
for (int j = 0; j < outputSize; j++) {
output[j] = (scratch[j] + output[j]) / 2;
}
}
delete[] deinterleaved;
delete[] scratch;
fft_close(state);
return true;
} }

1
src/core/audio/Buffer.h
View File

@ -64,7 +64,6 @@ namespace musik { namespace core { namespace audio {
virtual void SetSamples(long samples); virtual void SetSamples(long samples);
virtual long Bytes() const; virtual long Bytes() const;
virtual double Position() const; virtual double Position() const;
virtual bool Fft(float* buffer, int size);
void SetPosition(double position); void SetPosition(double position);
void Copy(float* buffer, long samples); void Copy(float* buffer, long samples);

58
src/core/audio/Player.cpp
View File

@ -81,6 +81,8 @@ Player::Player(const std::string &url, OutputPtr output)
, setPosition(-1) { , setPosition(-1) {
musik::debug::info(TAG, "new instance created"); musik::debug::info(TAG, "new instance created");
fft.Init(FFT_BUFFER_SIZE, FFT_OUTPUT_SIZE);
this->spectrum = new float[FFT_OUTPUT_SIZE]; this->spectrum = new float[FFT_OUTPUT_SIZE];
/* we allow callers to specify an output device; but if they don't, /* we allow callers to specify an output device; but if they don't,
@ -314,12 +316,62 @@ bool Player::Exited() {
return (this->state == Player::Quit); return (this->state == Player::Quit);
} }
static inline void writeToVisualizer(IBuffer *buffer, float *spectrum) { static inline bool performFft(IBuffer* buffer, FFT& fft, float* output, int outputSize) {
long samples = buffer->Samples();
int channels = buffer->Channels();
if (samples / channels < FFT_BUFFER_SIZE ||
outputSize != FFT_BUFFER_SIZE / 2)
{
return false;
}
float* input = buffer->BufferPointer();
int count = samples / FFT_BUFFER_SIZE;
/* de-interleave the audio first */
float* deinterleaved = new float[FFT_BUFFER_SIZE * count];
for (int i = 0; i < count * FFT_BUFFER_SIZE; i++) {
const int to = ((i % channels) * FFT_BUFFER_SIZE) + (i / count);
deinterleaved[to] = input[i];
}
/* if there's more than one set of interleaved data then
allocate a scratch buffer. we'll use this for averaging
the result */
float* scratch = nullptr;
if (count > 1) {
scratch = new float[outputSize];
}
fft.Init(FFT_BUFFER_SIZE, outputSize);
/* first FFT will go directly to the output buffer */
fft.TimeToFrequencyDomain(input, output);
for (int i = 1; i < count; i++) {
fft.TimeToFrequencyDomain(deinterleaved + (i * FFT_BUFFER_SIZE), scratch);
/* average with the previous read */
for (int j = 0; j < outputSize; j++) {
output[j] = (scratch[j] + output[j]) / 2;
}
}
delete[] deinterleaved;
delete[] scratch;
return true;
}
static inline void writeToVisualizer(IBuffer *buffer, FFT& fft, float *spectrum) {
ISpectrumVisualizer* specVis = vis::SpectrumVisualizer(); ISpectrumVisualizer* specVis = vis::SpectrumVisualizer();
IPcmVisualizer* pcmVis = vis::PcmVisualizer(); IPcmVisualizer* pcmVis = vis::PcmVisualizer();
if (specVis && specVis->Visible()) { if (specVis && specVis->Visible()) {
if (buffer->Fft(spectrum, FFT_OUTPUT_SIZE)) { if (performFft(buffer, fft, spectrum, FFT_OUTPUT_SIZE)) {
vis::SpectrumVisualizer()->Write(spectrum, FFT_OUTPUT_SIZE); vis::SpectrumVisualizer()->Write(spectrum, FFT_OUTPUT_SIZE);
} }
} }
@ -332,7 +384,7 @@ void Player::OnBufferProcessed(IBuffer *buffer) {
bool started = false; bool started = false;
bool found = false; bool found = false;
writeToVisualizer(buffer, this->spectrum); writeToVisualizer(buffer, this->fft, this->spectrum);
{ {
boost::mutex::scoped_lock lock(this->queueMutex); boost::mutex::scoped_lock lock(this->queueMutex);

3
src/core/audio/Player.h
View File

@ -34,6 +34,7 @@
#pragma once #pragma once
#include <fft.h>
#include <core/config.h> #include <core/config.h>
#include <core/audio/IStream.h> #include <core/audio/IStream.h>
#include <core/sdk/IOutput.h> #include <core/sdk/IOutput.h>
@ -120,6 +121,8 @@ namespace musik { namespace core { namespace audio {
int state; int state;
bool notifiedStarted; bool notifiedStarted;
float* spectrum; float* spectrum;
FFT fft;
}; };
} } } } } }

1
src/core/sdk/IBuffer.h
View File

@ -48,7 +48,6 @@ namespace musik { namespace core { namespace sdk {
virtual long Samples() const = 0; virtual long Samples() const = 0;
virtual void SetSamples(long samples) = 0; virtual void SetSamples(long samples) = 0;
virtual long Bytes() const = 0; virtual long Bytes() const = 0;
virtual bool Fft(float* buffer, int size) = 0;
}; };
} } } } } }