engine.go

package giffer

import (
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"
	"sync"

	"github.com/pkg/errors"
)

// Engine implements video and image manipulation.
type Engine struct {
	Dir     string    // Directory to write temporary files.
	FFmpeg  string    // Path to FFmpeg binary.
	Convert string    // Path to imagemagick Convert binary.
	Debug   bool      // Print commands used.
	Out     io.Writer // Writer to use if debug is true.
	Junk    []string  // Temporary files to cleanup.

	once sync.Once
}

// Cut and merge the target file into the specified time slices.
// Cuts is a slice of int pairs which are start and end times (in seconds)
// respectively.
// Returns a filepath to the merged file.
func (eng *Engine) Cut(video string, cuts ...[2]int) (string, error) {
	if err := eng.init(); err != nil {
		return "", fmt.Errorf("initializing engine: %w", err)
	}
	var (
		cutfiles []string
		entries  []string
		filelist = eng.path("tmp_file_list.txt")
		merged   = eng.path(fmt.Sprintf("merged%s", filepath.Ext(video)))
	)
	defer func() {
		eng.Junk = append(eng.Junk, append(cutfiles, filelist, merged)...)
	}()
	for ii, c := range cuts {
		start, end := c[0], c[1]
		if start > end {
			return "", fmt.Errorf("start > end: %d > %d", start, end)
		}
		output := eng.path(fmt.Sprintf("tmp_%d%s", ii, filepath.Ext(video)))
		cutSlice := eng.command(
			eng.FFmpeg,
			"-ss", fmt.Sprintf("%d", start),
			"-t", fmt.Sprintf("%d", end-start),
			"-i", video,
			output,
		)
		if out, err := cutSlice.CombinedOutput(); err != nil {
			return "", errors.Wrapf(err, "cutting video: %s", string(out))
		}
		cutfiles = append(cutfiles, output)
	}
	for _, f := range cutfiles {
		entries = append(entries, fmt.Sprintf("file '%s'", f))
	}
	if err := ioutil.WriteFile(
		filelist,
		[]byte(strings.Join(entries, "\n")),
		0644,
	); err != nil {
		return "", errors.Wrap(err, "creating file list for concatentation")
	}
	merge := eng.command(
		eng.FFmpeg,
		"-f", "concat",
		"-i", filelist,
		"-c", "copy",
		merged,
	)
	if out, err := merge.CombinedOutput(); err != nil {
		return "", errors.Wrapf(err, "merging cut files: %s", string(out))
	}
	return merged, nil
}

// Transcode the target video file into a gif.
// Returns a filepath to the gif image.
func (eng *Engine) Transcode(
	video string,
	start, end float64,
	width, height int,
	fps float64,
) (string, error) {
	if err := eng.init(); err != nil {
		return "", fmt.Errorf("initializing engine: %w", err)
	}
	var (
		duration   = end - start
		filters    string
		palettegen string
		palette    = eng.path("palette.png")
		output     = eng.path(fmt.Sprintf("%s.gif", strings.Split(filepath.Base(video), ".")[0]))
	)
	if height < -2 {
		height = -2
	}
	if width < -2 {
		width = -2
	}
	if fps > 0.0 {
		filters += fmt.Sprintf("fps=%2f", fps)
	}
	if width > 0.0 || height > 0.0 {
		if filters != "" {
			filters += ","
		}
		filters += fmt.Sprintf("scale=%d:%d:flags=lanczos", width, height)
	}
	if len(filters) > 0 {
		palettegen = fmt.Sprintf("%s,palettegen", filters)
	} else {
		palettegen = "palettegen"
	}
	defer func() {
		eng.Junk = append(eng.Junk, palette, output)
	}()
	// TODO(jfm): make these structured, with omission as a field.
	genPalette := eng.command(
		eng.FFmpeg,
		"-ss", fmt.Sprintf("%2f;omitempty", start),
		"-t", fmt.Sprintf("%2f;omitempty", duration),
		"-i", video,
		"-vf", palettegen,
		"-y", palette,
	)
	if out, err := genPalette.CombinedOutput(); err != nil {
		return "", errors.Wrapf(err, "generating palette: %s", string(out))
	}
	makeGif := eng.command(
		eng.FFmpeg,
		"-ss", fmt.Sprintf("%2f;omitempty", start),
		"-t", fmt.Sprintf("%2f;omitempty", duration),
		"-i", video, "-i", palette,
		"-lavfi", fmt.Sprintf("%s [x]; [x][1:v] paletteuse", filters),
		"-y", output,
	)
	if out, err := makeGif.CombinedOutput(); err != nil {
		return "", errors.Wrapf(err, "making gif: %s", string(out))
	}
	return output, nil
}

// Crush reduces the file size of a gif image.
// Accepts a filepath to the gif image and replaces it with the crushed gif.
// Fuzz is a percentage value between 0 and 100, where 0 is best quality, 100 is
// smallest file size. Optimal is typically 2-5.
func (eng *Engine) Crush(gif string, fuzz int) error {
	if eng.Convert == "" {
		return nil
	}
	args := []string{gif}
	if fuzz > 0 {
		args = append(args, "-fuzz", fmt.Sprintf("%d%%", fuzz))
	}
	args = append(args, "-layers", "Optimize", gif)
	crushGif := eng.command(eng.Convert, args...)
	if out, err := crushGif.CombinedOutput(); err != nil {
		return errors.Wrap(err, string(out))
	}
	return nil
}

// Clean the temporary files.
func (eng *Engine) Clean() {
	for _, f := range eng.Junk {
		if err := os.Remove(f); err != nil {
			eng.logf("clean: %v\n", err)
		}
	}
}

// command creates a new exec.Cmd after removing empty arguments.
// If an argument value contains "<value>;omitempty" and <value> is a zero
// value, the argument value and it's corresponding argument specifier are
// considered "empty" and omitted.
func (eng *Engine) command(cmd string, args ...string) *exec.Cmd {
	var a []string
	for ii := 0; ii < len(args); ii++ {
		arg := args[ii]
		if arg[0] == '-' { // This is an argument specifier eg "-h".
			if v := args[ii+1]; v == "" {
				ii++
				continue
			} else if strings.Contains(v, ";omitempty") {
				// Handle special ;omitempty directive.
				v = strings.Split(v, ";omitempty")[0]
				if v == "" {
					ii++
					continue
				}
				x, _ := strconv.Atoi(v)
				if x == 0 {
					ii++
					continue
				}
				fl, _ := strconv.ParseFloat(v, 64)
				if fl <= 0.0 {
					ii++
					continue
				}
				args[ii+1] = v
			}
		}
		a = append(a, arg)
	}
	if eng.Debug {
		eng.logf("%s %s\n", cmd, strings.Join(a, " "))
	}
	return exec.Command(cmd, a...)
}

func (eng *Engine) logf(f string, v ...interface{}) (int, error) {
	if eng.Debug && eng.Out != nil {
		return fmt.Fprintf(eng.Out, f, v...)
	}
	return 0, nil
}

// path resolves the given path segments against the configured directory.
func (eng *Engine) path(s ...string) string {
	p := filepath.Join(s...)
	eng.logf("dir: %s, p: %s\n", eng.Dir, p)
	p = strings.Replace(p, eng.Dir, "", 1)
	return filepath.Join(eng.Dir, p)
}

func (eng *Engine) init() (err error) {
	eng.once.Do(func() {
		if eng.FFmpeg == "" {
			eng.FFmpeg = "ffmpeg"
		}
		if eng.Dir == "" {
			return
		}
		err = os.MkdirAll(eng.Dir, 0755)
		if err != nil && !os.IsExist(err) {
			err = errors.Wrap(err, "preparing directories")
		} else if os.IsExist(err) {
			err = nil
		}
	})
	return err
}