658 lines
14 KiB
Go
658 lines
14 KiB
Go
package mpv
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"os/exec"
|
|
"runtime"
|
|
"seanime/internal/mediaplayers/mpvipc"
|
|
"seanime/internal/util"
|
|
"seanime/internal/util/result"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/rs/zerolog"
|
|
)
|
|
|
|
type (
|
|
Playback struct {
|
|
Filename string
|
|
Paused bool
|
|
Position float64
|
|
Duration float64
|
|
IsRunning bool
|
|
Filepath string
|
|
}
|
|
|
|
Mpv struct {
|
|
Logger *zerolog.Logger
|
|
Playback *Playback
|
|
SocketName string
|
|
AppPath string
|
|
Args string
|
|
mu sync.Mutex
|
|
playbackMu sync.RWMutex
|
|
cancel context.CancelFunc // Cancel function for the context
|
|
subscribers *result.Map[string, *Subscriber] // Subscribers to the mpv events
|
|
conn *mpvipc.Connection // Reference to the mpv connection
|
|
cmd *exec.Cmd
|
|
prevSocketName string
|
|
exitedCh chan struct{}
|
|
}
|
|
|
|
// Subscriber is a subscriber to the mpv events.
|
|
// Make sure the subscriber listens to both channels, otherwise it will deadlock.
|
|
Subscriber struct {
|
|
eventCh chan *mpvipc.Event
|
|
closedCh chan struct{}
|
|
}
|
|
)
|
|
|
|
var cmdCtx, cmdCancel = context.WithCancel(context.Background())
|
|
|
|
func New(logger *zerolog.Logger, socketName string, appPath string, optionalArgs ...string) *Mpv {
|
|
if cmdCancel != nil {
|
|
cmdCancel()
|
|
}
|
|
|
|
sn := socketName
|
|
if socketName == "" {
|
|
sn = getDefaultSocketName()
|
|
}
|
|
|
|
additionalArgs := ""
|
|
if len(optionalArgs) > 0 {
|
|
additionalArgs = optionalArgs[0]
|
|
}
|
|
|
|
return &Mpv{
|
|
Logger: logger,
|
|
Playback: &Playback{},
|
|
mu: sync.Mutex{},
|
|
playbackMu: sync.RWMutex{},
|
|
SocketName: sn,
|
|
AppPath: appPath,
|
|
Args: additionalArgs,
|
|
subscribers: result.NewResultMap[string, *Subscriber](),
|
|
exitedCh: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
func (m *Mpv) GetExecutablePath() string {
|
|
if m.AppPath != "" {
|
|
return m.AppPath
|
|
}
|
|
return "mpv"
|
|
}
|
|
|
|
// launchPlayer starts the mpv player and plays the file.
|
|
// If the player is already running, it just loads the new file.
|
|
func (m *Mpv) launchPlayer(idle bool, filePath string, args ...string) error {
|
|
var err error
|
|
|
|
m.Logger.Trace().Msgf("mpv: Launching player with args: %+v", args)
|
|
|
|
// Cancel previous goroutine context
|
|
if m.cancel != nil {
|
|
m.Logger.Trace().Msg("mpv: Cancelling previous context")
|
|
m.cancel()
|
|
}
|
|
// Cancel previous command context
|
|
if cmdCancel != nil {
|
|
m.Logger.Trace().Msg("mpv: Cancelling previous command context")
|
|
cmdCancel()
|
|
}
|
|
cmdCtx, cmdCancel = context.WithCancel(context.Background())
|
|
|
|
m.Logger.Debug().Msg("mpv: Starting player")
|
|
if idle {
|
|
args = append(args, "--input-ipc-server="+m.SocketName, "--idle")
|
|
m.cmd, err = m.createCmd("", args...)
|
|
} else {
|
|
args = append(args, "--input-ipc-server="+m.SocketName)
|
|
m.cmd, err = m.createCmd(filePath, args...)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.prevSocketName = m.SocketName
|
|
|
|
// Create a pipe for stdout
|
|
stdoutPipe, err := m.cmd.StdoutPipe()
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to create stdout pipe")
|
|
return err
|
|
}
|
|
|
|
err = m.cmd.Start()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
wg := sync.WaitGroup{}
|
|
wg.Add(1)
|
|
|
|
receivedLog := false
|
|
|
|
go func() {
|
|
scanner := bufio.NewScanner(stdoutPipe)
|
|
for scanner.Scan() {
|
|
// Skip AV messages
|
|
if bytes.Contains(scanner.Bytes(), []byte("AV:")) {
|
|
continue
|
|
}
|
|
line := strings.TrimSpace(scanner.Text())
|
|
if line != "" {
|
|
if !receivedLog {
|
|
receivedLog = true
|
|
wg.Done()
|
|
}
|
|
m.Logger.Trace().Msg("mpv cmd: " + line) // Print to logger
|
|
}
|
|
}
|
|
if err := scanner.Err(); err != nil {
|
|
if strings.Contains(err.Error(), "file already closed") {
|
|
m.Logger.Debug().Msg("mpv: File closed")
|
|
//close(m.exitedCh)
|
|
//m.exitedCh = make(chan struct{})
|
|
} else {
|
|
m.Logger.Error().Err(err).Msg("mpv: Error reading from stdout")
|
|
}
|
|
}
|
|
}()
|
|
|
|
go func() {
|
|
err := m.cmd.Wait()
|
|
if err != nil {
|
|
m.Logger.Warn().Err(err).Msg("mpv: Player has exited")
|
|
}
|
|
}()
|
|
|
|
wg.Wait()
|
|
time.Sleep(1 * time.Second)
|
|
|
|
m.Logger.Debug().Msg("mpv: Player started")
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Mpv) replaceFile(filePath string) error {
|
|
m.Logger.Debug().Msg("mpv: Replacing file")
|
|
|
|
if m.conn != nil && !m.conn.IsClosed() {
|
|
_, err := m.conn.Call("loadfile", filePath, "replace")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Mpv) Exited() chan struct{} {
|
|
return m.exitedCh
|
|
}
|
|
|
|
func (m *Mpv) OpenAndPlay(filePath string, args ...string) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
m.Playback = &Playback{}
|
|
|
|
// If the player is already running, just load the new file
|
|
var err error
|
|
if m.conn != nil && !m.conn.IsClosed() {
|
|
// Launch player or replace file
|
|
err = m.replaceFile(filePath)
|
|
} else {
|
|
// Launch player
|
|
err = m.launchPlayer(false, filePath, args...)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Create context for the connection
|
|
// When the cancel method is called (by launchPlayer), the previous connection will be closed
|
|
var ctx context.Context
|
|
ctx, m.cancel = context.WithCancel(context.Background())
|
|
|
|
// Establish new connection, only if it doesn't exist
|
|
// We don't continue past this point if the connection is already open, because it means the goroutine is already running
|
|
if m.conn != nil && !m.conn.IsClosed() {
|
|
return nil
|
|
}
|
|
|
|
err = m.establishConnection()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// // Reset subscriber's done channel in case it was closed
|
|
// m.subscribers.Range(func(key string, sub *Subscriber) bool {
|
|
// sub.eventCh = make(chan *mpvipc.Event)
|
|
// return true
|
|
// })
|
|
|
|
m.Playback.IsRunning = false
|
|
|
|
// Listen for events in a goroutine
|
|
go m.listenForEvents(ctx)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Mpv) Pause() error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
if m.conn == nil || m.conn.IsClosed() {
|
|
return errors.New("mpv is not running")
|
|
}
|
|
|
|
_, err := m.conn.Call("set_property", "pause", true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Mpv) Resume() error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
if m.conn == nil || m.conn.IsClosed() {
|
|
return errors.New("mpv is not running")
|
|
}
|
|
|
|
_, err := m.conn.Call("set_property", "pause", false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SeekTo seeks to the given position in the file by first pausing the player and unpausing it after seeking.
|
|
func (m *Mpv) SeekTo(position float64) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
if m.conn == nil || m.conn.IsClosed() {
|
|
return errors.New("mpv is not running")
|
|
}
|
|
|
|
// pause the player
|
|
_, err := m.conn.Call("set_property", "pause", true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
_, err = m.conn.Call("set_property", "time-pos", position)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
// unpause the player
|
|
_, err = m.conn.Call("set_property", "pause", false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Seek seeks to the given position in the file.
|
|
func (m *Mpv) Seek(position float64) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
if m.conn == nil || m.conn.IsClosed() {
|
|
return errors.New("mpv is not running")
|
|
}
|
|
|
|
_, err := m.conn.Call("set_property", "time-pos", position)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Mpv) GetOpenConnection() (*mpvipc.Connection, error) {
|
|
if m.conn == nil || m.conn.IsClosed() {
|
|
return nil, errors.New("mpv is not running")
|
|
}
|
|
return m.conn, nil
|
|
}
|
|
|
|
func (m *Mpv) establishConnection() error {
|
|
tries := 1
|
|
for {
|
|
m.conn = mpvipc.NewConnection(m.SocketName)
|
|
err := m.conn.Open()
|
|
if err != nil {
|
|
if tries >= 5 {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to establish connection")
|
|
return err
|
|
}
|
|
m.Logger.Error().Err(err).Msgf("mpv: Failed to establish connection (%d/4), retrying...", tries)
|
|
tries++
|
|
time.Sleep(1 * time.Second)
|
|
continue
|
|
}
|
|
m.Logger.Debug().Msg("mpv: Connection established")
|
|
break
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Mpv) listenForEvents(ctx context.Context) {
|
|
// Close the connection when the goroutine ends
|
|
defer func() {
|
|
m.Logger.Debug().Msg("mpv: Closing socket connection")
|
|
m.conn.Close()
|
|
m.terminate()
|
|
m.Logger.Debug().Msg("mpv: Instance closed")
|
|
}()
|
|
|
|
events, stopListening := m.conn.NewEventListener()
|
|
m.Logger.Debug().Msg("mpv: Listening for events")
|
|
|
|
_, err := m.conn.Get("path")
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to get path")
|
|
return
|
|
}
|
|
|
|
_, err = m.conn.Call("observe_property", 42, "time-pos")
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to observe time-pos")
|
|
return
|
|
}
|
|
_, err = m.conn.Call("observe_property", 43, "pause")
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to observe pause")
|
|
return
|
|
}
|
|
_, err = m.conn.Call("observe_property", 44, "duration")
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to observe duration")
|
|
return
|
|
}
|
|
_, err = m.conn.Call("observe_property", 45, "filename")
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to observe filename")
|
|
return
|
|
}
|
|
_, err = m.conn.Call("observe_property", 46, "path")
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to observe path")
|
|
return
|
|
}
|
|
|
|
// Listen for close event
|
|
go func() {
|
|
m.conn.WaitUntilClosed()
|
|
m.Logger.Debug().Msg("mpv: Connection has been closed")
|
|
stopListening <- struct{}{}
|
|
}()
|
|
|
|
go func() {
|
|
// When the context is cancelled, close the connection
|
|
<-ctx.Done()
|
|
m.Logger.Debug().Msg("mpv: Context cancelled")
|
|
m.Playback.IsRunning = false
|
|
err := m.conn.Close()
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to close connection")
|
|
}
|
|
stopListening <- struct{}{}
|
|
return
|
|
}()
|
|
|
|
// Listen for events
|
|
for event := range events {
|
|
if event.Data != nil {
|
|
m.Playback.IsRunning = true
|
|
//m.Logger.Trace().Msgf("received event: %s, %v, %+v", event.Name, event.ID, event.Data)
|
|
switch event.ID {
|
|
case 43:
|
|
m.Playback.Paused = event.Data.(bool)
|
|
case 42:
|
|
m.Playback.Position = event.Data.(float64)
|
|
case 44:
|
|
m.Playback.Duration = event.Data.(float64)
|
|
case 45:
|
|
m.Playback.Filename = event.Data.(string)
|
|
case 46:
|
|
m.Playback.Filepath = event.Data.(string)
|
|
}
|
|
m.subscribers.Range(func(key string, sub *Subscriber) bool {
|
|
go func() {
|
|
sub.eventCh <- event
|
|
}()
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func (m *Mpv) GetPlaybackStatus() (*Playback, error) {
|
|
m.playbackMu.RLock()
|
|
defer m.playbackMu.RUnlock()
|
|
if !m.Playback.IsRunning {
|
|
return nil, errors.New("mpv is not running")
|
|
}
|
|
if m.Playback == nil {
|
|
return nil, errors.New("no playback status")
|
|
}
|
|
if m.Playback.Filename == "" {
|
|
return nil, errors.New("no media found")
|
|
}
|
|
if m.Playback.Duration == 0 {
|
|
return nil, errors.New("no duration found")
|
|
}
|
|
return m.Playback, nil
|
|
}
|
|
|
|
func (m *Mpv) CloseAll() {
|
|
m.Logger.Debug().Msg("mpv: Received close request")
|
|
if m.conn != nil {
|
|
err := m.conn.Close()
|
|
if err != nil {
|
|
m.Logger.Error().Err(err).Msg("mpv: Failed to close connection")
|
|
}
|
|
}
|
|
m.terminate()
|
|
}
|
|
|
|
func (m *Mpv) terminate() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
m.Logger.Warn().Msgf("mpv: Termination panic")
|
|
}
|
|
}()
|
|
m.Logger.Trace().Msg("mpv: Terminating")
|
|
m.resetPlaybackStatus()
|
|
m.publishDone()
|
|
if m.cancel != nil {
|
|
m.cancel()
|
|
}
|
|
if cmdCancel != nil {
|
|
cmdCancel()
|
|
}
|
|
m.Logger.Trace().Msg("mpv: Terminated")
|
|
}
|
|
|
|
func (m *Mpv) Subscribe(id string) *Subscriber {
|
|
sub := &Subscriber{
|
|
eventCh: make(chan *mpvipc.Event, 100),
|
|
closedCh: make(chan struct{}),
|
|
}
|
|
m.subscribers.Set(id, sub)
|
|
return sub
|
|
}
|
|
|
|
func (m *Mpv) Unsubscribe(id string) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
}
|
|
}()
|
|
sub, ok := m.subscribers.Get(id)
|
|
if !ok {
|
|
return
|
|
}
|
|
close(sub.eventCh)
|
|
close(sub.closedCh)
|
|
m.subscribers.Delete(id)
|
|
}
|
|
|
|
func (s *Subscriber) Events() <-chan *mpvipc.Event {
|
|
return s.eventCh
|
|
}
|
|
|
|
func (s *Subscriber) Closed() <-chan struct{} {
|
|
return s.closedCh
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// parseArgs parses a command line string into individual arguments, respecting quotes
|
|
func parseArgs(s string) ([]string, error) {
|
|
args := make([]string, 0)
|
|
var current strings.Builder
|
|
var inQuotes bool
|
|
var quoteChar rune
|
|
|
|
runes := []rune(s)
|
|
for i := 0; i < len(runes); i++ {
|
|
char := runes[i]
|
|
switch {
|
|
case char == '"' || char == '\'':
|
|
if !inQuotes {
|
|
inQuotes = true
|
|
quoteChar = char
|
|
} else if char == quoteChar {
|
|
inQuotes = false
|
|
quoteChar = 0
|
|
// Add the current string even if it's empty (for empty quoted strings)
|
|
args = append(args, current.String())
|
|
current.Reset()
|
|
} else {
|
|
current.WriteRune(char)
|
|
}
|
|
case char == ' ' || char == '\t':
|
|
if inQuotes {
|
|
current.WriteRune(char)
|
|
} else if current.Len() > 0 {
|
|
args = append(args, current.String())
|
|
current.Reset()
|
|
}
|
|
case char == '\\' && i+1 < len(runes):
|
|
// Handle escaped characters
|
|
if inQuotes && (runes[i+1] == '"' || runes[i+1] == '\'') {
|
|
i++
|
|
current.WriteRune(runes[i])
|
|
} else {
|
|
current.WriteRune(char)
|
|
}
|
|
default:
|
|
current.WriteRune(char)
|
|
}
|
|
}
|
|
|
|
if inQuotes {
|
|
return nil, errors.New("unclosed quote in arguments")
|
|
}
|
|
|
|
if current.Len() > 0 {
|
|
args = append(args, current.String())
|
|
}
|
|
|
|
return args, nil
|
|
}
|
|
|
|
// getDefaultSocketName returns the default name of the socket/pipe.
|
|
func getDefaultSocketName() string {
|
|
switch runtime.GOOS {
|
|
case "windows":
|
|
return "\\\\.\\pipe\\mpv_ipc"
|
|
case "linux":
|
|
return "/tmp/mpv_socket"
|
|
case "darwin":
|
|
return "/tmp/mpv_socket"
|
|
default:
|
|
return "/tmp/mpv_socket"
|
|
}
|
|
}
|
|
|
|
// createCmd returns a new exec.Cmd instance.
|
|
func (m *Mpv) createCmd(filePath string, args ...string) (*exec.Cmd, error) {
|
|
var cmd *exec.Cmd
|
|
|
|
// Add user-defined arguments
|
|
if m.Args != "" {
|
|
userArgs, err := parseArgs(m.Args)
|
|
if err != nil {
|
|
m.Logger.Warn().Err(err).Msg("mpv: Failed to parse user arguments, using simple split")
|
|
userArgs = strings.Fields(m.Args)
|
|
}
|
|
args = append(args, userArgs...)
|
|
}
|
|
|
|
if filePath != "" {
|
|
// escapedFilePath := url.PathEscape(filePath)
|
|
args = append(args, filePath)
|
|
}
|
|
|
|
binaryPath := "mpv"
|
|
switch m.AppPath {
|
|
case "":
|
|
default:
|
|
binaryPath = m.AppPath
|
|
}
|
|
|
|
cmd = util.NewCmdCtx(cmdCtx, binaryPath, args...)
|
|
|
|
m.Logger.Trace().Msgf("mpv: Command: %s", strings.Join(cmd.Args, " "))
|
|
|
|
return cmd, nil
|
|
}
|
|
|
|
func (m *Mpv) resetPlaybackStatus() {
|
|
m.playbackMu.Lock()
|
|
m.Logger.Trace().Msg("mpv: Resetting playback status")
|
|
m.Playback.Filename = ""
|
|
m.Playback.Filepath = ""
|
|
m.Playback.Paused = false
|
|
m.Playback.Position = 0
|
|
m.Playback.Duration = 0
|
|
m.Playback.IsRunning = false
|
|
m.playbackMu.Unlock()
|
|
return
|
|
}
|
|
|
|
func (m *Mpv) publishDone() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
m.Logger.Warn().Msgf("mpv: Connection already closed")
|
|
}
|
|
}()
|
|
m.subscribers.Range(func(key string, sub *Subscriber) bool {
|
|
go func() {
|
|
sub.closedCh <- struct{}{}
|
|
}()
|
|
return true
|
|
})
|
|
}
|