314 lines
8.0 KiB
Go
314 lines
8.0 KiB
Go
package beatglow
|
|
|
|
import (
|
|
"context"
|
|
"image/color"
|
|
"image/gif"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
|
|
"github.com/BeatGlow/audio"
|
|
|
|
"github.com/BeatGlow/beatglow/app"
|
|
"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
|
|
recorder *gif.GIF
|
|
recorderStart time.Time
|
|
recorderFrames int
|
|
recorderPalette color.Palette
|
|
}
|
|
|
|
func New(config *config.Config) (*Controller, error) {
|
|
log := logrus.NewEntry(logrus.StandardLogger())
|
|
|
|
if err := hostInit(log); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c := &Controller{
|
|
//recorderStart: time.Now().Add(10 * time.Second),
|
|
//recorderFrames: 100,
|
|
}
|
|
|
|
if err := c.configureDisplay(log, &config.Display); err != nil {
|
|
log.WithError(err).Error("fatal error setting up display")
|
|
return nil, err
|
|
}
|
|
c.recorderPalette = app.PaletteFor(c.ctx.display.ColorModel())
|
|
log.Debugf("palette (%d colors): %+v", len(c.recorderPalette), c.recorderPalette)
|
|
|
|
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.configureLayouts(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
|
|
}
|
|
|
|
userSettings := c.ctx.Settings()
|
|
c.ctx.contrast = userSettings.Display.Contrast
|
|
if err = c.ctx.display.SetContrast(userSettings.Display.Contrast); 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) configureLayouts(_ *logrus.Entry) (err error) {
|
|
c.ctx.addSettings(layout.Settings(&c.ctx))
|
|
c.ctx.addLayout(layout.Playing(&c.ctx))
|
|
c.ctx.addLayout(layout.Analyzer(&c.ctx))
|
|
c.ctx.addLayout(layout.Shader(&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(now time.Time) {
|
|
log := logrus.WithField("component", "controller")
|
|
|
|
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 {
|
|
log.WithError(err).Warn("display refresh failed")
|
|
}
|
|
|
|
if c.recorder != nil {
|
|
c.recorder.Image = append(c.recorder.Image, app.ImageToPaletted(nil, c.ctx.display, c.recorderPalette))
|
|
c.recorder.Delay = append(c.recorder.Delay, int(now.Sub(c.recorderStart).Seconds()/1000))
|
|
if len(c.recorder.Image) > c.recorderFrames {
|
|
go c.recorderSave()
|
|
}
|
|
} else if now.After(c.recorderStart) {
|
|
log.Info("recorder starting")
|
|
c.recorder = new(gif.GIF)
|
|
}
|
|
|
|
} else {
|
|
log.Trace("display refresh skipped, widgets not changed")
|
|
}
|
|
|
|
if c.ctx.contrast < c.ctx.contrastTarget {
|
|
c.ctx.contrast++
|
|
log.Debugf("increasing contrast %d to reach %d", c.ctx.contrast, c.ctx.contrastTarget)
|
|
if err := c.ctx.display.SetContrast(c.ctx.contrast); err != nil {
|
|
log.WithError(err).Warn("can't set display contrast")
|
|
}
|
|
} else if c.ctx.contrast > c.ctx.contrastTarget {
|
|
c.ctx.contrast--
|
|
log.Debugf("decreasing contrast %d to reach %d", c.ctx.contrast, c.ctx.contrastTarget)
|
|
if err := c.ctx.display.SetContrast(c.ctx.contrast); err != nil {
|
|
log.WithError(err).Warn("can't set display contrast")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *Controller) recorderSave() {
|
|
r := c.recorder
|
|
c.recorder = nil
|
|
c.recorderStart = time.Now().Add(24000 * time.Hour) // never? :P
|
|
|
|
name := "beatglow-recording.gif"
|
|
log := logrus.WithField("path", name)
|
|
log.Debugf("saving %d frames", len(r.Image))
|
|
|
|
f, err := os.Create(name)
|
|
if err != nil {
|
|
log.WithError(err).Warn("can't save recording")
|
|
return
|
|
}
|
|
|
|
if err = gif.EncodeAll(f, r); err != nil {
|
|
logrus.WithError(err).Warn("can't save recording")
|
|
_ = f.Close()
|
|
_ = os.Remove(name)
|
|
return
|
|
}
|
|
|
|
f.Close()
|
|
}
|
|
|
|
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:
|
|
}
|
|
}
|
|
}
|