ffmpeg_go

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

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

 Go to latest Published: Nov 1, 2023 License: Apache-2.0 Imports: 18 Imported by: 0

README

ffmpeg-go

ffmpeg-go is golang port of https://github.com/kkroening/ffmpeg-python

check examples/example_test.go and ffmpeg_test.go for more examples.

Examples

split := Input(TestInputFile1).VFlip().Split()
	split0, split1 := split.Get("0"), split.Get("1")
	overlayFile := Input(TestOverlayFile).Crop(10, 10, 158, 112)
err := Concat([]*Stream{
    split0.Trim(KwArgs{"start_frame": 10, "end_frame": 20}),
    split1.Trim(KwArgs{"start_frame": 30, "end_frame": 40})}).
    Overlay(overlayFile.HFlip(), "").
    DrawBox(50, 50, 120, 120, "red", 5).
    Output(TestOutputFile1).
    OverWriteOutput().
    Run()

Transcoding From One Codec To Another

err := ffmpeg.Input("./sample_data/in1.mp4").
		Output("./sample_data/out1.mp4", ffmpeg.KwArgs{"c:v": "libx265"}).
		OverWriteOutput().ErrorToStdOut().Run()

Cut Video From Timestamp

err := ffmpeg.Input("./sample_data/in1.mp4", ffmpeg.KwArgs{"ss": 1}).
    Output("./sample_data/out1.mp4", ffmpeg.KwArgs{"t": 1}).OverWriteOutput().Run()
assert.Nil(t, err)

Add Watermark For Video

// show watermark with size 64:-1 in the top left corner after seconds 1
overlay := ffmpeg.Input("./sample_data/overlay.png").Filter("scale", ffmpeg.Args{"64:-1"})
err := ffmpeg.Filter(
    []*ffmpeg.Stream{
        ffmpeg.Input("./sample_data/in1.mp4"),
        overlay,
    }, "overlay", ffmpeg.Args{"10:10"}, ffmpeg.KwArgs{"enable": "gte(t,1)"}).
    Output("./sample_data/out1.mp4").OverWriteOutput().ErrorToStdOut().Run()

result:

img.png

Cut Video For Gif

err := ffmpeg.Input("./sample_data/in1.mp4", ffmpeg.KwArgs{"ss": "1"}).
    Output("./sample_data/out1.gif", ffmpeg.KwArgs{"s": "320x240", "pix_fmt": "rgb24", "t": "3", "r": "3"}).
    OverWriteOutput().ErrorToStdOut().Run()

result:

img.png

Task Frame From Video

func ExampleReadFrameAsJpeg(inFileName string, frameNum int) io.Reader {
	buf := bytes.NewBuffer(nil)
	err := ffmpeg.Input(inFileName).
		Filter("select", ffmpeg.Args{fmt.Sprintf("gte(n,%d)", frameNum)}).
		Output("pipe:", ffmpeg.KwArgs{"vframes": 1, "format": "image2", "vcodec": "mjpeg"}).
		WithOutput(buf, os.Stdout).
		Run()
	if err != nil {
		panic(err)
	}
	return buf
}

reader := ExampleReadFrameAsJpeg("./sample_data/in1.mp4", 5)
img, err := imaging.Decode(reader)
if err != nil {
    t.Fatal(err)
}
err = imaging.Save(img, "./sample_data/out1.jpeg")
if err != nil {
    t.Fatal(err)
}

result :

image

Get Multiple Output

// get multiple output with different size/bitrate
input := ffmpeg.Input("./sample_data/in1.mp4").Split()
out1 := input.Get("0").Filter("scale", ffmpeg.Args{"1920:-1"}).
Output("./sample_data/1920.mp4", ffmpeg.KwArgs{"b:v": "5000k"})
out2 := input.Get("1").Filter("scale", ffmpeg.Args{"1280:-1"}).
Output("./sample_data/1280.mp4", ffmpeg.KwArgs{"b:v": "2800k"})

err := ffmpeg.MergeOutputs(out1, out2).OverWriteOutput().ErrorToStdOut().Run()

Show FFmpeg Progress

see complete example at: showProgress

func ExampleShowProgress(inFileName, outFileName string) {
	a, err := ffmpeg.Probe(inFileName)
	if err != nil {
		panic(err)
	}
	totalDuration := gjson.Get(a, "format.duration").Float()

	err = ffmpeg.Input(inFileName).
		Output(outFileName, ffmpeg.KwArgs{"c:v": "libx264", "preset": "veryslow"}).
		GlobalArgs("-progress", "unix://"+TempSock(totalDuration)).
		OverWriteOutput().
		Run()
	if err != nil {
		panic(err)
	}
}
ExampleShowProgress("./sample_data/in1.mp4", "./sample_data/out2.mp4")

result

progress:  .0
progress:  0.72
progress:  1.00
progress:  done

Integrate FFmpeg-go With Open-CV (gocv) For Face-detect

see complete example at: opencv

result: image

Set Cpu limit/request For FFmpeg-go

e := ComplexFilterExample("./sample_data/in1.mp4", "./sample_data/overlay.png", "./sample_data/out2.mp4")
err := e.RunWithResource(0.1, 0.5)
if err != nil {
    assert.Nil(t, err)
}

result from command top: we will see ffmpeg used 0.5 core as expected.

> top 
PID    USER       PR  NI    VIRT    RES    SHR S  %CPU   %MEM     TIME+ COMMAND
1386105 root      20   0 2114152 273780  31672 R  50.2   1.7      0:16.79 ffmpeg

View Progress Graph

function view generate mermaid chart, which can be use in markdown or view online

split := Input(TestInputFile1).VFlip().Split()
	split0, split1 := split.Get("0"), split.Get("1")
	overlayFile := Input(TestOverlayFile).Crop(10, 10, 158, 112)
b, err := Concat([]*Stream{
    split0.Trim(KwArgs{"start_frame": 10, "end_frame": 20}),
    split1.Trim(KwArgs{"start_frame": 30, "end_frame": 40})}).
    Overlay(overlayFile.HFlip(), "").
    DrawBox(50, 50, 120, 120, "red", 5).
    Output(TestOutputFile1).
    OverWriteOutput().View(ViewTypeFlowChart)
fmt.Println(b)

image

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var GlobalCommandOptions = make([]CommandOption, 0)
View Source 
var LogCompiledCommand bool = true

Functions

func AssertType 

func AssertType(hasType, expectType string, action string)

func ConvertKwargsToCmdLineArgs 

func ConvertKwargsToCmdLineArgs(kwargs KwArgs) []string

func DebugNodes 

func DebugNodes(node []DagNode)

func DebugOutGoingMap 

func DebugOutGoingMap(node []DagNode, m map[int]map[Label][]NodeInfo)

func Probe 

func Probe(fileName string, kwargs ...KwArgs) (string, error)

Probe Run ffprobe on the specified file and return a JSON representation of the output.

func ProbeReader 

func ProbeReader(r io.Reader, kwargs ...KwArgs) (string, error)

ProbeReader runs ffprobe passing given reader via stdin and return a JSON representation of the output.

func ProbeReaderWithTimeout 

func ProbeReaderWithTimeout(r io.Reader, timeOut time.Duration, kwargs KwArgs) (string, error)

func ProbeReaderWithTimeoutExec 

func ProbeReaderWithTimeoutExec(r io.Reader, timeOut time.Duration, kwargs KwArgs) (string, error)

func ProbeWithTimeout 

func ProbeWithTimeout(fileName string, timeOut time.Duration, kwargs KwArgs) (string, error)

func ProbeWithTimeoutExec 

func ProbeWithTimeoutExec(fileName string, timeOut time.Duration, kwargs KwArgs) (string, error)

Types

type Args 

type Args []string

func (Args) EscapeWith 

func (a Args) EscapeWith(chars string) Args

func (Args) Sorted 

func (a Args) Sorted() Args

type CommandOption 

type CommandOption func(cmd *exec.Cmd)

type CompilationOption 

type CompilationOption func(s *Stream, cmd *exec.Cmd)

func SeparateProcessGroup 

func SeparateProcessGroup() CompilationOption

SeparateProcessGroup ensures that the command is run in a separate process group. This is useful to enable handling of signals such as SIGINT without propagating them to the ffmpeg process.

type DagEdge 

type DagEdge struct {
	DownStreamNode   DagNode
	DownStreamLabel  Label
	UpStreamNode     DagNode
	UpStreamLabel    Label
	UpStreamSelector Selector
}

func GetInComingEdges 

func GetInComingEdges(downStreamNode DagNode, inComingEdgeMap map[Label]NodeInfo) []DagEdge

func GetOutGoingEdges 

func GetOutGoingEdges(upStreamNode DagNode, outOutingEdgeMap map[Label][]NodeInfo) []DagEdge

type DagNode 

type DagNode interface {
	Hash() int
	// Compare two nodes
	Equal(other DagNode) bool
	// Return a full string representation of the node.
	String() string
	// Return a partial/concise representation of the node
	ShortRepr() string
	// Provides information about all incoming edges that connect to this node.
	//
	//        The edge map is a dictionary that maps an “incoming_label“ to “(outgoing_node, outgoing_label)“.  Note that
	//        implicity, “incoming_node“ is “self“.  See "Edges" section above.
	IncomingEdgeMap() map[Label]NodeInfo
}

Node in a directed-acyclic graph (DAG).

Edges: DagNodes are connected by edges. An edge connects two nodes with a label for each side: - “upstream_node“: upstream/parent node - “upstream_label“: label on the outgoing side of the upstream node - “downstream_node“: downstream/child node - “downstream_label“: label on the incoming side of the downstream node

For example, DagNode A may be connected to DagNode B with an edge labelled "foo" on A's side, and "bar" on B's side:

_____ _____ | | | | | A >[foo]---[bar]> B | |_____| |_____|

Edge labels may be integers or strings, and nodes cannot have more than one incoming edge with the same label.

DagNodes may have any number of incoming edges and any number of outgoing edges. DagNodes keep track only of their incoming edges, but the entire graph structure can be inferred by looking at the furthest downstream nodes and working backwards.

Hashing: DagNodes must be hashable, and two nodes are considered to be equivalent if they have the same hash value.

Nodes are immutable, and the hash should remain constant as a result. If a node with new contents is required, create a new node and throw the old one away.

String representation: In order for graph visualization tools to show useful information, nodes must be representable as strings. The “String“ operator should provide a more or less "full" representation of the node, and the “ShortRepr“ property should be a shortened, concise representation.

Again, because nodes are immutable, the string representations should remain constant.

func TopSort 

func TopSort(downStreamNodes []DagNode) (sortedNodes []DagNode, outOutingEdgeMaps map[int]map[Label][]NodeInfo, err error)

type Graph 

type Graph struct {
	OutputStream string       `json:"output_stream"`
	GraphOptions GraphOptions `json:"graph_options"`
	Nodes        []GraphNode  `json:"nodes"`
}

type GraphNode 

type GraphNode struct {
	Name          string   `json:"name"`
	InputStreams  []string `json:"input_streams"`
	OutputStreams []string `json:"output_streams"`
	Args          Args     `json:"args"`
	KwArgs        KwArgs   `json:"kw_args"`
}

type GraphOptions 

type GraphOptions struct {
	Timeout         time.Duration
	OverWriteOutput bool
}

type KwArgs 

type KwArgs map[string]interface{}

func MergeKwArgs 

func MergeKwArgs(args []KwArgs) KwArgs

func (KwArgs) Copy 

func (a KwArgs) Copy() KwArgs

func (KwArgs) EscapeWith 

func (a KwArgs) EscapeWith(chars string) KwArgs

func (KwArgs) GetDefault 

func (a KwArgs) GetDefault(k string, defaultV interface{}) interface{}

func (KwArgs) GetString 

func (a KwArgs) GetString(k string) string

func (KwArgs) HasKey 

func (a KwArgs) HasKey(k string) bool

func (KwArgs) PopDefault 

func (a KwArgs) PopDefault(k string, defaultV interface{}) interface{}

func (KwArgs) PopString 

func (a KwArgs) PopString(k string) string

func (KwArgs) SortedKeys 

func (a KwArgs) SortedKeys() []string

type Label 

type Label string

type Node 

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

func FilterMultiOutput 

func FilterMultiOutput(streamSpec []*Stream, filterName string, args Args, kwArgs ...KwArgs) *Node

func NewFilterNode 

func NewFilterNode(name string, streamSpec []*Stream, maxInput int, args []string, kwargs KwArgs) *Node

func NewGlobalNode 

func NewGlobalNode(name string, streamSpec []*Stream, args []string, kwargs KwArgs) *Node

func NewInputNode 

func NewInputNode(name string, args []string, kwargs KwArgs) *Node

func NewMergeOutputsNode 

func NewMergeOutputsNode(name string, streamSpec []*Stream) *Node

func NewNode 

func NewNode(streamSpec []*Stream,
	name string,
	incomingStreamTypes sets.String,
	outgoingStreamType string,
	minInputs int,
	maxInputs int,
	args []string,
	kwargs KwArgs,
	nodeType string) *Node

func NewOutputNode 

func NewOutputNode(name string, streamSpec []*Stream, args []string, kwargs KwArgs) *Node

func (*Node) Equal 

func (n *Node) Equal(other DagNode) bool

func (*Node) Get 

func (n *Node) Get(a string) *Stream

func (*Node) GetFilter 

func (n *Node) GetFilter(outgoingEdges []DagEdge) string

func (*Node) GetInComingEdges 

func (n *Node) GetInComingEdges() []DagEdge

func (*Node) Hash 

func (n *Node) Hash() int

func (*Node) IncomingEdgeMap 

func (n *Node) IncomingEdgeMap() map[Label]NodeInfo

func (*Node) ShortRepr 

func (n *Node) ShortRepr() string

func (*Node) Stream 

func (n *Node) Stream(label Label, selector Selector) *Stream

func (*Node) String 

func (n *Node) String() string

type NodeInfo 

type NodeInfo struct {
	Node     DagNode
	Label    Label
	Selector Selector
}

type RunHook 

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

type Selector 

type Selector string

type Stream 

type Stream struct {
	Node       *Node
	Label      Label
	Selector   Selector
	Type       string
	FfmpegPath string
	Context    context.Context
}

func Concat 

func Concat(streams []*Stream, kwargs ...KwArgs) *Stream

func Filter 

func Filter(streamSpec []*Stream, filterName string, args Args, kwArgs ...KwArgs) *Stream

func Input 

func Input(filename string, kwargs ...KwArgs) *Stream

Input file URL (ffmpeg “-i“ option)

Any supplied kwargs are passed to ffmpeg verbatim (e.g. “t=20“, “f='mp4'“, “acodec='pcm'“, etc.).

To tell ffmpeg to read from stdin, use “pipe:“ as the filename.

Official documentation: `Main options <https://ffmpeg.org/ffmpeg.html#Main-options>`__

func MergeOutputs 

func MergeOutputs(streams ...*Stream) *Stream

Include all given outputs in one ffmpeg command line

func NewStream 

func NewStream(node *Node, streamType string, label Label, selector Selector) *Stream

func Output 

func Output(streams []*Stream, fileName string, kwargs ...KwArgs) *Stream

Output file URL 

Syntax:
    `ffmpeg.Output([]*Stream{stream1, stream2, stream3...}, filename, kwargs)`

Any supplied keyword arguments are passed to ffmpeg verbatim (e.g.
``t=20``, ``f='mp4'``, ``acodec='pcm'``, ``vcodec='rawvideo'``,
etc.).  Some keyword-arguments are handled specially, as shown below.

Args:
    video_bitrate: parameter for ``-b:v``, e.g. ``video_bitrate=1000``.
    audio_bitrate: parameter for ``-b:a``, e.g. ``audio_bitrate=200``.
    format: alias for ``-f`` parameter, e.g. ``format='mp4'``
        (equivalent to ``f='mp4'``).

If multiple streams are provided, they are mapped to the same
output.

To tell ffmpeg to write to stdout, use ``pipe:`` as the filename.

Official documentation: `Synopsis <https://ffmpeg.org/ffmpeg.html#Synopsis>`__
"""

func OutputContext 

func OutputContext(ctx context.Context, streams []*Stream, fileName string, kwargs ...KwArgs) *Stream

Output file URL 

Syntax:
    `ffmpeg.Output(ctx, []*Stream{stream1, stream2, stream3...}, filename, kwargs)`

Any supplied keyword arguments are passed to ffmpeg verbatim (e.g.
``t=20``, ``f='mp4'``, ``acodec='pcm'``, ``vcodec='rawvideo'``,
etc.).  Some keyword-arguments are handled specially, as shown below.

Args:
    video_bitrate: parameter for ``-b:v``, e.g. ``video_bitrate=1000``.
    audio_bitrate: parameter for ``-b:a``, e.g. ``audio_bitrate=200``.
    format: alias for ``-f`` parameter, e.g. ``format='mp4'``
        (equivalent to ``f='mp4'``).

If multiple streams are provided, they are mapped to the same
output.

To tell ffmpeg to write to stdout, use ``pipe:`` as the filename.

Official documentation: `Synopsis <https://ffmpeg.org/ffmpeg.html#Synopsis>`__
"""

func (*Stream) ASplit 

func (s *Stream) ASplit() *Node

func (*Stream) Audio 

func (s *Stream) Audio() *Stream

func (*Stream) ColorChannelMixer 

func (s *Stream) ColorChannelMixer(kwargs ...KwArgs) *Stream

todo fix this

func (*Stream) Compile 

func (s *Stream) Compile(options ...CompilationOption) *exec.Cmd

func (*Stream) Concat 

func (s *Stream) Concat(streams []*Stream, kwargs ...KwArgs) *Stream

func (*Stream) Crop 

func (s *Stream) Crop(x, y, w, h int, kwargs ...KwArgs) *Stream

func (*Stream) DrawBox 

func (s *Stream) DrawBox(x, y, w, h int, color string, thickness int, kwargs ...KwArgs) *Stream

func (*Stream) Drawtext 

func (s *Stream) Drawtext(text string, x, y int, escape bool, kwargs ...KwArgs) *Stream

func (*Stream) Equal 

func (s *Stream) Equal(other Stream) bool

func (*Stream) ErrorToStdOut 

func (s *Stream) ErrorToStdOut() *Stream

func (*Stream) Filter 

func (s *Stream) Filter(filterName string, args Args, kwArgs ...KwArgs) *Stream

func (*Stream) Get 

func (s *Stream) Get(index string) *Stream

func (*Stream) GetArgs 

func (s *Stream) GetArgs() []string

func (*Stream) GlobalArgs 

func (s *Stream) GlobalArgs(args ...string) *Stream

Add extra global command-line argument(s), e.g. “-progress“.

func (*Stream) HFlip 

func (s *Stream) HFlip(kwargs ...KwArgs) *Stream

func (*Stream) Hash 

func (s *Stream) Hash() int

func (*Stream) Hue 

func (s *Stream) Hue(kwargs ...KwArgs) *Stream

func (*Stream) Output 

func (s *Stream) Output(fileName string, kwargs ...KwArgs) *Stream

func (*Stream) OverWriteOutput 

func (s *Stream) OverWriteOutput() *Stream

func (*Stream) Overlay 

func (s *Stream) Overlay(overlayParentNode *Stream, eofAction string, kwargs ...KwArgs) *Stream

func (*Stream) OverwriteOutput 

func (s *Stream) OverwriteOutput(stream *Stream) *Stream

Overwrite output files without asking (ffmpeg “-y“ option)

Official documentation: `Main options <https://ffmpeg.org/ffmpeg.html#Main-options>`_

func (*Stream) Run 

func (s *Stream) Run(options ...CompilationOption) error

func (*Stream) RunLinux 

func (s *Stream) RunLinux() error

func (*Stream) RunWithResource 

func (s *Stream) RunWithResource(cpuRequest, cpuLimit float32) error

func (*Stream) SetFfmpegPath 

func (s *Stream) SetFfmpegPath(path string) *Stream

func (*Stream) SetPts 

func (s *Stream) SetPts(expr string) *Node

func (*Stream) Silent 

func (s *Stream) Silent(isSilent bool) *Stream

func (*Stream) Split 

func (s *Stream) Split() *Node

func (*Stream) String 

func (s *Stream) String() string

func (*Stream) Trim 

func (s *Stream) Trim(kwargs ...KwArgs) *Stream

func (*Stream) VFlip 

func (s *Stream) VFlip(kwargs ...KwArgs) *Stream

func (*Stream) Video 

func (s *Stream) Video() *Stream

func (*Stream) View 

func (s *Stream) View(viewType ViewType) (string, error)

func (*Stream) WithCpuCoreLimit 

func (s *Stream) WithCpuCoreLimit(n float32) *Stream

func (*Stream) WithCpuCoreRequest 

func (s *Stream) WithCpuCoreRequest(n float32) *Stream

func (*Stream) WithCpuSet 

func (s *Stream) WithCpuSet(n string) *Stream

func (*Stream) WithErrorOutput 

func (s *Stream) WithErrorOutput(out io.Writer) *Stream

func (*Stream) WithInput 

func (s *Stream) WithInput(reader io.Reader) *Stream

func (*Stream) WithMemSet 

func (s *Stream) WithMemSet(n string) *Stream

func (*Stream) WithOutput 

func (s *Stream) WithOutput(out ...io.Writer) *Stream

func (*Stream) WithTimeout 

func (s *Stream) WithTimeout(timeOut time.Duration) *Stream

func (*Stream) ZoomPan 

func (s *Stream) ZoomPan(kwargs ...KwArgs) *Stream

type ViewType 

type ViewType string
const (
	// FlowChart the diagram type for output in flowchart style (https://mermaid-js.github.io/mermaid/#/flowchart) (including current state
	ViewTypeFlowChart ViewType = "flowChart"
	// StateDiagram the diagram type for output in stateDiagram style (https://mermaid-js.github.io/mermaid/#/stateDiagram)
	ViewTypeStateDiagram ViewType = "stateDiagram"
)

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.