Compare commits

...

5 Commits

Author SHA1 Message Date
Mark 58fd2821b5
Added test.cpp 2022-06-24 21:33:12 -07:00
Mark 2332e2980a
Added TODO 2022-06-24 21:32:28 -07:00
Mark bc1a6f3a85
Added FFT code 2022-06-24 21:28:03 -07:00
Mark 7655f1bdad
Fixed a bug 2022-06-24 21:27:49 -07:00
Mark 952d03ee10
Rearranged files 2022-06-24 21:07:30 -07:00
10 changed files with 519 additions and 5 deletions

View File

@ -0,0 +1,313 @@
#include "fft.hpp"
FFT_Visualizer::FFT_Visualizer(
size_t width,
size_t height,
// Advanced options. These have default values.
double HZ_MIN,
double HZ_MAX,
uint32_t DFT_TOTAL_SIZE,
uint32_t DFT_NONZERO_SIZE,
double GAIN
):
width(width),
height(height),
HZ_MIN(HZ_MIN),
HZ_MAX(HZ_MAX),
DFT_TOTAL_SIZE(DFT_TOTAL_SIZE),
DFT_NONZERO_SIZE(DFT_NONZERO_SIZE),
GAIN(GAIN),
DYNAMIC_RANGE(100 - GAIN)
{
fftw_results = DFT_TOTAL_SIZE/2 + 1;
freq_magnitudes.resize(fftw_results);
partial_output.reserve(width);
output.resize(width);
GenLogspace();
fftw_input = static_cast<double *>(fftw_malloc(sizeof(double)*DFT_TOTAL_SIZE));
fftw_output = static_cast<fftw_complex *>(fftw_malloc(sizeof(fftw_complex)*fftw_results));
memset(fftw_input, 0, sizeof(double)*DFT_TOTAL_SIZE);
plan = fftw_plan_dft_r2c_1d(
DFT_TOTAL_SIZE,
fftw_input,
fftw_output,
FFTW_ESTIMATE
);
}
FFT_Visualizer::~FFT_Visualizer() {
fftw_destroy_plan(plan);
fftw_free(fftw_input);
fftw_free(fftw_output);
}
/*
Returns ideal size for this visualizer's Buffer's output.
*/
size_t FFT_Visualizer::compute_buffer_output_size() const {
return DFT_NONZERO_SIZE;
}
// Generate log-scaled vector of frequencies from HZ_MIN to HZ_MAX.
void FFT_Visualizer::GenLogspace() {
// Prepare vector
logspace.resize(width);
// Calculate number of extra bins needed between 0 HZ and HZ_MIN
//
// In logspace, divide the region between MAX and MIN into
// `width - 1` equal segments (fenceposts; this gives us `width` seperators)
const double d = (
(log10(HZ_MAX) - log10(HZ_MIN))
/
(width - 1)
);
// Count how many of these segments will fit between
// 0 and MIN (note that we're still in logspace).
// This is how many log-scaled intervals are outside
// our desired range of frequencies.
const size_t skip_bins = log10(HZ_MIN) / d;
// Calculate log scale size.
// We can't use the value of d here, because d is "anchored" to both MIN and MAX.
// The last bin should be equal to MAX, but there may not be a bin that is equal to MIN.
//
// So, we re-partition our logspace:
// Divide the distance between 0 and MAX into equal partitions.
const double log_scale = log10(HZ_MAX) / (skip_bins + width - 1);
// Exponential-map bins out of logspace, skipping those that are outside our range.
// Note that the first (skipped) bin is ALWAYS 1, since 10^(0 * log_scale) = 1.
// The last bin ALWAYS equals MAX.
for (size_t i = skip_bins; i < width + skip_bins; ++i) {
logspace[i - skip_bins] = pow(10, i * log_scale);
}
}
/*
Apply the Blackman window and copy buffer data.
@param output Where to write output data
@param input Raw data from buffer
@param data_length How much data there is. The lengths
of both input and output must be equal to this value.
*/
void FFT_Visualizer::ApplyWindow(
double* output,
const int16_t* input,
ssize_t data_length
) const {
// samples = length of input = length of output
// Constants.
// These give us low sidelobes and fast sidelobe rolloff.
// https://en.wikipedia.org/wiki/Window_function#Blackman_window
//
// See also:
// https://en.wikipedia.org/wiki/Spectral_leakage
const double alpha = 0.16;
const double a0 = (1 - alpha) / 2;
const double a1 = 0.5;
const double a2 = alpha / 2;
const double pi = 3.151592653;
const double window_width = DFT_NONZERO_SIZE - 1;
for (unsigned i = 0; i < data_length; ++i) {
double window = (
a0 -
a1*cos(
2*pi*i /
window_width
) +
a2*cos(
4*pi*i /
window_width
)
);
// Output values are between 1 and -1.
output[i] = (window * input[i]) / INT16_MAX;
}
}
/*
Not sure what this does yet.
Takes values in [0, DFT_TOTAL_SIZE/2],
returns values in [0, 44100 / 2].
@param bin An index of `freq_magnitudes`
*/
double FFT_Visualizer::Bin2Hz(size_t bin) const {
return bin*44100/DFT_TOTAL_SIZE;
}
/*
Fill empty bins with interpolated data.
@param target_x The index of the bin we want to fill.
@param last_bar_idx The index of the last non-empty and non-interpolated bin.
*/
double FFT_Visualizer::Interpolate(
size_t target_x,
size_t last_bar_idx
) {
const double x_next = partial_output[last_bar_idx].first;
const double h_next = partial_output[last_bar_idx].second;
double dh = 0;
if (last_bar_idx == 0) {
// no data points on left, linear extrapolation
if (last_bar_idx < partial_output.size()-1) {
const double x_next2 = partial_output[last_bar_idx + 1].first;
const double h_next2 = partial_output[last_bar_idx + 1].second;
dh = (h_next2 - h_next) / (x_next2 - x_next);
}
return h_next - dh*(x_next - target_x);
} else if (last_bar_idx == 1) {
// one data point on left, linear interpolation
const double x_prev = partial_output[last_bar_idx - 1].first;
const double h_prev = partial_output[last_bar_idx - 1].second;
dh = (h_next - h_prev) / (x_next - x_prev);
return h_next - dh*(x_next - target_x);
} else if (last_bar_idx < partial_output.size() - 1) {
// Two data points on both sides, cubic interpolation
// https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Interpolation_on_an_arbitrary_interval
const double x_prev2 = partial_output[last_bar_idx - 2].first;
const double h_prev2 = partial_output[last_bar_idx - 2].second;
const double x_prev = partial_output[last_bar_idx - 1].first;
const double h_prev = partial_output[last_bar_idx - 1].second;
const double x_next2 = partial_output[last_bar_idx + 1].first;
const double h_next2 = partial_output[last_bar_idx + 1].second;
const double m0 = (h_prev - h_prev2) / (x_prev - x_prev2);
const double m1 = (h_next2 - h_next) / (x_next2 - x_next);
const double t = (target_x - x_prev) / (x_next - x_prev);
const double h00 = 2*t*t*t - 3*t*t + 1;
const double h10 = t*t*t - 2*t*t + t;
const double h01 = -2*t*t*t + 3*t*t;
const double h11 = t*t*t - t*t;
return h00*h_prev + h10*(x_next-x_prev)*m0 + h01*h_next + h11*(x_next-x_prev)*m1;
}
// Less than two data points on right, no interpolation.
// This should never happen unless you have a VERY low DFT size
return h_next;
}
/*
Read a buffer and update output array
*/
void FFT_Visualizer::update(
const Buffer& buf
) {
// Load data and execute FFT
ApplyWindow(fftw_input, buf.get_output().data(), buf.get_output().size());
fftw_execute(plan);
// Count magnitude of each frequency and normalize
// (fftw does not normalize)
for (size_t i = 0; i < fftw_results; ++i) {
freq_magnitudes[i] = sqrt(
fftw_output[i][0]*fftw_output[i][0]
+
fftw_output[i][1]*fftw_output[i][1]
) / (DFT_NONZERO_SIZE);
}
// Skip magnitudes not in log space
size_t cur_bin = 0;
while (cur_bin < fftw_results && Bin2Hz(cur_bin) < logspace[0]) {
++cur_bin;
}
partial_output.clear();
// Accumulate magnitudes into bins
for (size_t x = 0; x < width; x++) {
double bar_height = 0;
size_t count = 0;
// Check right bound
while (cur_bin < fftw_results && Bin2Hz(cur_bin) < logspace[x]) {
// Check left bound if not first index
if (x == 0 || Bin2Hz(cur_bin) >= logspace[x-1]) {
bar_height += freq_magnitudes[cur_bin];
++count;
}
++cur_bin;
}
// If bin is empty, we're done.
// Don't add this bin to partial_output,
// it will be interpolated later.
if (count == 0) {
continue;
}
// average bins
bar_height /= count;
// log scale heights
bar_height = (20 * log10(bar_height) + DYNAMIC_RANGE + GAIN) / DYNAMIC_RANGE;
// Scale bar height between 0 and height
bar_height = bar_height > 0 ? bar_height * (height-1) : 0;
bar_height = bar_height >= height ? (height-1) : bar_height;
// use emplace_back to prevent redundant copy operations.
// faster than push_back, in this case.
partial_output.emplace_back(x, bar_height);
}
size_t bar_idx = 0;
for (size_t x = 0; x < width; x++) {
const size_t bar_x = partial_output[bar_idx].first;
const double bar_height = partial_output[bar_idx].second;
if (x == bar_x) {
// This data point exists, add it to output array.
output[x] = (size_t) bar_height;
if (bar_idx < partial_output.size() - 1) {
bar_idx++;
}
} else {
// data point does not exist, we need to interpolate
// This check shouldn't be necessary, but sometimes
// Interpolate throws out a negative value.
//
// figure out why!
double i = Interpolate(x, bar_idx);
output[x] = (size_t) (i > 0 ? i : 0);
}
}
}

View File

@ -0,0 +1,121 @@
#pragma once
#include <stdio.h>
#include <cstdint>
#include <vector>
#include <math.h>
#include <cstring> // memset
#include <fftw3.h>
#include "utility/buffer.hpp"
class FFT_Visualizer {
public:
FFT_Visualizer(
size_t width,
size_t height,
// Advanced options you probably shouldn't touch
double HZ_MIN = 20,
double HZ_MAX = 20000,
uint32_t DFT_TOTAL_SIZE = 1 << 15,
// #define conf_spectrum_dft_size 2 (between 1 and 5, inclusive)
uint32_t DFT_NONZERO_SIZE = (2048 * (2*2 + 4)),
double GAIN = 10
);
~FFT_Visualizer();
void update(
const Buffer& buf
);
size_t compute_buffer_output_size() const;
const std::vector<size_t>& get_output() {
return output;
};
private:
///
// Visualizer parameters
///
// How many bars this visualizer will generate
const size_t width;
// Resolution of this visualizer's bars.
const size_t height;
// Leftmost frequency in spectrum
const double HZ_MIN;
// Rightmost frequency in spectrum
const double HZ_MAX;
// Not sure what this does
const uint32_t DFT_TOTAL_SIZE;
// Not sure what this does, either
const uint32_t DFT_NONZERO_SIZE;
// Visualization spectrum gain
// tune if bars are too small
const double GAIN;
// Not sure what this does
const double DYNAMIC_RANGE;
///
// FFTW resources
///
fftw_plan plan;
// How many output values fftw will give us
size_t fftw_results;
// Input array. This is filled with buffer data
// that has been filtered through a window.
double* fftw_input;
// FFT output array.
fftw_complex *fftw_output;
///
// Intermediate values
///
// The magnitudes of the complex values fftw returns.
std::vector<double> freq_magnitudes;
// An array of frequency bins, scaled logarithmically.
std::vector<double> logspace;
// Nearly-complete output.
// This is necessary because some frequency bins
// may be empty, and need to be interpolated
std::vector<
std::pair<
size_t,
double
>
> partial_output;
// Output vector, with empty bins interpolated.
// The maximum possible value of an element in this
// vector is `height`.
std::vector<size_t> output;
///
// Helper methods
// See definition for docs.
///
void GenLogspace();
double Bin2Hz(size_t bin) const;
void ApplyWindow(
double *output,
const int16_t *input,
ssize_t samples
) const;
double Interpolate(
size_t x,
size_t h_idx
);
};

View File

@ -4,8 +4,8 @@
#include <cstdint>
#include <vector>
#include "bitmap/bitmap.hpp"
#include "buffer/buffer.hpp"
#include "utility/bitmap.hpp"
#include "utility/buffer.hpp"
void waveform_generate(

78
src/test.cpp Normal file
View File

@ -0,0 +1,78 @@
#include <stdio.h>
#include <cstdint>
#include <vector>
// For reading FIFO
#include <fcntl.h>
#include <unistd.h>
// Math libs
#include <math.h>
#include <fftw3.h>
// Local files
#include "utility/bitmap.hpp"
#include "utility/buffer.hpp"
#include "signal_processing/fft.hpp"
// TODO:
// stereo support (and maybe different bitrates?)
// Optimization: don't copy filename in buffer?
// understand consumption rate
// understand BIN2HZ
// understand values and sizes (DFT_TOTAL, DFT_NONZERO, etc)
// note that wave and spectrum have different sizes
//
// MPD interface
// hid interface to keyboard
// beat detection
void draw_spectrum_bitmap(
const std::vector<size_t>& waveform,
Bitmap& bitmap
) {
for (size_t x = 0; x < waveform.size(); x++) {
for (size_t y = 0; y < waveform[x]; y++) {
bitmap.setpixel(bitmap.get_height() - y - 1, x, 0xFF, 0x00, 0x00);
}
}
}
const size_t width = 300;
const size_t height = 100;
int main(int argc, char *argv[]) {
// buffer size for waveform:
// (44100 / fps * 10), make 10 bigger for slower scrolling
//
// Double both buffer sizes if stereo
FFT_Visualizer fft = FFT_Visualizer(
width, height,
20, 20000
);
std::vector<size_t> waveform;
waveform.resize(width);
Buffer buf = Buffer(
"/tmp/mpd.fifo",
44100 / 2, // Keep 500ms of data in buffer
fft.compute_buffer_output_size()
);
Bitmap b = Bitmap(width, height);
while (1) {
b.clear();
buf.update();
fft.update(buf);
draw_spectrum_bitmap(fft.get_output(), b);
b.save("/tmp/o.bmp");
}
}

View File

@ -4,9 +4,9 @@ Bitmap::Bitmap(size_t w, size_t h) {
this->width = w;
this->height = h;
this->data.reserve(h);
this->data.resize(h);
for (size_t r = 0; r < h; r++) {
data[r].reserve(w);
data[r].resize(w);
}
clear();
@ -67,7 +67,9 @@ void Bitmap::setpixel(
}
// TODO: format filename
//char f[100];
//snprintf(f, 100, "/tmp/%i.bmp", c);
void Bitmap::save(const char *filename) const {
uint8_t header[54] = {