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 } type audioSourceConfigurator interface { SetAudioSource(config.Audio) } 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 p, ok := c.ctx.player.(audioSourceConfigurator); ok { p.SetAudioSource(config.Audio) } 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: } } }