mpvipc

README

mpvipc

A Go implementation of mpv's IPC interface

Sample usage

• Run mpv

  $ mpv some_file.mkv --input-ipc-server=/tmp/mpv_socket
  

• Do things to it!

  package main
  
  import (
      "fmt"
      "log"
  
      "github.com/DexterLB/mpvipc"
  )
  
  func main() {
      conn := mpvipc.NewConnection("/tmp/mpv_rpc")
      err := conn.Open()
      if err != nil {
          log.Fatal(err)
      }
      defer conn.Close()
  
      events, stopListening := conn.NewEventListener()
  
      path, err := conn.Get("path")
      if err != nil {
          log.Fatal(err)
      }
      log.Printf("current file playing: %s", path)
  
      err = conn.Set("pause", true)
      if err != nil {
          log.Fatal(err)
      }
      log.Printf("paused!")
  
      _, err = conn.Call("observe_property", 42, "volume")
      if err != nil {
          fmt.Print(err)
      }
  
      go func() {
          conn.WaitUntilClosed()
          stopListening <- struct{}{}
      }()
  
      for event := range events {
          if event.ID == 42 {
              log.Printf("volume now is %f", event.Data.(float64))
          } else {
              log.Printf("received event: %s", event.Name)
          }
      }
  
      log.Printf("mpv closed socket")
  }
  

See more examples at the documentation.

All of mpv's functions and properties are listed here.

Documentation

Overview

Package mpvipc provides an interface for communicating with the mpv media player via it's JSON IPC interface

Index

• type Connection
  • func NewConnection(socketName string) *Connection
  • func (c *Connection) Call(arguments ...interface{}) (interface{}, error)
  • func (c *Connection) Close() error
  • func (c *Connection) Get(property string) (interface{}, error)
  • func (c *Connection) IsClosed() bool
  • func (c *Connection) ListenForEvents(events chan<- *Event, stop <-chan struct{})
  • func (c *Connection) NewEventListener() (chan *Event, chan struct{})
  • func (c *Connection) Open() error
  • func (c *Connection) Set(property string, value interface{}) error
  • func (c *Connection) WaitUntilClosed()
• type Event
  • func (e *Event) UnmarshalJSON(data []byte) error
• type EventListener
• type Hub

Examples

• Connection.Call
• Connection.Get
• Connection.ListenForEvents
• Connection.NewEventListener
• Connection.Set
• Connection.WaitUntilClosed

Types

type Connection

type Connection struct {
	// contains filtered or unexported fields
}

Connection represents a connection to a mpv IPC socket

func NewConnection

func NewConnection(socketName string) *Connection

NewConnection returns a Connection associated with the given unix socket

func (*Connection) Call

func (c *Connection) Call(arguments ...interface{}) (interface{}, error)

Call calls an arbitrary command and returns its result. For a list of possible functions, see https://mpv.io/manual/master/#commands and https://mpv.io/manual/master/#list-of-input-commands

Example

conn := NewConnection("/tmp/mpv_socket")
err := conn.Open()
if err != nil {
	fmt.Print(err)
	return
}
defer func() {
	_ = conn.Close()
}()

// toggle play/pause
_, err = conn.Call("cycle", "pause")
if err != nil {
	fmt.Print(err)
}

// increase volume by 5
_, err = conn.Call("add", "volume", 5)
if err != nil {
	fmt.Print(err)
}

// decrease volume by 3, showing an osd message and progress bar
_, err = conn.Call("osd-msg-bar", "add", "volume", -3)
if err != nil {
	fmt.Print(err)
}

// get mpv's version
version, err := conn.Call("get_version")
if err != nil {
	fmt.Print(err)
}
fmt.Printf("version: %f\n", version.(float64))

func (*Connection) Close

func (c *Connection) Close() error

Close closes the socket, disconnecting from mpv. It is safe to call Close() on an already closed connection.

func (*Connection) Get

func (c *Connection) Get(property string) (interface{}, error)

Get is a shortcut to Call("get_property", property)

Example

conn := NewConnection("/tmp/mpv_socket")
err := conn.Open()
if err != nil {
	fmt.Print(err)
	return
}
defer func() {
	_ = conn.Close()
}()

// see if we're paused
paused, err := conn.Get("pause")
if err != nil {
	fmt.Print(err)
} else if paused.(bool) {
	fmt.Printf("we're paused!\n")
} else {
	fmt.Printf("we're not paused.\n")
}

// see the current position in the file
elapsed, err := conn.Get("time-pos")
if err != nil {
	fmt.Print(err)
} else {
	fmt.Printf("seconds from start of video: %f\n", elapsed.(float64))
}

func (*Connection) IsClosed

func (c *Connection) IsClosed() bool

IsClosed returns true if the connection is closed. There are several cases in which a connection is closed:

1. Close() has been called

2. The connection has been initialised but Open() hasn't been called yet

3. The connection terminated because of an error, mpv exiting or crashing

It's ok to use IsClosed() to check if you need to reopen the connection before calling a command.

func (*Connection) ListenForEvents

func (c *Connection) ListenForEvents(events chan<- *Event, stop <-chan struct{})

ListenForEvents blocks until something is received on the stop channel (or it's closed). In the mean time, events received on the socket will be sent on the events channel. They may not appear in the same order they happened in.

The events channel is closed automatically just before this method returns.

Example

conn := NewConnection("/tmp/mpv_socket")
err := conn.Open()
if err != nil {
	fmt.Print(err)
	return
}
defer func() {
	_ = conn.Close()
}()

_, err = conn.Call("observe_property", 42, "volume")
if err != nil {
	fmt.Print(err)
}

events := make(chan *Event)
stop := make(chan struct{})
go conn.ListenForEvents(events, stop)

// print all incoming events for 5 seconds, then exit
go func() {
	time.Sleep(time.Second * 5)
	stop <- struct{}{}
}()

for event := range events {
	if event.ID == 42 {
		fmt.Printf("volume now is %f\n", event.Data.(float64))
	} else {
		fmt.Printf("received event: %s\n", event.Name)
	}
}

func (*Connection) NewEventListener

func (c *Connection) NewEventListener() (chan *Event, chan struct{})

NewEventListener is a convenience wrapper around ListenForEvents(). It creates and returns the event channel and the stop channel. After calling NewEventListener, read events from the events channel and send an empty struct to the stop channel to close it.

Example

conn := NewConnection("/tmp/mpv_socket")
err := conn.Open()
if err != nil {
	fmt.Print(err)
	return
}
defer func() {
	_ = conn.Close()
}()

_, err = conn.Call("observe_property", 42, "volume")
if err != nil {
	fmt.Print(err)
}

events, stop := conn.NewEventListener()

// print all incoming events for 5 seconds, then exit
go func() {
	time.Sleep(time.Second * 5)
	stop <- struct{}{}
}()

for event := range events {
	if event.ID == 42 {
		fmt.Printf("volume now is %f\n", event.Data.(float64))
	} else {
		fmt.Printf("received event: %s\n", event.Name)
	}
}

func (*Connection) Open

func (c *Connection) Open() error

Open connects to the socket. Returns an error if already connected. It also starts listening to events, so ListenForEvents() can be called afterwards.

func (*Connection) Set

func (c *Connection) Set(property string, value interface{}) error

Set is a shortcut to Call("set_property", property, value)

Example

conn := NewConnection("/tmp/mpv_socket")
err := conn.Open()
if err != nil {
	fmt.Print(err)
	return
}
defer func() {
	_ = conn.Close()
}()

// pause playback
err = conn.Set("pause", true)
if err != nil {
	fmt.Print(err)
}

// seek to the middle of file
err = conn.Set("percent-pos", 50)
if err != nil {
	fmt.Print(err)
}

func (*Connection) WaitUntilClosed

func (c *Connection) WaitUntilClosed()

WaitUntilClosed blocks until the connection becomes closed. See IsClosed() for an explanation of the closed state.

Example

conn := NewConnection("/tmp/mpv_socket")
err := conn.Open()
if err != nil {
	fmt.Print(err)
	return
}
defer func() {
	_ = conn.Close()
}()

events, stop := conn.NewEventListener()

// print events until mpv exits, then exit
go func() {
	conn.WaitUntilClosed()
	stop <- struct{}{}
}()

for event := range events {
	fmt.Printf("received event: %s\n", event.Name)
}

type Event

type Event struct {
	// Name is the only obligatory field: the name of the event
	Name string `json:"event"`

	// Reason is the reason for the event: currently used for the "end-file"
	// event. When Name is "end-file", possible values of Reason are:
	// "eof", "stop", "quit", "error", "redirect", "unknown"
	Reason string `json:"reason"`

	// Prefix is the log-message prefix (only if Name is "log-message")
	Prefix string `json:"prefix"`

	// Level is the loglevel for a log-message (only if Name is "log-message")
	Level string `json:"level"`

	// Text is the text of a log-message (only if Name is "log-message")
	Text string `json:"text"`

	// ID is the user-set property ID (on events triggered by observed properties)
	ID int64 `json:"id"`

	// Data is the property value (on events triggered by observed properties)
	Data interface{} `json:"data"`

	// ExtraData contains extra attributes of the event payload (on spontaneous events)
	ExtraData map[string]interface{} `json:"-"`
}

Event represents an event received from mpv. For a list of all possible events, see https://mpv.io/manual/master/#list-of-events

func (*Event) UnmarshalJSON

func (e *Event) UnmarshalJSON(data []byte) error

type EventListener

type EventListener struct {
	// contains filtered or unexported fields
}

type Hub

type Hub struct {
	// contains filtered or unexported fields
}

Hub maintains the set of active EventListeners and broadcasts messages to them.