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

345 lines
8.3 KiB
Go

package harmon
import (
"context"
"crypto/rand"
"errors"
"fmt"
"image"
"image/color"
"time"
"github.com/sirupsen/logrus"
"periph.io/x/conn/v3/physic"
"periph.io/x/host/v3"
"go.maze.io/harmon/audio"
"go.maze.io/harmon/config"
"go.maze.io/harmon/hardware"
"go.maze.io/harmon/hardware/display"
"go.maze.io/harmon/internal/pixel"
"go.maze.io/harmon/player"
"go.maze.io/harmon/visual"
"go.maze.io/harmon/visual/screensaver"
)
const defaultFPS = 20
type Controller struct {
// Left, right and color displays.
Main hardware.Display
Left hardware.Display
Right hardware.Display
Color hardware.Display
// Player.
Player player.Player
AlbumArt player.AlbumArt
// Audio source.
Audio audio.Stream
// Stream of audio samples.
Stream audio.Stream
// Visual effects.
visual struct {
current visual.Visual
offline *visual.Offline
screensaver *screensaver.Stars
vumeterLeft *visual.VUMeter
vumeterRight *visual.VUMeter
}
fps time.Duration
connected bool
playing bool
}
func NewController(config *config.Config) (*Controller, error) {
state, err := host.Init()
if err != nil {
return nil, err
}
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")
}
c := &Controller{}
if err = c.loadAudio(config.Audio); err != nil {
c.teardown()
return nil, err
}
if err = c.loadDisplays(config.Display); err != nil {
c.teardown()
return nil, err
}
if err = c.loadInputs(config.Input); err != nil {
c.teardown()
return nil, err
}
if err = c.loadPlayer(config.Player); err != nil {
c.teardown()
return nil, err
}
return c, nil
}
func (c *Controller) log() *logrus.Entry {
return logrus.WithField("type", "controller")
}
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")
} else {
c.log().Warn("player doesn't support album art... sad :-(")
}
}
return
}
func (c *Controller) loadAudio(config config.Audio) (err error) {
c.Audio, err = audio.New(config)
return
}
func (c *Controller) loadDisplays(config config.Display) (err error) {
log := c.log()
if c.fps = time.Second / time.Duration(config.FPS); c.fps <= 0 {
config.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": config.FPS,
"rate": c.fps,
}).Debug("setting frame rate")
}
if config.Main != nil {
if c.Main, err = display.Load(*config.Main); err != nil {
return fmt.Errorf("error loading main display driver: %w", err)
}
size := c.Main.Size()
c.Left = display.MakeView(c.Main, image.Rect(0, 0, size.X/2, size.Y))
c.Right = display.MakeView(c.Main, image.Rect(size.X/2, 0, size.X, size.Y))
} else if config.Left == nil {
return errors.New("missing main or left block in display configuration")
} else if config.Right == nil {
return errors.New("missing main or right block in display configuration")
} else {
if c.Left, err = display.Load(*config.Left); err != nil {
return fmt.Errorf("error loading left display driver: %w", err)
} else if err = c.Left.Fill(pixel.On); err != nil {
return err
}
if c.Right, err = display.Load(*config.Right); err != nil {
return fmt.Errorf("error loading right display driver: %w", err)
} else if err = c.Right.Fill(pixel.Off); err != nil {
return err
}
c.Main = display.NewCombined(c.Left, c.Right)
}
/*
if c.Color, err = display.Load(config.Color); err != nil {
return fmt.Errorf("error loading color display driver: %w", err)
} else if err = c.Color.Fill(pixel.Off); err != nil {
return err
}
*/
log.WithField("type", c.Main.Type()).Info("configured main display")
log.WithField("type", c.Left.Type()).Info("configured left display")
log.WithField("type", c.Right.Type()).Info("configured right display")
rate := c.Audio.SampleRate() / physic.Frequency(config.FPS)
c.visual.screensaver = screensaver.NewStars(c.Main, 12)
c.visual.offline = visual.NewOffline(c.Left, c.Right, nil)
c.visual.vumeterLeft = visual.NewVUMeter(c.Left, rate, 1, c.Audio.Channels())
c.visual.vumeterRight = visual.NewVUMeter(c.Right, rate, 2, c.Audio.Channels())
// Splash screen
/*
if err = display.DrawImage(c.Color, 40, 40, "harmon.png"); err != nil {
return fmt.Errorf("error loading splash screen: %w", err)
}
display.DrawText(c.Color, 1, 1, display.Font8x16, "Harmon")
for y := 0; y < 240; y++ {
for x := 0; x < 240; x++ {
c.Color.Set(x, y, randomColor())
}
}
if err = c.Color.Refresh(); err != nil {
return err
}
*/
return
}
func (c *Controller) loadInputs(config config.Input) (err error) {
return
}
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.Left != nil {
log.WithError(c.Left.Halt()).Debug("halt left screen")
}
if c.Right != nil {
log.WithError(c.Right.Halt()).Debug("halt right screen")
}
if c.Color != nil {
log.WithError(c.Color.Halt()).Debug("halt color screen")
}
}
func (c *Controller) Run(ctx context.Context) error {
defer c.teardown()
playerEvents, err := c.Player.Events()
if err != nil {
return err
}
var (
fps = time.NewTicker(c.fps)
update = time.NewTicker(25 * time.Millisecond)
rate = int(time.Second / c.fps)
)
logrus.WithFields(logrus.Fields{
"fps": rate,
"rate_display": c.fps,
"rate_sample": c.Audio.SampleRate(),
}).Debug("opening audio stream")
var (
samples = c.Audio.Samples(int(c.Audio.SampleRate() / physic.Frequency(rate) / physic.Hertz))
last time.Time
frames int
)
defer fps.Stop()
defer update.Stop()
c.log().WithFields(logrus.Fields{
"rate": c.Audio.SampleRate(),
"fps": rate,
"rate_fps": c.Audio.SampleRate() / physic.Frequency(rate),
}).Info("Harmon controller running...")
for {
select {
case event := <-playerEvents:
c.handlePlayer(event)
case <-fps.C:
frames++
c.handleFrame()
case now := <-update.C:
if logrus.GetLevel() >= logrus.DebugLevel {
if now.Sub(last) > time.Second {
c.log().WithField("fps", frames).Debug("frame rate")
last = now
frames = 0
}
}
case samples := <-samples:
c.handleSamples(samples)
case <-ctx.Done():
return ctx.Err()
}
}
}
func (c *Controller) handlePlayer(event player.Event) {
log := c.log().WithField("from", "player")
log.WithFields(logrus.Fields{
"event": event.String(),
}).Trace("new event")
switch event := event.(type) {
case player.ConnectedEvent:
log.Info("player connected")
c.connected = true
case player.DisconnectedEvent:
log.Warn("player disconnected")
c.connected = false
c.playing = false
case player.PlayEvent:
log.WithField("track", event.Track).Info("now playing")
case player.StatusEvent:
log.WithField("state", event.Status).Trace("player status")
c.playing = event.Status.Playing
default:
log.WithField("event", event).Warn("unhandled event")
}
}
func (c *Controller) handleFrame() {
log := c.log()
if c.connected {
if c.playing {
if err := c.visual.vumeterLeft.Render(); err != nil {
log.WithError(err).Warn("left vumeter render failed")
}
if err := c.visual.vumeterRight.Render(); err != nil {
log.WithError(err).Warn("right vumeter render failed")
}
} else {
if err := c.visual.screensaver.Refresh(); err != nil {
log.WithError(err).Warn("screensaver render failed")
}
}
} else {
if err := c.visual.offline.Render(); err != nil {
log.WithError(err).Warn("offline render failed")
}
}
}
func (c *Controller) handleSamples(samples audio.Buffer) {
c.visual.vumeterLeft.Process(samples)
c.visual.vumeterRight.Process(samples)
}