Sybren A. Stüvel
ab8ecc24cc
Add license specifiers to Go files that were missing them: ``` // SPDX-License-Identifier: GPL-3.0-or-later ``` No functional changes.
128 lines
3.4 KiB
Go
128 lines
3.4 KiB
Go
// package find_ffmpeg can find an FFmpeg binary on the system.
|
|
package find_ffmpeg
|
|
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/rs/zerolog/log"
|
|
)
|
|
|
|
type Result struct {
|
|
Path string
|
|
Version string
|
|
}
|
|
|
|
const (
|
|
// ffmpegExename is the name of the ffmpeg executable. It will be suffixed by
|
|
// the platform-depentent `exeSuffix`
|
|
ffmpegExename = "ffmpeg"
|
|
|
|
// toolsDir is the directory sitting next to the currently running executable,
|
|
// in which tools like FFmpeg are searched for.
|
|
toolsDir = "tools"
|
|
)
|
|
|
|
// Find returns the path of an `ffmpeg` executable,
|
|
// If there is one next to the currently running executable, that one is used.
|
|
// Otherwise $PATH is searched.
|
|
func Find() (Result, error) {
|
|
path, err := findBundled()
|
|
switch {
|
|
case errors.Is(err, fs.ErrNotExist):
|
|
// Not finding FFmpeg next to the executable is fine, just continue searching.
|
|
case err != nil:
|
|
// Other errors might be more serious. Log them, but keep going.
|
|
log.Error().Err(err).Msg("error finding FFmpeg next to the current executable")
|
|
case path != "":
|
|
// Found FFmpeg!
|
|
return getVersion(path)
|
|
}
|
|
|
|
path, err = exec.LookPath(ffmpegExename)
|
|
if err != nil {
|
|
return Result{}, err
|
|
}
|
|
return getVersion(path)
|
|
}
|
|
|
|
func findBundled() (string, error) {
|
|
exe, err := os.Executable()
|
|
if err != nil {
|
|
return "", fmt.Errorf("finding current executable: %w", err)
|
|
}
|
|
|
|
exeDir := filepath.Dir(exe)
|
|
|
|
// Subdirectories to use to find the ffmpeg executable. Should go from most to
|
|
// least specific for the current platform.
|
|
filenames := []string{
|
|
fmt.Sprintf("%s-%s-%s%s", ffmpegExename, runtime.GOOS, runtime.GOARCH, exeSuffix),
|
|
fmt.Sprintf("%s-%s%s", ffmpegExename, runtime.GOOS, exeSuffix),
|
|
fmt.Sprintf("%s%s", ffmpegExename, exeSuffix),
|
|
}
|
|
|
|
var firstErr error
|
|
for _, filename := range filenames {
|
|
ffmpegPath := filepath.Join(exeDir, toolsDir, filename)
|
|
_, err = os.Stat(ffmpegPath)
|
|
|
|
switch {
|
|
case err == nil:
|
|
return ffmpegPath, nil
|
|
case errors.Is(err, fs.ErrNotExist):
|
|
log.Debug().Str("path", ffmpegPath).Msg("FFmpeg not found on this path")
|
|
default:
|
|
log.Debug().Err(err).Str("path", ffmpegPath).Msg("FFmpeg could not be accessed on this path")
|
|
}
|
|
|
|
// If every path fails, report on the first-failed path, as that's the most
|
|
// specific one.
|
|
if firstErr == nil {
|
|
firstErr = err
|
|
}
|
|
}
|
|
|
|
return "", firstErr
|
|
}
|
|
|
|
func getVersion(path string) (Result, error) {
|
|
ctx, ctxCancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer ctxCancel()
|
|
|
|
cmd := exec.CommandContext(ctx, path, "-version")
|
|
outputBytes, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
return Result{}, fmt.Errorf("running %s -version: %w", path, err)
|
|
}
|
|
output := string(outputBytes)
|
|
|
|
lines := strings.SplitN(output, "\n", 2)
|
|
if len(lines) < 2 {
|
|
return Result{}, fmt.Errorf("unexpected output (only %d lines) from %s -version: %s", len(lines), path, output)
|
|
}
|
|
versionLine := lines[0]
|
|
|
|
// Get the version from the first line of output.
|
|
// ffmpeg version 4.2.7-0ubuntu0.1 Copyright (c) 2000-2022 the FFmpeg developer
|
|
if !strings.HasPrefix(versionLine, "ffmpeg version ") {
|
|
return Result{}, fmt.Errorf("unexpected output from %s -version: [%s]", path, versionLine)
|
|
}
|
|
lineParts := strings.SplitN(versionLine, " ", 4)
|
|
|
|
return Result{
|
|
Path: path,
|
|
Version: lineParts[2],
|
|
}, nil
|
|
}
|