mpvipc

package module
v0.0.0-...-eb73ba4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 24, 2023 License: MIT Imports: 6 Imported by: 1

README

mpvipc

GoDoc Build Status MIT licensed

A Go implementation of mpv's IPC interface

Sample usage

  • Run mpv

    $ mpv some_file.mkv --input-unix-socket=/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

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

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))

Output:

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))
}

Output:

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)
	}
}

Output:

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)
	}
}

Output:

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)
}

Output:

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)
}

Output:

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) MarshalJSON 

func (e *Event) MarshalJSON() ([]byte, error)

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.

type Parser 

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

func (*Parser) Decode 

func (p *Parser) Decode(data []byte, value interface{}) error

func (*Parser) Encode 

func (p *Parser) Encode(value interface{}) ([]byte, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.