Checkpoint

This commit is contained in:
maze authored and maze committed 2026-10-29 17:29:54 +01:00
1 parent c5d6137fab
commit 4ae7655cd8
223 files changed
+14770 -18352

No files matched your search

+128 -451
View File
@@ -2,560 +2,237 @@ package beatglow
import (
"context"
"crypto/rand"
"errors"
"fmt"
"image"
"image/color"
"time"
"github.com/sirupsen/logrus"
"periph.io/x/host/v3"
"github.com/BeatGlow/audio"
"github.com/BeatGlow/beatglow/app/layout"
"github.com/BeatGlow/beatglow/config"
"github.com/BeatGlow/beatglow/hardware"
"github.com/BeatGlow/beatglow/hardware/input"
"github.com/BeatGlow/beatglow/player"
"github.com/BeatGlow/beatglow/sound"
"github.com/BeatGlow/beatglow/ui"
"github.com/BeatGlow/beatglow/ui/screen"
"github.com/BeatGlow/display"
)
const defaultFPS = 20
type Controller struct {
// Main and meta display.
Main display.Display
Full display.Display
Meta display.Display
// Player.
Player player.Player
AlbumArt player.AlbumArt
// Audio source.
Audio sound.Source
// Inputs.
encoder input.Encoder
// Volume level.
volume int
// Observers
observe struct {
track *player.Track
trackChanged []player.TrackObserver
status *player.Status
statusChanged []player.StatusObserver
}
// Screens.
screen struct {
priority ui.Screen
priorityUntil time.Time
active ui.Screen
boot ui.Screen
playing ui.Screen
volume ui.Screen
stereoSpectrum ui.Screen
stereoWaterfall ui.Screen
carousel []ui.Screen
carouselIndex uint
}
fps time.Duration
state *State
ctx controllerContext
encoder input.Encoder
frameRate time.Duration
}
func NewController(config *config.Config) (*Controller, error) {
state, err := host.Init()
if err != nil {
return nil, err
}
func New(config *config.Config) (*Controller, error) {
log := logrus.NewEntry(logrus.StandardLogger())
for _, driver := range state.Failed {
log.WithField("driver", driver.String()).WithError(driver.Err).Trace("host driver failed to load")
}
for _, driver := range state.Skipped {
log.WithField("driver", driver.String()).Trace("host driver skipped")
}
for _, driver := range state.Loaded {
log.WithField("driver", driver.String()).Debug("host driver loaded")
if err := hostInit(log); err != nil {
return nil, err
}
c := &Controller{
state: new(State),
volume: -1,
}
if err = c.loadAudio(config.Audio); err != nil {
c.teardown()
c := &Controller{}
if err := c.configureDisplay(log, &config.Display); err != nil {
log.WithError(err).Error("fatal error setting up display")
return nil, err
}
if err = c.loadDisplays(config.Display, config.Screen); err != nil {
c.teardown()
if err := c.configureAudio(&config.Audio); err != nil {
log.WithError(err).Error("fatal error setting up audio source")
c.teardown(log)
return nil, err
}
if err = c.loadInputs(config.Input); err != nil {
c.teardown()
if err := c.configurePlayer(log, &config.Player); err != nil {
log.WithError(err).Error("fatal error setting up player")
c.teardown(log)
return nil, err
}
if err = c.loadPlayer(config.Player); err != nil {
c.teardown()
if err := c.configureInputs(log, &config.Input); err != nil {
log.WithError(err).Error("fatal error setting up inputs")
c.teardown(log)
return nil, err
}
if err := c.configureApps(log); err != nil {
log.WithError(err).Error("fatal error setting up apps")
c.teardown(log)
return nil, err
}
if config.Display.FPS > 0 {
c.frameRate = time.Second / time.Duration(config.Display.FPS)
} else {
c.frameRate = time.Second / 20
}
log.WithField("fps", int(time.Second/c.frameRate)).Debug("refresh rate set")
return c, nil
}
func (c *Controller) log() *logrus.Entry {
return logrus.WithField("type", "controller")
func (c *Controller) configureDisplay(log *logrus.Entry, settings *config.Display) (err error) {
log.WithField("driver", settings.Main.Type).Debug("setup display")
if c.ctx.display, err = hardware.Display(settings.Main); err != nil {
return
} else if err = c.ctx.display.Refresh(); err != nil {
return
}
log.WithField("display", c.ctx.display).Debug("setup display done")
return
}
func (c *Controller) loadPlayer(config config.Player) (err error) {
if c.Player, err = player.New(config); err == nil {
var ok bool
if c.AlbumArt, ok = c.Player.(player.AlbumArt); ok {
c.log().Debug("player supports album art, great")
func (c *Controller) configureAudio(settings *config.Audio) (err error) {
c.ctx.audio, err = sound.New(settings)
return
}
func (c *Controller) configurePlayer(log *logrus.Entry, settings *config.Player) (err error) {
log.WithField("player", settings.Type).Debug("setup player")
if c.ctx.player, err = player.New(settings); err == nil {
if _, ok := c.ctx.player.(player.AlbumArt); ok {
log.Debug("player supports album art, great")
} else {
c.log().Warn("player doesn't support album art... sad :-(")
log.Warn("player doesn't support album art... sad :-(")
}
}
c.screen.volume = screen.Volume(c.Player, c.Main)
c.observer(c.screen.volume)
log.WithField("player", c.ctx.player).Debug("setup player done")
return
}
func (c *Controller) loadAudio(config config.Audio) (err error) {
if c.Audio, err = sound.New(config); err != nil {
func (c *Controller) configureInputs(log *logrus.Entry, settings *config.Input) (err error) {
log.Debug("setup rotary encoder")
if c.encoder, err = input.NewEncoder(settings.Encoder); err != nil {
return
}
log.WithField("encoder", c.encoder.String()).Debug("setup rotary encoder done")
return
}
func (c *Controller) loadDisplays(displayConfig config.Display, screenConfig config.Screen) (err error) {
log := c.log()
if c.fps = time.Second / time.Duration(displayConfig.FPS); c.fps <= 0 {
displayConfig.FPS = defaultFPS
log.WithFields(logrus.Fields{
"fps": defaultFPS,
"rate": c.fps,
}).Debug("setting default frame rate")
c.fps = time.Second / defaultFPS
} else {
log.WithFields(logrus.Fields{
"fps": displayConfig.FPS,
"rate": c.fps,
}).Debug("setting frame rate")
}
if displayConfig.Main != nil {
// Single display
if c.Main, err = hardware.Display(displayConfig.Main); err != nil {
return fmt.Errorf("error loading main display driver: %w", err)
}
} else if displayConfig.Left == nil {
return errors.New("missing main or left block in display configuration")
} else if displayConfig.Right == nil {
return errors.New("missing main or right block in display configuration")
} else {
// Dual displays
var left, right display.Display
if left, err = hardware.Display(displayConfig.Left); err != nil {
return fmt.Errorf("error loading left display driver: %w", err)
} else if err = left.Refresh(); err != nil {
return err
}
if right, err = hardware.Display(displayConfig.Right); err != nil {
return fmt.Errorf("error loading right display driver: %w", err)
} else if err = right.Refresh(); err != nil {
return err
}
// Merge into virtual display
c.Main = hardware.NewCombined(left, right)
}
var (
bounds = c.Main.Bounds()
size = bounds.Size()
left34 = image.Rect(0, 0, (size.X/4)*3, size.Y)
right14 = image.Rect((size.X/4)*3, 0, size.X, size.Y)
)
c.Full = c.Main
if displayConfig.Meta == nil {
// Split the screen
c.Meta = hardware.MakeView(c.Main, right14)
c.Main = hardware.MakeView(c.Main, left34)
} else {
if c.Meta, err = hardware.Display(displayConfig.Meta); err != nil {
return fmt.Errorf("error loading meta display driver: %w", err)
} else if err = c.Meta.Refresh(); err != nil {
return err
}
}
log.WithField("type", c.Main).Info("configured main display")
log.WithField("type", c.Meta).Info("configured meta display")
// Load screens and observers
spectrumConfig := new(config.ScreenSpectrum)
waterfallConfig := new(config.ScreenSpectrum)
if screenConfig.Spectrum != nil {
*spectrumConfig = *screenConfig.Spectrum
*waterfallConfig = *screenConfig.Spectrum
}
spectrumConfig.Waterfall = false
waterfallConfig.Waterfall = true
c.screen.boot = screen.Boot(c.Full)
c.screen.playing = screen.Playing(c.Main, c.Meta, screenConfig.Playing)
c.screen.stereoSpectrum = screen.StereoSpectrum(c.Full, spectrumConfig)
c.screen.stereoWaterfall = screen.StereoSpectrum(c.Full, waterfallConfig)
c.observer(c.screen.playing)
c.observer(c.screen.stereoSpectrum)
c.observer(c.screen.stereoWaterfall)
// Set active screen.
c.screen.active = c.screen.playing
c.screen.playing.SetVisible(true)
// Available screens for carousel.
c.screen.carousel = []ui.Screen{
c.screen.playing,
c.screen.stereoSpectrum,
c.screen.stereoWaterfall,
}
// Set priority screen for the boot splash.
//c.screen.priority = c.screen.boot
c.screen.priorityUntil = time.Now().Add(time.Second)
func (c *Controller) configureApps(_ *logrus.Entry) (err error) {
c.ctx.addSettings(layout.Settings(&c.ctx))
c.ctx.addLayout(layout.Playing(&c.ctx))
c.ctx.Show(nil)
return
}
func (c *Controller) loadInputs(config config.Input) (err error) {
if c.encoder, err = input.NewEncoder(config.Encoder); err != nil {
return
}
return nil
}
func (c *Controller) observer(o interface{}) {
log := c.log()
if o, ok := o.(player.TrackObserver); ok {
log.WithField("observer", o).Debug("adding track change observer")
c.observe.trackChanged = append(c.observe.trackChanged, o)
}
if o, ok := o.(player.StatusObserver); ok {
log.WithField("observer", o).Debug("adding status change observer")
c.observe.statusChanged = append(c.observe.statusChanged, o)
}
}
func randomColor() color.RGBA {
var b [3]byte
rand.Read(b[:])
return color.RGBA{
R: b[0],
G: b[1],
B: b[2],
A: 0xff,
}
}
func (c *Controller) teardown() {
log := c.log()
if c.Player != nil {
log.Debug("halt player")
}
if c.Audio != nil {
//log.WithError(c.Audio.Halt()).Debug("halt audio")
}
if c.Main != nil {
log.WithError(c.Main.Close()).Debug("halt main screen")
}
if c.Meta != nil {
log.WithError(c.Meta.Close()).Debug("halt meta screen")
}
func (c *Controller) teardown(log *logrus.Entry) {
c.ctx.teardown(log)
}
func (c *Controller) Run(ctx context.Context) error {
defer c.teardown()
log := logrus.NewEntry(logrus.StandardLogger())
defer c.teardown(log)
playerEvents, err := c.Player.Events()
player, err := c.ctx.player.Events()
if err != nil {
log.WithError(err).Error("error opening player events")
return err
}
inputEvents, err := c.encoder.Events()
encoder, err := c.encoder.Events()
if err != nil {
log.WithError(err).Error("error opening player events")
return err
}
frames := time.NewTicker(c.frameRate)
defer frames.Stop()
log.Debug("main loop starting")
var (
fps = time.NewTicker(c.fps)
update = time.NewTicker(time.Second)
rate = int(time.Second / c.fps)
frames int
last = time.Now()
frame int
)
logrus.WithFields(logrus.Fields{
"fps": rate,
"rate_display": c.fps,
"rate_sample": c.Audio.SampleRate(),
}).Debug("opening audio stream")
defer fps.Stop()
defer update.Stop()
go c.processSound(ctx)
c.log().WithFields(logrus.Fields{
"rate": c.Audio.SampleRate(),
"fps": rate,
}).Info("BeatGlow controller running...")
// Main house keeping loop, processes player and input updates, as well as video frames.
go c.processAudio(ctx)
for {
select {
case event := <-playerEvents:
c.handlePlayer(event)
case now := <-fps.C:
frames++
c.handleFrame(now)
case <-update.C:
// Display the frame rate in the debug log.
c.log().WithField("fps", frames).Debug("frame rate")
frames = 0
case event := <-inputEvents:
// Handle input events.
c.handleInput(event)
case <-ctx.Done():
return ctx.Err()
log.Warn("shutting down")
return nil
case now := <-frames.C:
frame++
if now.Sub(last) >= time.Second {
log.Debugf("current frame rate is %d fps", frame)
frame = 0
last = now
}
c.onFrame(now)
case event := <-encoder:
c.onInput(log, event)
case event := <-player:
c.onPlayer(log, event)
}
}
}
func (c *Controller) handleFrame(t time.Time) {
var widgets []ui.Widget
if c.screen.priority != nil {
if t.After(c.screen.priorityUntil) {
c.log().Debug("priorty screen expired; closing")
c.screen.priority = nil
c.screen.active.SetVisible(true)
} else {
c.log().Trace("priorty screen is active")
widgets = c.screen.priority.Widgets()
}
}
if widgets == nil {
widgets = c.screen.active.Widgets()
}
func (c *Controller) onFrame(_ time.Time) {
var refresh bool
for _, widget := range widgets {
if changed := widget.Render(false); changed {
refresh = true
for _, layout := range c.ctx.layouts {
for _, widget := range layout.Widgets() {
if widget.IsVisible() {
if widget.Refresh(&c.ctx) {
refresh = true
}
}
}
}
if refresh {
if err := c.Main.Refresh(); err != nil {
c.log().WithError(err).Error("main refresh failed")
}
if err := c.Meta.Refresh(); err != nil {
c.log().WithError(err).Error("meta refresh failed")
logrus.Trace("display refresh required")
if err := c.ctx.display.Refresh(); err != nil {
logrus.WithError(err).Warn("display refresh failed")
}
} else {
logrus.Trace("display refresh skipped, widgets not changed")
}
}
func (c *Controller) handleScreen(name string) {
previous := c.screen.active
switch name {
case "boot":
c.screen.active = c.screen.boot
case "playing":
c.screen.active = c.screen.playing
}
if previous != c.screen.active {
previous.SetVisible(false)
c.screen.active.SetVisible(true)
}
func (c *Controller) onInput(log *logrus.Entry, event hardware.InputEvent) {
log = log.WithField("event", event.String())
log.Debug("input event")
c.ctx.handleInput(event)
}
func (c *Controller) handlePlayer(event player.Event) {
log := c.log().WithField("from", "player")
log.WithFields(logrus.Fields{
"event": event.String(),
}).Trace("new event")
func (c *Controller) onPlayer(log *logrus.Entry, event player.Event) {
log = log.WithField("player", c.ctx.player.String())
switch event := event.(type) {
case player.ConnectedEvent:
log.Info("player connected")
c.state = &State{Connected: true}
c.handleStatus(nil)
case player.DisconnectedEvent:
log.Warn("player disconnected")
c.state = &State{}
c.handleStatus(nil)
case player.PlayEvent:
c.handleTrack(event.Track)
case player.StatusEvent:
c.handleStatus(event.Status)
c.ctx.handleStatus(event.Status)
c.ctx.handleTrack(event.Status.Track)
default:
log.WithField("event", event).Warn("unhandled event")
log.WithField("event", event).Debug("unhandled player event")
}
}
func (c *Controller) handleStatus(status *player.Status) {
//log := c.log().WithField("from", "player")
for _, o := range c.observe.statusChanged {
o.StatusChanged(status)
}
c.observe.status = status
if status != nil {
if c.state.Connected {
if c.volume != -1 && c.volume != status.Volume {
c.log().WithFields(logrus.Fields{"old": c.volume, "new": status.Volume}).Debug("volume change, showing volume screen")
c.volume = status.Volume
c.screen.active.SetVisible(false)
c.screen.priority = c.screen.volume
c.screen.priority.SetVisible(true)
c.screen.priorityUntil = time.Now().Add(5 * time.Second)
}
c.volume = status.Volume
}
c.handleTrack(status.Track)
}
}
func (c *Controller) handleTrack(track *player.Track) {
log := c.log().WithField("from", "player")
if !c.observe.track.Eq(track) {
log.WithField("track", track).Info("track changed")
for _, o := range c.observe.trackChanged {
o.TrackChanged(c.Player, track)
}
}
c.observe.track = track
}
func (c *Controller) processSound(ctx context.Context) {
func (c *Controller) processAudio(ctx context.Context) {
var (
channels = c.Audio.Channels()
channels = c.ctx.audio.Channels()
buffer = make(audio.Buffer[float64], channels)
)
for channel := 0; channel < channels; channel++ {
buffer[channel] = make([]float64, 1024)
}
log := logrus.WithField("audio", c.ctx.audio.String())
for {
n, err := c.Audio.ReadBuffer(buffer)
n, err := c.ctx.audio.ReadBuffer(buffer)
if err != nil {
c.log().WithError(err).Warn("reading samples failed; retrying")
log.WithError(err).Warn("reading samples failed; retrying...")
time.Sleep(time.Second)
continue
}
c.log().WithField("samples", n).Trace("read samples")
c.handleSamples(buffer)
}
}
log.WithField("samples", n).Trace("processing audio")
c.ctx.handleAudio(buffer)
func (c *Controller) handleSamples(buffer audio.Buffer[float64]) {
log := c.log().WithFields(logrus.Fields{
"channels": buffer.Channels(),
"samples": buffer.Samples(),
"screen": c.screen.active,
})
if c.screen.active == nil {
log.Trace("no active screen, discarding samples")
return
}
if processor, ok := c.screen.active.(sound.Processor); ok {
log.Trace("active screen processing samples")
processor.ProcessBuffer(buffer)
} else {
log.Trace("active screen doesn't process samples, discarding samples")
}
}
func (c *Controller) handleInput(event hardware.InputEvent) {
log := c.log()
switch event := event.(type) {
case hardware.RotaryEvent:
if c.observe.status != nil && c.state.Connected {
log.WithField("delta", event.Delta).Debug("update volume")
if err := c.Player.ChangeVolume(event.Delta); err != nil {
log.WithError(err).Warn("failed to adjust volume")
}
} else {
log.WithField("delta", event.Delta).Debug("ignored volume adjustment: player is not connected")
select {
case <-ctx.Done():
return
default:
}
case hardware.RotaryPressEvent:
if c.screen.priority == nil {
c.screen.active.SetVisible(false)
c.screen.carouselIndex = (c.screen.carouselIndex + 1) % uint(len(c.screen.carousel))
c.screen.active = c.screen.carousel[c.screen.carouselIndex]
c.screen.active.SetVisible(true)
log.WithField("screen", c.screen.active).Info("switching active screen")
}
case hardware.RotaryLongPressEvent:
if c.state != nil && c.state.Connected {
if err := c.Player.ToggleMute(); err != nil {
log.WithError(err).Warn("mute toggle failed")
}
}
default:
log.WithField("event", event).Debug("unhandled input")
}
}
type State struct {
Connected bool
Playing bool
PlayingSince time.Time
Track *player.Track
}
func (a *State) Eq(b *State) bool {
if a == nil {
return false
}
if b == nil {
return true
}
if a.Connected != b.Connected {
return true
}
if a.Playing != b.Playing {
return true
}
return false
}