114 lines
2.4 KiB
Go
114 lines
2.4 KiB
Go
package visual
|
|
|
|
import (
|
|
"math/cmplx"
|
|
|
|
"github.com/BeatGlow/beatglow/audio"
|
|
"github.com/BeatGlow/beatglow/draw"
|
|
"github.com/BeatGlow/beatglow/draw/pixel"
|
|
"github.com/BeatGlow/beatglow/internal/calc"
|
|
"github.com/BeatGlow/display"
|
|
"gonum.org/v1/gonum/dsp/fourier"
|
|
)
|
|
|
|
type Analyzer struct {
|
|
display display.Display
|
|
canvas *draw.Canvas
|
|
rate audio.Rate
|
|
step int
|
|
fft *fourier.FFT
|
|
complex []complex128
|
|
samples []float64
|
|
levels []float64
|
|
}
|
|
|
|
func NewAnalyzer(display display.Display, rate audio.Rate, step int) *Analyzer {
|
|
return &Analyzer{
|
|
display: display,
|
|
canvas: draw.NewCanvas(display),
|
|
rate: rate,
|
|
step: step,
|
|
levels: make([]float64, display.Bounds().Dx()),
|
|
}
|
|
}
|
|
|
|
func (a *Analyzer) ProcessBuffer(buffer *audio.Buffer) {
|
|
a.frequencySpectrum(buffer.ToMono().Samples[0], a.rate, a.step)
|
|
}
|
|
|
|
func (a *Analyzer) Halt() error {
|
|
return nil
|
|
}
|
|
|
|
func (Analyzer) Type() string {
|
|
return "visual:analyzer"
|
|
}
|
|
|
|
func (a *Analyzer) Render() error {
|
|
//a.display.Clear()
|
|
|
|
for x, level := range a.levels {
|
|
h := int(56*level + .5)
|
|
draw.Line(a.display, pixel.On, x, 56-h, x+1, 56)
|
|
}
|
|
|
|
return a.display.Refresh()
|
|
}
|
|
|
|
func (a *Analyzer) resize(n int) {
|
|
if s := n/2 + 1; len(a.complex) != s {
|
|
a.fft = fourier.NewFFT(n)
|
|
a.samples = make([]float64, n)
|
|
a.complex = make([]complex128, s)
|
|
}
|
|
}
|
|
|
|
func (a *Analyzer) convert(samples []audio.Sample) {
|
|
for i, v := range samples {
|
|
a.samples[i] = float64(v)
|
|
}
|
|
}
|
|
|
|
func (a *Analyzer) frequencySpectrum(samples []audio.Sample, rate audio.Rate, step int) error {
|
|
n := len(samples)
|
|
a.resize(n)
|
|
a.convert(samples)
|
|
a.fft.Coefficients(a.complex, a.samples)
|
|
|
|
/*
|
|
if err := transform(csamples); err != nil {
|
|
return nil, err
|
|
}
|
|
*/
|
|
|
|
/*
|
|
fmt.Printf("%d: %#+v", len(a.complex), a.complex)
|
|
freqSamplingStep := float64(rate) / float64(n)
|
|
scaleStep := float64(step) / freqSamplingStep
|
|
freqLimit := float64(rate) / 2.0
|
|
|
|
for i := 0.0; i*freqSamplingStep <= freqLimit; i += scaleStep {
|
|
//result[int(i*freqSamplingStep)] = math.Abs(real(a.complex[int(i)])) // cmplx.Abs(a.complex[int(i)])
|
|
a.levels[int(i*freqSamplingStep)] = cmplx.Abs(a.complex[int(i)])
|
|
}
|
|
*/
|
|
for i := 0; i < a.display.Bounds().Size().X; i++ {
|
|
o := i << 1
|
|
a.levels[i] = (cmplx.Abs(a.complex[o]) + cmplx.Abs(a.complex[o+1])) / 2
|
|
}
|
|
calc.Hamming(a.levels, a.levels)
|
|
|
|
a.normalizeSpectrum()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a *Analyzer) normalizeSpectrum() {
|
|
max := calc.Max(a.levels)
|
|
if max > 0 {
|
|
for i := range a.levels {
|
|
a.levels[i] /= max
|
|
}
|
|
}
|
|
}
|