562 lines
13 KiB
Go
562 lines
13 KiB
Go
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/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
|
|
}
|
|
|
|
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{
|
|
state: new(State),
|
|
volume: -1,
|
|
}
|
|
if err = c.loadAudio(config.Audio); err != nil {
|
|
c.teardown()
|
|
return nil, err
|
|
}
|
|
if err = c.loadDisplays(config.Display, config.Screen); 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 :-(")
|
|
}
|
|
}
|
|
|
|
c.screen.volume = screen.Volume(c.Player, c.Main)
|
|
c.observer(c.screen.volume)
|
|
|
|
return
|
|
}
|
|
|
|
func (c *Controller) loadAudio(config config.Audio) (err error) {
|
|
if c.Audio, err = sound.New(config); err != nil {
|
|
return
|
|
}
|
|
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)
|
|
|
|
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) Run(ctx context.Context) error {
|
|
defer c.teardown()
|
|
|
|
playerEvents, err := c.Player.Events()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
inputEvents, err := c.encoder.Events()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var (
|
|
fps = time.NewTicker(c.fps)
|
|
update = time.NewTicker(time.Second)
|
|
rate = int(time.Second / c.fps)
|
|
frames 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.
|
|
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()
|
|
}
|
|
}
|
|
}
|
|
|
|
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()
|
|
}
|
|
|
|
var refresh bool
|
|
for _, widget := range widgets {
|
|
if changed := widget.Render(false); changed {
|
|
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")
|
|
}
|
|
}
|
|
}
|
|
|
|
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) 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.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)
|
|
|
|
default:
|
|
log.WithField("event", event).Warn("unhandled 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) {
|
|
var (
|
|
channels = c.Audio.Channels()
|
|
buffer = make(audio.Buffer[float64], channels)
|
|
)
|
|
for channel := 0; channel < channels; channel++ {
|
|
buffer[channel] = make([]float64, 1024)
|
|
}
|
|
|
|
for {
|
|
n, err := c.Audio.ReadBuffer(buffer)
|
|
if err != nil {
|
|
c.log().WithError(err).Warn("reading samples failed; retrying")
|
|
time.Sleep(time.Second)
|
|
continue
|
|
}
|
|
|
|
c.log().WithField("samples", n).Trace("read samples")
|
|
c.handleSamples(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")
|
|
}
|
|
|
|
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
|
|
}
|