Checkpoint

This commit is contained in:
maze authored and maze committed 2026-10-29 17:29:41 +01:00
1 parent 85a9ec684c
commit c5d6137fab
160 files changed
+76293 -387

No files matched your search

Binary file not shown.

After

Width:  |  Height:  |  Size: 22 KiB

+72
View File
@@ -0,0 +1,72 @@
package screen
import (
"image"
"github.com/BeatGlow/beatglow/hardware"
"github.com/BeatGlow/beatglow/ui"
"github.com/BeatGlow/beatglow/ui/widget"
"github.com/BeatGlow/display"
)
type boot struct {
display display.Display
widgets []ui.Widget
}
func Boot(displays ...display.Display) ui.Screen {
widgets := make([]ui.Widget, len(displays))
for i, display := range displays {
if i == 0 {
widgets[i] = newBoot(display)
} else {
widgets[i] = newEmpty(display)
}
}
return &boot{
display: displays[0],
widgets: widgets,
}
}
func (boot) String() string { return "boot" }
func (boot) HandleInput(_ hardware.InputEvent) {}
func (s *boot) SetVisible(_ bool) {
s.display.Clear()
}
func (s *boot) Widgets() []ui.Widget {
return s.widgets
}
func newBoot(display display.Display) ui.Widget {
var (
style = ui.StylesFor(display.ColorModel()).Boot
size = display.Bounds().Size()
)
switch {
case size.Y >= 64:
style.Font.SetPointSize(style.FontSize * 2)
default:
style.Font.SetPointSize(style.FontSize)
}
var (
width, height = style.Font.MeasureText("beatglow")
at = image.Pt(
(size.X-width)/2,
(size.Y-height)/2,
)
)
text := widget.NewText(display, at)
text.SetStyle(style)
text.Set("beatglow")
return text
}
func newEmpty(display display.Display) ui.Widget {
return widget.Empty{display}
}
+222
View File
@@ -0,0 +1,222 @@
package screen
import (
"fmt"
"image"
"time"
"github.com/BeatGlow/audio"
"github.com/BeatGlow/beatglow/config"
"github.com/BeatGlow/beatglow/player"
"github.com/BeatGlow/beatglow/ui"
"github.com/BeatGlow/beatglow/ui/widget"
"github.com/BeatGlow/display"
"github.com/nfnt/resize"
"github.com/sirupsen/logrus"
_ "embed" // Embed assets
)
type playing struct {
main display.Display
meta display.Display
status *player.Status
format *widget.Text
duration *widget.Text
progress *widget.Progress
track *widget.Scroller
art *widget.Image
artPlaceholder image.Image
spectrum *widget.Spectrum
visible bool
}
func Playing(main, meta display.Display, config *config.ScreenPlaying) ui.Screen {
var (
mainR = main.Bounds()
mainW = mainR.Dx()
mainW1_3 = mainW / 3 // 1/3rd of the width
mainW2_3 = mainW1_3 * 2 // 2/3rd of the width
mainH = mainR.Dy()
metaR = meta.Bounds()
metaW = uint(metaR.Dx())
metaH = uint(metaR.Dy())
styles = ui.StylesFor(main.ColorModel())
)
s := &playing{
main: main,
meta: meta,
format: widget.NewText(main, image.Pt(0, 0)).SetStyle(styles.Format).Set("Dunno"),
duration: widget.NewText(main, image.Pt(40, 0)).SetStyle(styles.Format).Set("--:-- / --:--"),
progress: widget.NewProgress(main, image.Pt(mainW2_3, 0), mainW1_3-1, 9).SetStyle(styles.Format),
track: widget.NewScroller(main, image.Pt(0, 10), 0, 32).SetStyle(styles.Track),
art: widget.NewImage(meta, image.Point{}, nil),
artPlaceholder: resize.Thumbnail(metaW, metaH, ui.MustDecodePNG(recordPNG), resize.Lanczos3),
spectrum: widget.NewSpectrum(main, image.Pt(0, mainH-24), mainW, 24),
}
s.configure(config, styles)
return s
}
func (s *playing) configure(config *config.ScreenPlaying, styles ui.Styles) {
if config == nil {
return
}
// Apply/load styles (if set).
if config.Track != nil {
config.Track.Apply(&styles.Track)
s.track.SetStyle(styles.Track)
}
if config.Format != nil {
config.Format.Apply(&styles.Format)
s.format.SetStyle(styles.Format)
s.duration.SetStyle(styles.Format)
s.progress.SetStyle(styles.Format)
}
// Configure spectrum analyzer
if config.Spectrum != nil {
s.spectrum.SetWaterwall(config.Spectrum.Waterfall)
if config.Spectrum.MinFrequency != 0 || config.Spectrum.MaxFrequency != 0 {
s.spectrum.SetRange(config.Spectrum.MinFrequency, config.Spectrum.MaxFrequency)
}
if config.Spectrum.Hold != 0 {
s.spectrum.SetHold(config.Spectrum.Hold)
}
}
}
func (s *playing) String() string {
return "playing"
}
func (s *playing) Widgets() []ui.Widget {
return []ui.Widget{
s.format,
s.duration,
s.progress,
s.track,
s.art,
s.spectrum,
}
}
func (s *playing) ProcessBuffer(buffer audio.Buffer[float64]) {
if !s.visible {
logrus.WithField("screen", "player").Debug("discarding buffer, not visible")
return
}
s.spectrum.ProcessBuffer(buffer)
}
func (s *playing) TrackChanged(source player.Player, track *player.Track) {
if track == nil || (track.Artist == "" && track.Title == "") {
s.format.Set("Idle")
s.track.Set("Not playing")
s.progress.Set(0)
s.art.Set(s.artPlaceholder)
return
}
// Update title.
if track.Artist != "" && track.Title != "" {
s.track.Set(track.Artist + " - " + track.Title)
} else if track.Title != "" {
s.track.Set("Unknown artist - " + track.Title)
} else if track.Artist != "" {
s.track.Set(track.Artist + " - Unknown")
}
// Update format.
s.format.Set(fmt.Sprintf("%-5s", track.Format))
// Update progress.
s.progress.Set(0)
// Update artwork.
log := logrus.WithField("screen", "playing")
if track.Image == nil {
log.Debug("track has no image, retrieving album art")
s.art.Set(s.artPlaceholder)
go s.artUpdate(source, track)
} else {
log.WithField("image", track.Image.Bounds().Size()).Debug("track has image, updating")
s.art.Set(track.Image)
}
}
func (s *playing) artUpdate(source player.Player, track *player.Track) {
log := logrus.WithField("screen", "playing")
if source != nil && track != nil {
a, ok := source.(player.AlbumArt)
if ok {
log.Debug("requesting album art from player")
i, ok := a.AlbumArt(track)
if ok {
log.WithField("image", i.Bounds().Size()).Debug("track has image, updating")
var (
r = s.meta.Bounds()
width = uint(r.Dx())
height = uint(r.Dy())
)
s.art.Set(resize.Thumbnail(width, height, i, resize.Lanczos3))
return
}
log.Debug("request didn't return an image, using fallback")
} else {
log.Debug("player doesn't support album art, using fallback")
}
}
// Fallback:
s.art.Set(s.artPlaceholder)
}
func (s *playing) StatusChanged(status *player.Status) {
/*
logrus.WithFields(logrus.Fields{
"screen": "playing",
"status": fmt.Sprintf("%#+v", status),
}).Debug("status changed")
*/
if status == nil {
s.TrackChanged(nil, nil)
s.duration.Set("--:-- / --:--")
s.progress.Set(0)
return
}
if status.Track.Duration > 0 {
s.duration.Set(fmt.Sprintf("%s / %s", formatDuration(status.Elapsed), formatDuration(status.Duration)))
s.progress.Set(float64(status.Elapsed) / float64(status.Duration))
} else {
s.duration.Set("--:-- / --:--")
s.progress.Set(0)
}
}
func (s *playing) SetVisible(visible bool) {
s.main.Clear()
s.meta.Clear()
if visible {
for _, widget := range s.Widgets() {
_ = widget.Render(true)
}
}
s.visible = visible
}
func formatDuration(d time.Duration) string {
m := int(d / time.Minute)
s := int((d - time.Duration(m)*time.Minute) / time.Second)
if m > 99 {
m = 99
}
return fmt.Sprintf("%02d:%02d", m, s)
}
//go:embed asset/record.png
var recordPNG []byte
+89
View File
@@ -0,0 +1,89 @@
package screen
import (
"image"
"sort"
"strings"
"github.com/BeatGlow/beatglow/config"
"github.com/BeatGlow/beatglow/player"
"github.com/BeatGlow/beatglow/ui"
"github.com/BeatGlow/beatglow/ui/widget"
"github.com/BeatGlow/display"
"github.com/sirupsen/logrus"
)
type playlist struct {
display display.Display
list *widget.List
player player.Player
status *player.Status
track *player.Track
}
func Playlist(main display.Display, config *config.ScreenPlaying) ui.Screen {
bounds := main.Bounds()
screen := &playlist{
list: widget.NewList(main, image.Point{}, bounds.Dx(), bounds.Dy()),
}
screen.configure(ui.StylesFor(main.ColorModel()).Format)
return screen
}
func (s *playlist) configure(style ui.Style) {
s.list.SetStyle(style)
}
func (playlist) String() string {
return "playlist"
}
func (s *playlist) Widgets() []ui.Widget {
return []ui.Widget{
s.list,
}
}
func (s *playlist) TrackChanged(source player.Player, track *player.Track) {
s.player = source
s.track = track
}
func (s *playlist) StatusChanged(status *player.Status) {
s.status = status
}
func (s *playlist) SetVisible(visible bool) {
s.display.Clear()
if visible {
if s.player != nil {
tracks, err := s.player.Playlist()
if err != nil {
logrus.WithError(err).Warn("error fetching playlist")
s.list.Index = 0
s.list.Items = nil
} else {
sort.Slice(tracks, func(i, j int) bool {
return strings.Compare(tracks[i].ID, tracks[j].ID) < 0
})
s.list.Index = 0
s.list.Items = make([]string, len(tracks))
for i, track := range tracks {
s.list.Items[i] = track.String()
if track.Eq(s.track) {
s.list.Index = i
}
}
}
} else {
s.list.Index = 0
s.list.Items = []string{"Player unavailable..."}
}
for _, widget := range s.Widgets() {
_ = widget.Render(true)
}
}
}
+99
View File
@@ -0,0 +1,99 @@
package screen
import (
"image"
"github.com/BeatGlow/audio"
"github.com/BeatGlow/audio/dsp"
"github.com/BeatGlow/beatglow/config"
"github.com/BeatGlow/beatglow/ui"
"github.com/BeatGlow/beatglow/ui/widget"
"github.com/BeatGlow/display"
)
type stereoSpectrum struct {
display display.Display
l, r *dsp.FrequencyPowerCalculator[float64]
waveform *widget.WaveForm
spectrum *widget.StereoSpectrum
visible bool
}
func StereoSpectrum(display display.Display, config *config.ScreenSpectrum) ui.Screen {
size := display.Bounds().Size()
const split = 24
s := &stereoSpectrum{
display: display,
waveform: widget.NewWaveform(display, image.Point{}, size.X, split),
spectrum: widget.NewStereoSpectrum(display, image.Pt(0, split), size.X, size.Y-split),
}
s.configure(config)
return s
}
func (s *stereoSpectrum) configure(config *config.ScreenSpectrum) {
if config == nil {
return
}
if config.MinFrequency != 0 || config.MaxFrequency != 0 {
s.spectrum.SetRange(config.MinFrequency, config.MaxFrequency)
}
if config.Hold != 0 {
s.spectrum.SetHold(config.Hold)
}
s.spectrum.SetWaterwall(config.Waterfall)
}
func (s *stereoSpectrum) String() string {
return "stereo spectrum"
}
func (s *stereoSpectrum) SetVisible(visible bool) {
s.visible = visible
}
func (s *stereoSpectrum) Widgets() []ui.Widget {
return []ui.Widget{
s.waveform,
s.spectrum,
}
}
func (s *stereoSpectrum) ProcessBuffer(buffer audio.Buffer[float64]) {
s.waveform.ProcessBuffer(buffer)
s.spectrum.ProcessBuffer(buffer)
}
type waveForm struct {
display display.Display
waveform *widget.WaveForm
visible bool
}
func WaveForm(display display.Display) ui.Screen {
size := display.Bounds().Size()
return &waveForm{
display: display,
waveform: widget.NewWaveform(display, image.Pt(0, 16), size.X, size.Y-16),
}
}
func (s *waveForm) String() string {
return "waveform"
}
func (s *waveForm) SetVisible(visible bool) {
s.visible = visible
}
func (s *waveForm) Widgets() []ui.Widget {
return []ui.Widget{
s.waveform,
}
}
func (s *waveForm) ProcessBuffer(buffer audio.Buffer[float64]) {
s.waveform.ProcessBuffer(buffer)
}
+73
View File
@@ -0,0 +1,73 @@
package screen
import (
"fmt"
"image"
"github.com/BeatGlow/beatglow/player"
"github.com/BeatGlow/beatglow/ui"
"github.com/BeatGlow/beatglow/ui/widget"
"github.com/BeatGlow/display"
)
type volume struct {
display display.Display
player player.Player
text *widget.Text
level *widget.Text
progress *widget.Progress
}
func Volume(player player.Player, display display.Display) ui.Screen {
var (
styles = ui.StylesFor(display.ColorModel())
size = display.Bounds().Size()
width = (size.X / 4) * 3
at = image.Pt((size.X-width)/2, size.Y-16)
)
return &volume{
display: display,
player: player,
text: widget.NewText(display, image.Pt(widget.CenterX, 0)).SetStyle(styles.Volume),
level: widget.NewText(display, image.Pt(widget.CenterX, int(styles.Volume.FontSize))).SetStyle(styles.Format),
progress: widget.NewProgress(display, at, width, 12),
}
}
func (volume) String() string {
return "volume"
}
func (s *volume) Widgets() []ui.Widget {
return []ui.Widget{
s.text,
s.progress,
}
}
func (s *volume) SetVisible(visible bool) {
if visible {
s.display.Clear()
s.text.Set("Player volume")
s.text.Render(true)
s.level.Render(true)
s.progress.Render(true)
}
}
func (s *volume) StatusChanged(status *player.Status) {
if status != nil {
if status.Volume == 0 {
s.level.Set("mute")
s.progress.Set(0)
} else {
s.level.Set(fmt.Sprintf("%3d%%", status.Volume))
s.progress.Set(float64(status.Volume) / 100)
}
}
}
var (
_ ui.Screen = (*volume)(nil)
_ player.StatusObserver = (*volume)(nil)
)