291 lines
7.3 KiB
Go
291 lines
7.3 KiB
Go
package layout
|
|
|
|
import (
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
"periph.io/x/conn/v3/physic"
|
|
|
|
"github.com/BeatGlow/audio"
|
|
|
|
"github.com/BeatGlow/beatglow/app"
|
|
"github.com/BeatGlow/beatglow/app/font"
|
|
"github.com/BeatGlow/beatglow/app/widget"
|
|
"github.com/BeatGlow/beatglow/player"
|
|
|
|
_ "embed"
|
|
)
|
|
|
|
const (
|
|
// "FLAC@192k "
|
|
// "FLAC@44.1k"
|
|
formatTextPlaceholder = "No track "
|
|
durationTextPlaceholder = "--:-- / --:--"
|
|
trackTextPlaceholder = "No track playing"
|
|
iconTextPlaceholder = string(font.IconPhones)
|
|
)
|
|
|
|
type playing struct {
|
|
base
|
|
phonesWidget *widget.Text
|
|
formatRate bool
|
|
formatText string
|
|
formatWidget *widget.Text
|
|
durationText string
|
|
durationWidget *widget.Text
|
|
track *player.Track
|
|
trackText string
|
|
trackWidget *widget.Text
|
|
iconText string
|
|
iconWidget *widget.Text
|
|
artWidget *widget.Image
|
|
spectrumWidget *widget.Spectrum
|
|
}
|
|
|
|
const playingWaterfallHeight = 32
|
|
|
|
func Playing(ctx app.Context) app.Layout {
|
|
bounds := ctx.Display().Bounds()
|
|
styles := app.StylesFor(ctx.Display().ColorModel())
|
|
layout := &playing{
|
|
base: base{name: "playing"},
|
|
phonesWidget: widget.NewText(image.Pt(10, 12)),
|
|
formatText: formatTextPlaceholder,
|
|
formatWidget: widget.NewText(image.Pt(2+len(formatTextPlaceholder)*9, 12)),
|
|
durationText: durationTextPlaceholder,
|
|
durationWidget: widget.NewText(image.Pt(2+len(durationTextPlaceholder)*9, 12)),
|
|
trackText: trackTextPlaceholder,
|
|
trackWidget: widget.NewText(image.Pt(bounds.Dx()-bounds.Dy(), bounds.Dy()-12-playingWaterfallHeight)),
|
|
iconText: iconTextPlaceholder,
|
|
iconWidget: widget.NewText(image.Pt(10, 12)),
|
|
artWidget: widget.NewImage(image.Pt(bounds.Dy(), bounds.Dy())),
|
|
spectrumWidget: widget.NewSpectrum(image.Pt(bounds.Dx()-bounds.Dy(), playingWaterfallHeight)),
|
|
}
|
|
|
|
var (
|
|
formatStyle = styles.Text.WithFont(font.Spleen6x12)
|
|
iconStyle = styles.Text.WithFont(font.SM4TIK).WithForegroundColor(color.Gray{0x3f})
|
|
durationStyle = formatStyle
|
|
titleStyle = styles.Text.WithFont(font.Montserrat.WithPointSize(20))
|
|
offset int
|
|
)
|
|
|
|
layout.phonesWidget.
|
|
SetStyle(iconStyle).
|
|
Update(string(font.IconNote)).
|
|
Resize(measureString(iconStyle.Font, iconTextPlaceholder)).
|
|
Move(image.Pt(offset, -3))
|
|
offset += 10
|
|
|
|
layout.formatWidget.
|
|
SetStyle(formatStyle).
|
|
Bind(&layout.formatText).
|
|
Resize(measureString(formatStyle.Font, formatTextPlaceholder)).
|
|
Move(image.Pt(offset, 0))
|
|
offset += layout.formatWidget.Bounds().Dx() + 10
|
|
|
|
layout.iconWidget.
|
|
SetStyle(iconStyle).
|
|
Bind(&layout.iconText).
|
|
Resize(measureString(iconStyle.Font, iconTextPlaceholder)).
|
|
Move(image.Pt(offset, -3))
|
|
offset += 10
|
|
|
|
layout.durationWidget.
|
|
SetStyle(durationStyle).
|
|
Bind(&layout.durationText).
|
|
Resize(measureString(formatStyle.Font, durationTextPlaceholder)).
|
|
Move(image.Pt(offset, 0))
|
|
|
|
layout.trackWidget.
|
|
SetStyle(titleStyle).
|
|
SetScroll(1, 8, time.Second/20).
|
|
Bind(&layout.trackText).
|
|
Move(image.Pt(0, 12))
|
|
|
|
layout.artWidget.
|
|
Move(image.Pt(bounds.Dx()-bounds.Dy(), 0))
|
|
|
|
layout.spectrumWidget.
|
|
SetWaterfall(false).
|
|
SetChannels(2).
|
|
SetStyles(*styles).
|
|
Move(image.Pt(0, bounds.Dy()-playingWaterfallHeight))
|
|
|
|
layout.widgets = []app.Widget{
|
|
layout.phonesWidget,
|
|
layout.formatWidget,
|
|
layout.iconWidget,
|
|
layout.durationWidget,
|
|
layout.trackWidget,
|
|
layout.artWidget,
|
|
layout.spectrumWidget,
|
|
}
|
|
|
|
return layout
|
|
}
|
|
|
|
/*
|
|
func (l *playing) log() *logrus.Entry {
|
|
return logrus.WithField("layout", "playing")
|
|
}
|
|
|
|
|
|
func (playing) String() string {
|
|
return "playing"
|
|
}
|
|
|
|
func (l *playing) Hide(ctx app.Context) {
|
|
log := l.log()
|
|
log.Debug("hide")
|
|
for _, widget := range l.Widgets() {
|
|
log.WithField("widget", widget.String()).Debug("hide widget")
|
|
_ = widget.Hide(ctx)
|
|
}
|
|
}
|
|
|
|
func (l *playing) Show(ctx app.Context) {
|
|
log := l.log()
|
|
log.Debug("show")
|
|
for _, widget := range l.Widgets() {
|
|
log.WithField("widget", widget.String()).Debug("show widget")
|
|
_ = widget.Show(ctx)
|
|
}
|
|
}
|
|
|
|
func (l *playing) Widgets() []app.Widget {
|
|
return []app.Widget{
|
|
l.phonesWidget,
|
|
l.formatWidget,
|
|
l.iconWidget,
|
|
l.durationWidget,
|
|
l.trackWidget,
|
|
l.artWidget,
|
|
l.spectrumWidget,
|
|
}
|
|
}
|
|
*/
|
|
|
|
func (l *playing) TrackChanged(ctx app.Context, track *player.Track) {
|
|
if track == nil {
|
|
l.formatText = formatTextPlaceholder
|
|
l.durationText = durationTextPlaceholder
|
|
l.trackText = trackTextPlaceholder
|
|
} else {
|
|
l.trackText = formatTrack(track)
|
|
l.formatRate = false
|
|
l.formatText = strings.ToUpper(track.Format)
|
|
}
|
|
|
|
if !track.Eq(l.track) {
|
|
l.track = track
|
|
l.artWidget.Update(beatglowLogo, ctx.Display().ColorModel())
|
|
go l.updateArt(ctx, track)
|
|
}
|
|
}
|
|
|
|
func (l *playing) updateArt(ctx app.Context, track *player.Track) {
|
|
log := logrus.WithField("track", track)
|
|
if fetcher, ok := ctx.Player().(player.AlbumArt); ok {
|
|
if image, ok := fetcher.AlbumArt(track); ok {
|
|
log.WithField("size", image.Bounds().Size()).Debug("updating album art")
|
|
l.artWidget.Update(image, ctx.Display().ColorModel())
|
|
return
|
|
}
|
|
}
|
|
log.Debug("updating album art failed: unavailable")
|
|
}
|
|
|
|
func (l *playing) StatusChanged(ctx app.Context, status *player.Status) {
|
|
if status == nil {
|
|
l.formatText = formatTextPlaceholder
|
|
l.durationText = durationTextPlaceholder
|
|
l.trackText = trackTextPlaceholder
|
|
l.iconText = string(font.IconBug)
|
|
return
|
|
}
|
|
|
|
if status.Paused {
|
|
l.iconText = string(font.IconPause)
|
|
} else if status.Playing {
|
|
l.iconText = string(font.IconPlay)
|
|
} else {
|
|
l.iconText = string(font.IconStop)
|
|
}
|
|
|
|
if status.Duration > 0 {
|
|
l.durationText = fmt.Sprintf("%s / %s", formatDuration(status.Elapsed), formatDuration(status.Duration))
|
|
}
|
|
|
|
if status.Track != nil {
|
|
if l.formatRate {
|
|
l.formatText = fmt.Sprintf("%04d@%s", status.Format.BitRate, formatRate(status.Format.SampleRate))
|
|
} else {
|
|
l.formatText = fmt.Sprintf("%-4s@%s", strings.ToUpper(status.Track.Format), formatRate(status.Format.SampleRate))
|
|
}
|
|
l.formatRate = !l.formatRate
|
|
}
|
|
}
|
|
|
|
func (l *playing) ProcessBuffer(buffer audio.Buffer[float64]) {
|
|
if l.spectrumWidget.IsVisible() {
|
|
l.spectrumWidget.ProcessBuffer(buffer)
|
|
}
|
|
}
|
|
|
|
func measureString(font font.Font, text string) image.Point {
|
|
width, height := font.MeasureString(text)
|
|
return image.Pt(width, height)
|
|
}
|
|
|
|
func formatDuration(d time.Duration) string {
|
|
m := int(d / time.Minute)
|
|
d -= time.Duration(m) * time.Minute
|
|
s := int(d / time.Second)
|
|
return fmt.Sprintf("%02d:%02d", m, s)
|
|
}
|
|
|
|
func formatTrack(track *player.Track) string {
|
|
var artist, title string
|
|
if artist = track.Artist; artist == "" {
|
|
artist = "Unknown Artist"
|
|
}
|
|
if title = track.Title; title == "" {
|
|
title = "Unknown Title"
|
|
}
|
|
return artist + " - " + title
|
|
}
|
|
|
|
func formatRate(rate physic.Frequency) string {
|
|
if rate > physic.MegaHertz {
|
|
m := rate / physic.MegaHertz
|
|
k := (rate - m*physic.MegaHertz) / 100
|
|
if m > 100 {
|
|
return fmt.Sprintf("%dm", int(m))
|
|
}
|
|
return fmt.Sprintf("%d.%1dm", int(m), int(k))
|
|
} else if rate > physic.KiloHertz {
|
|
v := float64(rate) / float64(physic.KiloHertz)
|
|
if v >= 100 {
|
|
return fmt.Sprintf("%dk", int(v))
|
|
}
|
|
return fmt.Sprintf("%03.1fk", v)
|
|
}
|
|
return fmt.Sprintf("%dh", rate/physic.Hertz)
|
|
}
|
|
|
|
var (
|
|
_ app.StatusChangeHandler = (*playing)(nil)
|
|
_ app.TrackChangeHandler = (*playing)(nil)
|
|
_ app.BufferProcessor = (*playing)(nil)
|
|
|
|
//go:embed asset/beatglow.png
|
|
beatglowPNG []byte
|
|
|
|
beatglowLogo = app.MustDecodeImage(beatglowPNG)
|
|
)
|