Files
beatglow/_old/visual/analyzer.go
T
2026-10-29 17:29:41 +01:00

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
}
}
}