Files
beatglow/controller.go
T
2026-10-29 17:29:54 +01:00

239 lines
5.8 KiB
Go

package beatglow
import (
"context"
"time"
"github.com/sirupsen/logrus"
"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"
)
type Controller struct {
ctx controllerContext
encoder input.Encoder
frameRate time.Duration
}
func New(config *config.Config) (*Controller, error) {
log := logrus.NewEntry(logrus.StandardLogger())
if err := hostInit(log); err != nil {
return nil, err
}
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.configureAudio(&config.Audio); err != nil {
log.WithError(err).Error("fatal error setting up audio source")
c.teardown(log)
return nil, err
}
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.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) 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) 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 {
log.Warn("player doesn't support album art... sad :-(")
}
}
log.WithField("player", c.ctx.player).Debug("setup player done")
return
}
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) 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) teardown(log *logrus.Entry) {
c.ctx.teardown(log)
}
func (c *Controller) Run(ctx context.Context) error {
log := logrus.NewEntry(logrus.StandardLogger())
defer c.teardown(log)
player, err := c.ctx.player.Events()
if err != nil {
log.WithError(err).Error("error opening player events")
return err
}
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 (
last = time.Now()
frame int
)
go c.processAudio(ctx)
for {
select {
case <-ctx.Done():
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) onFrame(_ time.Time) {
var refresh bool
for _, layout := range c.ctx.layouts {
for _, widget := range layout.Widgets() {
if widget.IsVisible() {
if widget.Refresh(&c.ctx) {
refresh = true
}
}
}
}
if refresh {
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) onInput(log *logrus.Entry, event hardware.InputEvent) {
log = log.WithField("event", event.String())
log.Debug("input event")
c.ctx.handleInput(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")
case player.DisconnectedEvent:
log.Warn("player disconnected")
case player.StatusEvent:
c.ctx.handleStatus(event.Status)
c.ctx.handleTrack(event.Status.Track)
default:
log.WithField("event", event).Debug("unhandled player event")
}
}
func (c *Controller) processAudio(ctx context.Context) {
var (
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.ctx.audio.ReadBuffer(buffer)
if err != nil {
log.WithError(err).Warn("reading samples failed; retrying...")
time.Sleep(time.Second)
continue
}
log.WithField("samples", n).Trace("processing audio")
c.ctx.handleAudio(buffer)
select {
case <-ctx.Done():
return
default:
}
}
}