initial commit

Author: zackradisic

LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2021 Modfy, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,68 @@
+# go-fluent-ffmpeg
+
+A Go version of [node-fluent-ffmpeg](https://github.com/fluent-ffmpeg/node-fluent-ffmpeg).
+
+## Installation
+`go get -u github.com/modfy/fluent-ffmpeg`
+
+### Requirements
+You will need FFmpeg installed on your machine, or you can specify a path to a binary:
+
+```go
+// Provide an empty string to use default FFmpeg path
+cmd := fluentffmpeg.NewCommand("")
+
+// Specify a path
+cmd = fluentffmpeg.NewCommand("/path/to/ffmpeg/binary")
+```
+
+## Quick Start
+
+Create and run commands using an API similar to node-fluent-ffmpeg:
+
+```go
+err := fluentffmpeg.NewCommand(""). 
+		InputPath("/path/to/video.avi").
+		OutputFormat("mp4").
+		OutputPath("/path/to/video.mp4").
+		Run()
+```
+
+If you want to view the errors/logs returned from FFmpeg, provide an io.Writer to receive the data. 
+```go
+buf := &bytes.Buffer{}
+err := fluentffmpeg.NewCommand("").
+		InputPath("./video.avi").
+		OutputFormat("mp4").
+		OutputPath("./video.mp4").
+		Overwrite(true).
+		OutputLogs(buf). // provide a io.Writer
+        Run()
+
+out, _ := ioutil.ReadAll(buf) // read logs
+fmt.Println(string(out))
+```
+
+You can also get the command in the form of an [exec.Cmd](https://golang.org/pkg/os/exec/#Cmd) struct, with which you can have better control over the running process. For example, you can conditionally kill the FFmpeg command:
+
+```go
+done := make(chan error, 1)
+cmd := fluentffmpeg.NewCommand("").
+    InputPath("./video.avi").
+    OutputFormat("mp4").
+    OutputPath("./video.mp4").
+    Overwrite(true).
+    Build()
+cmd.Start()
+
+go func() {
+    done <- cmd.Wait()
+}()
+
+select {
+case <-time.After(time.Second * 5):
+    fmt.Println("Timed out")
+    cmd.Process.Kill()
+case <-done:
+}
+```

args.go

@@ -0,0 +1,39 @@
+package fluentffmpeg
+
+// Args contains the input and output args set for FFmpeg
+type Args struct {
+	input  inputArgs
+	output outputArgs
+}
+
+type inputArgs struct {
+	inputPath            string
+	pipeInput            bool
+	fromFormat           string
+	nativeFramerateInput bool `getter:"none"`
+}
+
+type outputArgs struct {
+	outputPath            string
+	format                string
+	pipeOutput            bool
+	overwrite             bool
+	resolution            string `getter:"none"`
+	aspectRatio           string
+	pixelFormat           string
+	quality               int
+	preset                string
+	bufferSize            int
+	audioBitrate          int
+	audioChannels         int
+	keyframeInterval      int
+	audioCodec            string
+	videoBitRate          int
+	videoBitRateTolerance int
+	videoMaxBitrate       int
+	videoMinBitrate       int
+	videoCodec            string
+	vFrames               int
+	frameRate             int
+	audioRate             int
+}

command.go

@@ -0,0 +1,101 @@
+package fluentffmpeg
+
+import (
+	"io"
+	"os/exec"
+	"reflect"
+	"strings"
+
+	"github.com/fatih/structs"
+)
+
+// Command is a struct that holds arguments and their values to run FFmpeg
+type Command struct {
+	FFmpegPath string
+	Args       *Args
+	input      io.Reader
+	output     io.Writer
+	logs       io.Writer
+}
+
+// NewCommand returns a new Command
+func NewCommand(ffmpegPath string) *Command {
+	if ffmpegPath == "" {
+		ffmpegPath = "ffmpeg"
+	}
+	return &Command{
+		FFmpegPath: ffmpegPath,
+		Args:       &Args{},
+	}
+}
+
+// Run runs the FFmpeg command. It returns an error if the command fails with exit status code 1. This error message only signifies that
+// the command returned a non-zero status code, read from stderr to see more comprehensive FFmpeg errors.
+func (c *Command) Run() error {
+	return c.Build().Run()
+}
+
+// Build returns an exec.Cmd struct ready to run the FFmpeg command with its arguments
+func (c *Command) Build() *exec.Cmd {
+	cmd := exec.Command(c.FFmpegPath, c.GetArgs()...)
+
+	if c.input != nil {
+		cmd.Stdin = c.input
+	}
+
+	if c.output != nil {
+		cmd.Stdout = c.output
+	}
+
+	if c.logs != nil {
+		cmd.Stderr = c.logs
+	}
+
+	return cmd
+}
+
+// GetArgs returns the arguments for the FFmpeg command.
+func (c *Command) GetArgs() []string {
+	var inputs []string
+	var outputs []string
+
+	inputs = c.getArgs(c.Args.input, "pipeInput", "inputPath")
+	outputs = c.getArgs(c.Args.output, "pipeOutput", "outputPath")
+
+	return append(inputs, outputs...)
+}
+
+func (c *Command) getArgs(argType interface{}, targetNames ...string) []string {
+	var options []string
+	var target []string
+
+	fields := structs.Names(argType)
+
+	// Iterates through the fields,
+	// and calls its corresponding getter function.
+	for _, v := range fields {
+		option := true
+		if containsString(targetNames, v) {
+			option = false
+		}
+		value := reflect.ValueOf(c.Args).MethodByName("Get" + strings.Title(v))
+		if (value != reflect.Value{}) {
+			result := value.Call([]reflect.Value{})
+			if v, ok := result[0].Interface().([]string); ok {
+				if option {
+					options = append(options, v...)
+				} else {
+					target = append(target, v...)
+				}
+			}
+		}
+	}
+
+	return append(options, target...)
+}
+
+// OutputLogs sets the destination to write the FFmpeg log output to
+func (c *Command) OutputLogs(writer io.Writer) *Command {
+	c.logs = writer
+	return c
+}

example/file/file.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+
+	fluentffmpeg "github.com/modfy/fluent-ffmpeg"
+)
+
+func main() {
+	buf := &bytes.Buffer{}
+	err := fluentffmpeg.NewCommand("").
+		InputPath("./video.avi").
+		OutputFormat("mp4").
+		OutputPath("./video.mp4").
+		Overwrite(true).
+		OutputLogs(buf).
+		Run()
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	out, _ := ioutil.ReadAll(buf)
+	fmt.Println(string(out))
+}

example/pipe/pipe.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"net/http"
+
+	fluentffmpeg "github.com/modfy/fluent-ffmpeg"
+)
+
+func main() {
+	http.HandleFunc("/ffmpeg", handle)
+
+	http.ListenAndServe(":5000", nil)
+}
+
+func handle(w http.ResponseWriter, r *http.Request) {
+	r.ParseMultipartForm(32 << 20)
+	file, _, _ := r.FormFile("video")
+
+	fluentffmpeg.
+		NewCommand("").
+		PipeInput(file).
+		OutputFormat("flv").
+		PipeOutput(w).
+		Run()
+}

example/timeout/timeout.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	fluentffmpeg "github.com/modfy/fluent-ffmpeg"
+)
+
+func main() {
+	done := make(chan error, 1)
+	cmd := fluentffmpeg.NewCommand("").
+		InputPath("./video.avi").
+		OutputFormat("mp4").
+		OutputPath("./video.mp4").
+		Overwrite(true).
+		Build()
+	cmd.Start()
+
+	go func() {
+		done <- cmd.Wait()
+	}()
+
+	select {
+	case <-time.After(time.Second * 5):
+		fmt.Println("Timed out")
+		cmd.Process.Kill()
+	case <-done:
+	}
+}

fluentffmpeg_test/args_test.go

@@ -0,0 +1,25 @@
+package fluentffmpeg_test
+
+import (
+	"bytes"
+	"reflect"
+	"strings"
+	"testing"
+
+	fluentffmpeg "github.com/modfy/fluent-ffmpeg"
+)
+
+func TestArgsOrder(t *testing.T) {
+	buff := &bytes.Buffer{}
+
+	desired := []string{"-f", "avi", "-i", "pipe:0", "-f", "mp4", "pipe:1"}
+	args := fluentffmpeg.NewCommand("").
+		PipeInput(buff).
+		FromFormat("avi").
+		OutputFormat("mp4").
+		PipeOutput(buff).GetArgs()
+
+	if !reflect.DeepEqual(args, desired) {
+		t.Errorf("Got wrong arguments. Expected: \"%s\", but got: \"%s\"", strings.Join(desired, " "), strings.Join(args, " "))
+	}
+}

getters_internal_test.go

@@ -0,0 +1,38 @@
+package fluentffmpeg
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/fatih/structs"
+)
+
+func TestFieldsHaveGetters(t *testing.T) {
+	cmd := NewCommand("")
+
+	if err := testFieldsHaveGetters(cmd.Args.input, cmd); err != nil {
+		t.Error(err.Error())
+		return
+	}
+
+	if err := testFieldsHaveGetters(cmd.Args.output, cmd); err != nil {
+		t.Error(err.Error())
+	}
+}
+
+func testFieldsHaveGetters(argType interface{}, cmd *Command) error {
+
+	for _, field := range structs.Names(argType) {
+		sf, _ := reflect.TypeOf(argType).FieldByName(field)
+		if sf.Tag.Get("getter") != "none" {
+			method := reflect.ValueOf(cmd.Args).MethodByName("Get" + strings.Title(field))
+			if (method == reflect.Value{}) {
+				return fmt.Errorf("field: (%s) has no getter", field)
+			}
+		}
+	}
+
+	return nil
+}

go.mod

@@ -0,0 +1,8 @@
+module github.com/modfy/fluent-ffmpeg
+
+go 1.15
+
+require (
+	github.com/fatih/structs v1.1.0
+	github.com/pkg/errors v0.9.1
+)