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 }