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

+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