Checkpoint

This commit is contained in:
maze authored and maze committed 2026-10-29 17:28:51 +01:00
1 parent 7b6db17870
commit 0295eb1ad2
125 files changed
+59376

No files matched your search

+465
View File
@@ -0,0 +1,465 @@
package mpd
import (
"fmt"
"net"
"net/textproto"
"strconv"
"strings"
"time"
"git.maze.io/go/bragi/config"
"git.maze.io/go/bragi/player"
"git.maze.io/go/bragi/util"
"github.com/sirupsen/logrus"
)
func init() {
player.Register("mpd", func(config *config.Player) (player.Player, error) {
return New(config.Host, config.Password, config.Name)
}, Detect, 10)
}
const (
DefaultPort = "6600"
DefaultAddr = "localhost:" + DefaultPort
)
type Player struct {
// Version is the server protocol version.
Version Version
name string
addr string
password string
idleSubsystems []string
commands chan *Command
errors chan error
quit chan struct{}
}
type clientConn struct {
*textproto.Conn
name string
}
func (c *clientConn) log() *logrus.Entry {
return logrus.WithFields(logrus.Fields{
"protocol": "mpd",
"loop": c.name,
})
}
// Version number.
type Version struct {
Major int
Minor int
Patch int
}
func (v Version) String() string {
return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
}
func versionError(s string) error {
return fmt.Errorf("mpd: unexpected version %q", s)
}
func ParseVersion(s string) (Version, error) {
part := strings.Split(s, ".")
if len(part) != 3 {
return Version{}, versionError(s)
}
var (
v Version
err error
)
if v.Major, err = strconv.Atoi(part[0]); err != nil {
return Version{}, err
}
if v.Minor, err = strconv.Atoi(part[1]); err != nil {
return Version{}, err
}
if v.Patch, err = strconv.Atoi(part[2]); err != nil {
return Version{}, err
}
return v, nil
}
func New(addr, password, name string) (*Player, error) {
addr = util.MakeAddr(addr, DefaultAddr)
if _, err := net.ResolveTCPAddr("tcp", addr); err != nil {
return nil, err
}
p := &Player{
name: name,
addr: addr,
commands: make(chan *Command, 16),
errors: make(chan error, 1),
quit: make(chan struct{}, 2),
}
return p, nil
}
func newConn(addr, password, kind, name string) (*clientConn, *Version, error) {
log := logrus.WithFields(logrus.Fields{
"protocol": "mpd",
"player": name,
"addr": addr,
"conn": kind,
})
if addr == "" {
addr = DefaultAddr
}
log.Info("connecting to Music Player Daemon")
conn, err := textproto.Dial("tcp", addr)
if err != nil {
return nil, nil, err
}
line, err := conn.ReadLine()
if err != nil {
return nil, nil, err
}
log.WithField("response", line).Trace("reading server hello")
if !strings.HasPrefix(line, "OK MPD ") {
_ = conn.Close()
return nil, nil, fmt.Errorf("mpd: unexpected server greeting %q", line)
}
version, err := ParseVersion(line[7:])
if err != nil {
_ = conn.Close()
return nil, nil, fmt.Errorf("mpd: unexpected server version %q: %w", line[6:], err)
}
if password != "" {
log.Debug("sending password")
id, err := conn.Cmd("password %s", password)
if err != nil {
_ = conn.Close()
return nil, nil, err
}
conn.StartResponse(id)
defer conn.EndResponse(id)
if line, err = conn.ReadLine(); err != nil {
_ = conn.Close()
return nil, nil, err
}
log.WithField("response", line).Trace("reading server password response")
if line != "OK" {
_ = conn.Close()
return nil, nil, fmt.Errorf("mpd: unexpected response to password: %q", line)
}
}
return &clientConn{conn, kind}, &version, nil
}
func (p *Player) Close() error {
for i := 0; i < 2; i++ {
select {
case p.quit <- struct{}{}:
default:
}
}
select {
case err := <-p.errors:
return err
default:
return nil
}
}
func (p *Player) sendCommand(conn *clientConn, format string, args ...interface{}) (err error) {
log := conn.log().WithField("command", fmt.Sprintf(format, args...))
log.Trace("sending command")
var id uint
if id, err = conn.Cmd(format, args...); err != nil {
log.WithError(err).Warn("command failed")
return
}
log = log.WithField("id", id)
log.Trace("start response")
conn.StartResponse(id)
for {
var line string
if line, err = conn.ReadLine(); err != nil {
log.WithError(err).Warn("command response read failed")
break
}
log.WithField("data", line).Trace("command response")
if line == "OK" {
break
}
}
log.Trace("end response")
conn.EndResponse(id)
return
}
func (p *Player) sendCommandList(conn *clientConn, commands []Command) (err error) {
log := conn.log()
log.Trace("sending command list")
if len(commands) == 0 {
return
}
id := conn.Next()
conn.StartRequest(id)
if err = conn.PrintfLine("command_list_begin"); err != nil {
return
}
for _, command := range commands {
if err = conn.PrintfLine(command.Format, command.Args...); err != nil {
conn.EndRequest(id)
return
}
}
if err = conn.PrintfLine("command_list_end"); err != nil {
return
}
conn.EndRequest(id)
log = log.WithField("id", id)
log.Trace("start response")
conn.StartResponse(id)
conn.EndResponse(id)
return
}
func (p *Player) sendMapCommand(conn *clientConn, format string, args ...interface{}) (kv map[string]string, err error) {
log := conn.log().WithField("command", fmt.Sprintf(format, args...))
log.Trace("sending map command")
var id uint
if id, err = conn.Cmd(format, args...); err != nil {
log.WithError(err).Warn("map command failed")
return
}
log = log.WithField("id", id)
log.Trace("start map response")
conn.StartResponse(id)
kv = make(map[string]string)
for {
var line string
if line, err = conn.ReadLine(); err != nil {
log.WithError(err).Warn("command response read failed")
break
}
log.WithField("data", line).Trace("command response")
if line == "OK" {
break
} else if i := strings.Index(line, ": "); i > 0 {
kv[line[:i]] = line[i+2:]
}
}
log.Trace("end map response")
conn.EndResponse(id)
return
}
func (p *Player) run(events chan player.Event) {
log := logrus.WithFields(logrus.Fields{
"protocol": "mpd",
})
log.Info("starting client")
events <- player.NewDisconnectedEvent(p)
for {
main, version, err := newConn(p.addr, p.password, "main", p.name)
if err != nil {
log.WithError(err).Warn("connection failed; retrying")
time.Sleep(time.Second)
continue
}
main.log().WithField("version", version).Info("connected to Music Player Daemon")
idle, _, err := newConn(p.addr, p.password, "idle", p.name)
if err != nil {
_ = main.Close()
log.WithError(err).Warn("connection failed; retrying")
time.Sleep(time.Second)
continue
}
p.commands = make(chan *Command)
p.errors = make(chan error)
p.quit = make(chan struct{}, 2)
events <- player.NewConnectedEvent(p)
go p.idleLoop(idle)
p.mainLoop(main, events)
events <- player.NewDisconnectedEvent(p)
_ = idle.Close()
_ = main.Close()
close(p.commands)
close(p.errors)
}
log.Warn("client terminating")
}
func (p *Player) mainLoop(conn *clientConn, events chan player.Event) {
defer func() {
_ = conn.Close()
}()
log := conn.log()
log.Debug("starting loop")
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
var err error
loop:
for {
select {
case command := <-p.commands:
if command == nil {
break loop
}
if err = p.sendCommand(conn, command.Format, command.Args...); err != nil {
command.Err <- err
break loop
} else {
command.Err <- nil
}
case <-ticker.C:
var status map[string]string
if status, err = p.sendMapCommand(conn, "status"); err != nil {
log.WithError(err).Error("error retrieving status")
break loop
}
log.WithField("status", status).Debug("status")
var track map[string]string
if track, err = p.sendMapCommand(conn, "currentsong"); err != nil {
log.WithError(err).Error("error retrieving current song")
break loop
}
events <- player.NewStatusEvent(p, parseStatus(p, status, track))
case <-p.quit:
break loop
}
}
if err != nil {
log.WithError(err).Error("main loop terminating")
select {
case p.errors <- err:
default:
}
} else {
log.Info("main loop terminating")
}
select {
case p.quit <- struct{}{}:
default:
}
}
func (p *Player) Events() (<-chan player.Event, error) {
events := make(chan player.Event)
go p.run(events)
return events, nil
}
func (Player) Status() *player.Status {
return nil
}
func (p *Player) Name() string {
return p.name
}
func (p *Player) Command(format string, args ...interface{}) error {
command := newCommand(format, args...)
p.commands <- command
return <-command.Err
}
func (p *Player) Play() error { return p.Command("play") }
func (p *Player) Pause() error { return p.Command("pause") }
func (p *Player) Next() error { return p.Command("next") }
func (p *Player) Previous() error { return p.Command("previous") }
func (p *Player) Seek(d time.Duration) error { return p.Command("seekcur %f", d.Seconds()) }
type Command struct {
Format string
Args []interface{}
Err chan error
}
func newCommand(format string, args ...interface{}) *Command {
return &Command{
Format: format,
Args: args,
Err: make(chan error),
}
}
func parseStatus(p player.Player, status, track map[string]string) *player.Status {
s := &player.Status{
Player: p,
}
s.Source, _ = player.ParseMPDAudioFormat(status["audio"])
s.Source.BitRate, _ = strconv.Atoi(status["bitrate"])
s.Elapsed, _ = time.ParseDuration(status["elapsed"] + "s")
s.Volume, _ = strconv.Atoi(status["volume"])
switch status["state"] {
case "play":
s.Playing = true
s.Paused = false
case "pause":
s.Playing = true
s.Paused = false
}
s.Repeat = status["repeat"] == "1"
s.Shuffle = status["shuffle"] == "1"
// Parse track information.
s.Track, s.Source = parseTrack(track)
return s
}
func parseTrack(data map[string]string) (*player.Track, player.AudioFormat) {
track := &player.Track{
Artist: data["Artist"],
Title: data["Title"],
Album: data["Album"],
Label: data["Label"],
Genre: strings.Split(data["Genra"], ";"),
Path: data["file"],
}
track.Track, _ = strconv.Atoi(data["Track"])
track.Disc, _ = strconv.Atoi(data["Disc"])
track.Date, _ = time.Parse("2006-02-01", data["Date"])
track.Duration, _ = time.ParseDuration(data["duration"] + "s")
audio, _ := player.ParseMPDAudioFormat(data["Format"])
return track, audio
}