154 lines
3.6 KiB
Go
154 lines
3.6 KiB
Go
package moode
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"image"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/BeatGlow/beatglow/config"
|
|
"github.com/BeatGlow/beatglow/internal/util"
|
|
"github.com/BeatGlow/beatglow/player"
|
|
"github.com/BeatGlow/beatglow/player/mpd"
|
|
)
|
|
|
|
const (
|
|
DefaultHost = "localhost"
|
|
DefaultPort = "80"
|
|
DefaultAddr = DefaultHost + ":" + DefaultPort
|
|
currentSongFile = "/var/local/www/currentsong.txt"
|
|
)
|
|
|
|
type Player struct {
|
|
addr string
|
|
mpd *mpd.Player
|
|
isLocal bool
|
|
}
|
|
|
|
func New(config config.Player) (player.Player, error) {
|
|
addr := util.MakeAddr(config.Host, DefaultAddr)
|
|
|
|
return &Player{
|
|
addr: addr,
|
|
}, nil
|
|
}
|
|
|
|
func (p *Player) Halt() error { return p.mpd.Halt() }
|
|
func (Player) Type() string { return "moode" }
|
|
func (p *Player) Name() string { return "moOde" }
|
|
func (p *Player) Next() error { return p.mpd.Next() }
|
|
func (p *Player) Previous() error { return p.mpd.Previous() }
|
|
func (p *Player) Play() error { return p.mpd.Play() }
|
|
func (p *Player) Pause() error { return p.mpd.Pause() }
|
|
func (p *Player) Seek(d time.Duration) error { return p.mpd.Seek(d) }
|
|
func (p *Player) ChangeVolume(delta int) error { return p.mpd.ChangeVolume(delta) }
|
|
func (p *Player) SetVolume(level int) error { return p.mpd.SetVolume(level) }
|
|
func (p *Player) ToggleMute() error { return p.mpd.ToggleMute() }
|
|
|
|
func (p *Player) Events() (<-chan player.Event, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (p *Player) AlbumArt(t *player.Track) (image.Image, bool) {
|
|
return p.mpd.AlbumArt(t)
|
|
}
|
|
|
|
func (p *Player) Playlist() ([]*player.Track, error) {
|
|
return p.mpd.Playlist()
|
|
}
|
|
|
|
func (Player) Status() *player.Status {
|
|
s, _ := parseStatus(currentSongFile)
|
|
return s
|
|
}
|
|
|
|
func parseStatus(name string) (*player.Status, error) {
|
|
if name == "" {
|
|
name = currentSongFile
|
|
}
|
|
|
|
f, err := os.Open(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
scanner := bufio.NewScanner(f)
|
|
scanner.Split(bufio.ScanLines)
|
|
|
|
status := &player.Status{Track: new(player.Track)}
|
|
for scanner.Scan() {
|
|
if err = scanner.Err(); err != nil {
|
|
break
|
|
}
|
|
|
|
line := scanner.Text()
|
|
if line == "" {
|
|
continue
|
|
} else if i := strings.Index(line, "="); i > 0 {
|
|
k, v := line[:i], line[i+1:]
|
|
switch k {
|
|
case "file":
|
|
status.Track.Path = v
|
|
case "artist":
|
|
status.Track.Artist = v
|
|
case "album":
|
|
status.Track.Album = v
|
|
case "title":
|
|
status.Track.Title = v
|
|
case "state":
|
|
switch v {
|
|
case "play":
|
|
status.Playing = true
|
|
status.Paused = false
|
|
case "pause":
|
|
status.Playing = true
|
|
status.Paused = true
|
|
case "stop":
|
|
status.Playing = false
|
|
status.Paused = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return status, err
|
|
}
|
|
|
|
// parseAudioFormat takes a moOde notated audio format
|
|
//
|
|
// PCM 16/44.1 kHz, 2ch
|
|
// FLAC 16/48.0 kHz, 2ch
|
|
func parseAudioFormat(s string) (f player.AudioFormat, err error) {
|
|
var i int
|
|
|
|
if i = strings.IndexByte(s, ' '); i == -1 {
|
|
return f, fmt.Errorf("moode: unknown audio format %q", s)
|
|
}
|
|
f.Encoding, s = s[:i], s[i+1:]
|
|
|
|
if i = strings.IndexByte(s, '/'); i == -1 {
|
|
return f, fmt.Errorf("moode: unknown audio format %q", s)
|
|
}
|
|
if f.Bits, err = strconv.Atoi(s[:i]); err != nil {
|
|
return
|
|
}
|
|
s = s[i+1:] // "xx.y kHz, nch"
|
|
|
|
if i = strings.IndexByte(s, ','); i == -1 {
|
|
return f, fmt.Errorf("moode: unknown audio format %q", s)
|
|
}
|
|
if f.SampleRate, err = util.ParseFrequency(strings.Replace(s[:i], " ", "", 1)); err != nil {
|
|
return
|
|
}
|
|
s = strings.TrimSpace(s[i+1:]) // "nch"
|
|
|
|
if f.Channels, err = strconv.Atoi(s[:1]); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|