mpv

README

mpv (remote) control library

This library provides everything needed to (remote) control the mpv media player.

It provides an easy api, a json api and rpc functionality.

Usecases: Remote control your mediaplayer running on a raspberry pi or laptop or build a http interface for mpv

Usage

$ go get github.com/blang/mpv

Note: Always vendor your dependencies or fix on a specific version tag.

Start mpv:

$ mpv --idle --input-ipc-server=/tmp/mpvsocket

Remote control:

import github.com/blang/mpv

ipcc := mpv.NewIPCClient("/tmp/mpvsocket") // Lowlevel client
c := mpv.NewClient(ipcc) // Highlevel client, can also use RPCClient

c.LoadFile("movie.mp4", mpv.LoadFileModeReplace)
c.SetPause(true)
c.Seek(600, mpv.SeekModeAbsolute)
c.SetFullscreen(true)
c.SetPause(false)

pos, err := c.Position()
fmt.Printf("Position in Seconds: %.0f", pos)

Also check the GoDocs.

Features

• Low-Level and High-Level API
• RPC Server and Client (fully transparent)
• HTTP Handler exposing lowlevel API (json)

Contribution

Feel free to make a pull request. For bigger changes create a issue first to discuss about it.

License

See LICENSE file.

Documentation

Index

• Constants
• Variables
• func HTTPServerHandler(client LLClient) http.Handler
• type Client
  • func NewClient(llclient LLClient) *Client
  • func (c *Client) Duration() (float64, error)
  • func (c *Client) Filename() (string, error)
  • func (c *Client) Fullscreen() (bool, error)
  • func (c *Client) GetBoolProperty(name string) (bool, error)
  • func (c *Client) GetFloatProperty(name string) (float64, error)
  • func (c *Client) GetProperty(name string) (string, error)
  • func (c *Client) Idle() (bool, error)
  • func (c *Client) LoadList(path string, mode string) error
  • func (c *Client) Loadfile(path string, mode string) error
  • func (c *Client) Mute() (bool, error)
  • func (c *Client) Path() (string, error)
  • func (c *Client) Pause() (bool, error)
  • func (c *Client) PercentPosition() (float64, error)
  • func (c *Client) PlaylistNext() error
  • func (c *Client) PlaylistPrevious() error
  • func (c *Client) Position() (float64, error)
  • func (c *Client) Seek(n int, mode string) error
  • func (c *Client) SetFullscreen(v bool) error
  • func (c *Client) SetMute(mute bool) error
  • func (c *Client) SetPause(pause bool) error
  • func (c *Client) SetProperty(name string, value interface{}) error
  • func (c *Client) Speed() (float64, error)
  • func (c *Client) Volume() (float64, error)
• type IPCClient
  • func NewIPCClient(socket string) *IPCClient
  • func (c *IPCClient) Exec(command ...interface{}) (*Response, error)
• type JSONRequest
• type JSONResponse
• type LLClient
• type RPCClient
  • func NewRPCClient(client *rpc.Client) *RPCClient
  • func (s *RPCClient) Exec(command ...interface{}) (*Response, error)
• type RPCServer
  • func NewRPCServer(client LLClient) *RPCServer
  • func (s *RPCServer) Exec(args *[]interface{}, res *Response) error
• type Response

Constants

const (
	LoadFileModeReplace    = "replace"
	LoadFileModeAppend     = "append"
	LoadFileModeAppendPlay = "append-play" // Starts if nothing is playing
)

Mode options for Loadfile

const (
	SeekModeRelative = "relative"
	SeekModeAbsolute = "absolute"
)

Mode options for Seek

const (
	LoadListModeReplace = "replace"
	LoadListModeAppend  = "append"
)

Mode options for LoadList

Variables

var (
	ErrTimeoutSend = errors.New("Timeout while sending command")
	ErrTimeoutRecv = errors.New("Timeout while receiving response")
)

Timeout errors while communicating via IPC

var ErrInvalidType = errors.New("Invalid type")

ErrInvalidType is returned if the response data does not match the methods return type. Use GetProperty or find matching type in mpv docs.

Functions

func HTTPServerHandler

func HTTPServerHandler(client LLClient) http.Handler

HTTPServerHandler returns a http.Handler to access a client via a lowlevel json-api. Register as route on your server:

http.Handle("/mpv", mpv.HTTPHandler(lowlevelclient)

Use api:

POST http://host/lowlevel Body: { "command": ["get_property", "fullscreen"] }

Result:

{"error":"success","data":false}

Types

type Client

type Client struct {
	LLClient
}

Client is a more comfortable higher level interface to LLClient. It can use any LLClient implementation.

func NewClient

func NewClient(llclient LLClient) *Client

NewClient creates a new highlevel client based on a lowlevel client.

func (*Client) Duration

func (c *Client) Duration() (float64, error)

Duration returns the duration of the currently playing file.

func (*Client) Filename

func (c *Client) Filename() (string, error)

Filename returns the currently playing filename

func (*Client) Fullscreen

func (c *Client) Fullscreen() (bool, error)

Fullscreen returns true if the player is in fullscreen mode.

func (*Client) GetBoolProperty

func (c *Client) GetBoolProperty(name string) (bool, error)

GetBoolProperty reads a bool property and returns the data as a boolean.

func (*Client) GetFloatProperty

func (c *Client) GetFloatProperty(name string) (float64, error)

GetFloatProperty reads a float property and returns the data as a float64.

func (*Client) GetProperty

func (c *Client) GetProperty(name string) (string, error)

GetProperty reads a property by name and returns the data as a string.

func (*Client) Idle

func (c *Client) Idle() (bool, error)

Idle returns true if the player is idle

func (*Client) LoadList

func (c *Client) LoadList(path string, mode string) error

LoadList loads a playlist from path. It can either replace the current playlist (LoadListModeReplace) or append to the current playlist (LoadListModeAppend).

func (*Client) Loadfile

func (c *Client) Loadfile(path string, mode string) error

Loadfile loads a file, it either replaces the currently playing file (LoadFileModeReplace), appends to the current playlist (LoadFileModeAppend) or appends to playlist and plays if nothing is playing right now (LoadFileModeAppendPlay)

func (*Client) Mute

func (c *Client) Mute() (bool, error)

Mute returns true if the player is muted.

func (*Client) Path

func (c *Client) Path() (string, error)

Path returns the currently playing path

func (*Client) Pause

func (c *Client) Pause() (bool, error)

Pause returns true if the player is paused

func (*Client) PercentPosition

func (c *Client) PercentPosition() (float64, error)

PercentPosition returns the current playback position in percent.

func (*Client) PlaylistNext

func (c *Client) PlaylistNext() error

PlaylistNext plays the next playlistitem or NOP if no item is available.

func (*Client) PlaylistPrevious

func (c *Client) PlaylistPrevious() error

PlaylistPrevious plays the previous playlistitem or NOP if no item is available.

func (*Client) Position

func (c *Client) Position() (float64, error)

Position returns the current playback position in seconds.

func (*Client) Seek

func (c *Client) Seek(n int, mode string) error

Seek seeks to a position in the current file. Use mode to seek relative to current position (SeekModeRelative) or absolute (SeekModeAbsolute).

func (*Client) SetFullscreen

func (c *Client) SetFullscreen(v bool) error

SetFullscreen activates/deactivates the fullscreen mode.

func (*Client) SetMute

func (c *Client) SetMute(mute bool) error

SetMute mutes or unmutes the player.

func (*Client) SetPause

func (c *Client) SetPause(pause bool) error

SetPause pauses or unpauses the player

func (*Client) SetProperty

func (c *Client) SetProperty(name string, value interface{}) error

SetProperty sets the value of a property.

func (*Client) Speed

func (c *Client) Speed() (float64, error)

Speed returns the current playback speed.

func (*Client) Volume

func (c *Client) Volume() (float64, error)

Volume returns the current volume level.

type IPCClient

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

IPCClient is a low-level IPC client to communicate with the mpv player via socket.

func NewIPCClient

func NewIPCClient(socket string) *IPCClient

NewIPCClient creates a new IPCClient connected to the given socket.

func (*IPCClient) Exec

func (c *IPCClient) Exec(command ...interface{}) (*Response, error)

Exec executes a command via ipc and returns the response. A request can timeout while sending or while waiting for the response. An error is only returned if there was an error in the communication. The client has to check for `response.Error` in case the server returned an error.

type JSONRequest

type JSONRequest struct {
	Command []interface{} `json:"command"`
}

JSONRequest send to the server.

type JSONResponse

type JSONResponse struct {
	Err  string      `json:"error"`
	Data interface{} `json:"data"` // May contain float64, bool or string
}

JSONResponse send from the server.

type LLClient

type LLClient interface {
	Exec(command ...interface{}) (*Response, error)
}

LLClient is the most low level interface

type RPCClient

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

RPCClient represents a LLClient over RPC.

func NewRPCClient

func NewRPCClient(client *rpc.Client) *RPCClient

NewRPCClient creates a new RPCClient based on rpc.Client

func (*RPCClient) Exec

func (s *RPCClient) Exec(command ...interface{}) (*Response, error)

Exec executes a command over rpc.

type RPCServer

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

RPCServer publishes a LLClient over RPC.

func NewRPCServer

func NewRPCServer(client LLClient) *RPCServer

NewRPCServer creates a new RPCServer based on lowlevel client.

func (*RPCServer) Exec

func (s *RPCServer) Exec(args *[]interface{}, res *Response) error

Exec exposes llclient.Exec via RPC. Not intended to be used directly.

type Response

type Response struct {
	Err       string      `json:"error"`
	Data      interface{} `json:"data"` // May contain float64, bool or string
	Event     string      `json:"event"`
	RequestID int         `json:"request_id"`
}

Response received from mpv. Can be an event or a user requested response.