112 lines
2.4 KiB
Go
112 lines
2.4 KiB
Go
package widget
|
|
|
|
import (
|
|
"image"
|
|
"image/draw"
|
|
|
|
"github.com/BeatGlow/audio"
|
|
"github.com/BeatGlow/beatglow/ui"
|
|
"github.com/BeatGlow/display"
|
|
"github.com/BeatGlow/display/pixel"
|
|
)
|
|
|
|
type WaveForm struct {
|
|
Display display.Display
|
|
Position image.Point
|
|
buffer draw.Image
|
|
height int
|
|
width int
|
|
bins int
|
|
level [2][]float64
|
|
changed bool
|
|
}
|
|
|
|
func NewWaveform(display display.Display, at image.Point, width, height int) *WaveForm {
|
|
bins := width / 2
|
|
return &WaveForm{
|
|
Display: display,
|
|
Position: at,
|
|
buffer: ui.BufferFor(display.ColorModel(), width, height),
|
|
width: width,
|
|
height: height,
|
|
bins: bins,
|
|
}
|
|
}
|
|
|
|
func (w *WaveForm) Render(refresh bool) bool {
|
|
if !(refresh || w.changed) {
|
|
return false
|
|
}
|
|
|
|
draw.Draw(w.buffer, w.buffer.Bounds(), image.Black, image.Point{}, draw.Src)
|
|
|
|
for i := range w.level[0] {
|
|
w.drawLevel(0, i)
|
|
w.drawLevel(1, i)
|
|
}
|
|
|
|
draw.Draw(w.Display, w.buffer.Bounds().Add(w.Position), w.buffer, image.Point{}, draw.Src)
|
|
|
|
return true
|
|
}
|
|
|
|
func (w *WaveForm) drawLevel(channel, i int) {
|
|
var offset = (w.width / 2)
|
|
if channel == 0 {
|
|
offset -= i
|
|
} else {
|
|
offset += i
|
|
}
|
|
|
|
y := w.height/2 + int(float64(w.height/2)*w.level[channel][i]+.5)
|
|
w.buffer.Set(offset, y, pixel.On)
|
|
}
|
|
|
|
func (w *WaveForm) ProcessBuffer(buffer audio.Buffer[float64]) {
|
|
var (
|
|
channels = buffer.Channels()
|
|
)
|
|
|
|
if channels == 1 {
|
|
w.level[0] = condenseSamples(w.level[0], buffer[0], w.bins)
|
|
w.level[1] = w.level[0]
|
|
} else {
|
|
w.level[0] = condenseSamples(w.level[0], buffer[0], w.bins)
|
|
w.level[1] = condenseSamples(w.level[1], buffer[1], w.bins)
|
|
}
|
|
|
|
w.changed = true
|
|
}
|
|
|
|
// condenseSamples reduces the input samples to a fixed number of points.
|
|
// It aggregates values within each segment using averaging.
|
|
func condenseSamples(dst, src []float64, targetWidth int) []float64 {
|
|
if len(dst) != targetWidth {
|
|
dst = make([]float64, targetWidth)
|
|
}
|
|
|
|
if len(src) <= targetWidth {
|
|
// If the buffer is smaller than or equal to the target width, return as is.
|
|
copy(dst, src)
|
|
return dst
|
|
}
|
|
|
|
binSize := float64(len(src)) / float64(targetWidth)
|
|
for i := 0; i < targetWidth; i++ {
|
|
start := int(float64(i) * binSize)
|
|
end := int(float64(i+1) * binSize)
|
|
if end > len(src) {
|
|
end = len(src)
|
|
}
|
|
|
|
// Compute the average for the segment.
|
|
sum := 0.0
|
|
for j := start; j < end; j++ {
|
|
sum += src[j]
|
|
}
|
|
dst[i] = sum / float64(end-start)
|
|
}
|
|
|
|
return dst
|
|
}
|