update

core/ffmpeg/ffmpeg.go

@@ -0,0 +1,228 @@
+package ffmpeg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+)
+
+type FFmpeg interface {
+	Transcode(ctx context.Context, command, path string, maxBitRate, offset int) (io.ReadCloser, error)
+	ExtractImage(ctx context.Context, path string) (io.ReadCloser, error)
+	Probe(ctx context.Context, files []string) (string, error)
+	CmdPath() (string, error)
+	IsAvailable() bool
+	Version() string
+}
+
+func New() FFmpeg {
+	return &ffmpeg{}
+}
+
+const (
+	extractImageCmd = "ffmpeg -i %s -map 0:v -map -0:V -vcodec copy -f image2pipe -"
+	probeCmd        = "ffmpeg %s -f ffmetadata"
+)
+
+type ffmpeg struct{}
+
+func (e *ffmpeg) Transcode(ctx context.Context, command, path string, maxBitRate, offset int) (io.ReadCloser, error) {
+	if _, err := ffmpegCmd(); err != nil {
+		return nil, err
+	}
+	// First make sure the file exists
+	if err := fileExists(path); err != nil {
+		return nil, err
+	}
+	args := createFFmpegCommand(command, path, maxBitRate, offset)
+	return e.start(ctx, args)
+}
+
+func (e *ffmpeg) ExtractImage(ctx context.Context, path string) (io.ReadCloser, error) {
+	if _, err := ffmpegCmd(); err != nil {
+		return nil, err
+	}
+	// First make sure the file exists
+	if err := fileExists(path); err != nil {
+		return nil, err
+	}
+	args := createFFmpegCommand(extractImageCmd, path, 0, 0)
+	return e.start(ctx, args)
+}
+
+func fileExists(path string) error {
+	s, err := os.Stat(path)
+	if err != nil {
+		return err
+	}
+	if s.IsDir() {
+		return fmt.Errorf("'%s' is a directory", path)
+	}
+	return nil
+}
+
+func (e *ffmpeg) Probe(ctx context.Context, files []string) (string, error) {
+	if _, err := ffmpegCmd(); err != nil {
+		return "", err
+	}
+	args := createProbeCommand(probeCmd, files)
+	log.Trace(ctx, "Executing ffmpeg command", "args", args)
+	cmd := exec.CommandContext(ctx, args[0], args[1:]...) // #nosec
+	output, _ := cmd.CombinedOutput()
+	return string(output), nil
+}
+
+func (e *ffmpeg) CmdPath() (string, error) {
+	return ffmpegCmd()
+}
+
+func (e *ffmpeg) IsAvailable() bool {
+	_, err := ffmpegCmd()
+	return err == nil
+}
+
+// Version executes ffmpeg -version and extracts the version from the output.
+// Sample output: ffmpeg version 6.0 Copyright (c) 2000-2023 the FFmpeg developers
+func (e *ffmpeg) Version() string {
+	cmd, err := ffmpegCmd()
+	if err != nil {
+		return "N/A"
+	}
+	out, err := exec.Command(cmd, "-version").CombinedOutput() // #nosec
+	if err != nil {
+		return "N/A"
+	}
+	parts := strings.Split(string(out), " ")
+	if len(parts) < 3 {
+		return "N/A"
+	}
+	return parts[2]
+}
+
+func (e *ffmpeg) start(ctx context.Context, args []string) (io.ReadCloser, error) {
+	log.Trace(ctx, "Executing ffmpeg command", "cmd", args)
+	j := &ffCmd{args: args}
+	j.PipeReader, j.out = io.Pipe()
+	err := j.start(ctx)
+	if err != nil {
+		return nil, err
+	}
+	go j.wait()
+	return j, nil
+}
+
+type ffCmd struct {
+	*io.PipeReader
+	out  *io.PipeWriter
+	args []string
+	cmd  *exec.Cmd
+}
+
+func (j *ffCmd) start(ctx context.Context) error {
+	cmd := exec.CommandContext(ctx, j.args[0], j.args[1:]...) // #nosec
+	cmd.Stdout = j.out
+	if log.IsGreaterOrEqualTo(log.LevelTrace) {
+		cmd.Stderr = os.Stderr
+	} else {
+		cmd.Stderr = io.Discard
+	}
+	j.cmd = cmd
+
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("starting cmd: %w", err)
+	}
+	return nil
+}
+
+func (j *ffCmd) wait() {
+	if err := j.cmd.Wait(); err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
+			_ = j.out.CloseWithError(fmt.Errorf("%s exited with non-zero status code: %d", j.args[0], exitErr.ExitCode()))
+		} else {
+			_ = j.out.CloseWithError(fmt.Errorf("waiting %s cmd: %w", j.args[0], err))
+		}
+		return
+	}
+	_ = j.out.Close()
+}
+
+// Path will always be an absolute path
+func createFFmpegCommand(cmd, path string, maxBitRate, offset int) []string {
+	var args []string
+	for _, s := range fixCmd(cmd) {
+		if strings.Contains(s, "%s") {
+			s = strings.ReplaceAll(s, "%s", path)
+			args = append(args, s)
+			if offset > 0 && !strings.Contains(cmd, "%t") {
+				args = append(args, "-ss", strconv.Itoa(offset))
+			}
+		} else {
+			s = strings.ReplaceAll(s, "%t", strconv.Itoa(offset))
+			s = strings.ReplaceAll(s, "%b", strconv.Itoa(maxBitRate))
+			args = append(args, s)
+		}
+	}
+	return args
+}
+
+func createProbeCommand(cmd string, inputs []string) []string {
+	var args []string
+	for _, s := range fixCmd(cmd) {
+		if s == "%s" {
+			for _, inp := range inputs {
+				args = append(args, "-i", inp)
+			}
+		} else {
+			args = append(args, s)
+		}
+	}
+	return args
+}
+
+func fixCmd(cmd string) []string {
+	split := strings.Fields(cmd)
+	cmdPath, _ := ffmpegCmd()
+	for i, s := range split {
+		if s == "ffmpeg" || s == "ffmpeg.exe" {
+			split[i] = cmdPath
+		}
+	}
+	return split
+}
+
+func ffmpegCmd() (string, error) {
+	ffOnce.Do(func() {
+		if conf.Server.FFmpegPath != "" {
+			ffmpegPath = conf.Server.FFmpegPath
+			ffmpegPath, ffmpegErr = exec.LookPath(ffmpegPath)
+		} else {
+			ffmpegPath, ffmpegErr = exec.LookPath("ffmpeg")
+			if errors.Is(ffmpegErr, exec.ErrDot) {
+				log.Trace("ffmpeg found in current folder '.'")
+				ffmpegPath, ffmpegErr = exec.LookPath("./ffmpeg")
+			}
+		}
+		if ffmpegErr == nil {
+			log.Info("Found ffmpeg", "path", ffmpegPath)
+			return
+		}
+	})
+	return ffmpegPath, ffmpegErr
+}
+
+// These variables are accessible here for tests. Do not use them directly in production code. Use ffmpegCmd() instead.
+var (
+	ffOnce     sync.Once
+	ffmpegPath string
+	ffmpegErr  error
+)

core/ffmpeg/ffmpeg_test.go

@@ -0,0 +1,166 @@
+package ffmpeg
+
+import (
+	"context"
+	"runtime"
+	sync "sync"
+	"testing"
+	"time"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestFFmpeg(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelFatal)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "FFmpeg Suite")
+}
+
+var _ = Describe("ffmpeg", func() {
+	BeforeEach(func() {
+		_, _ = ffmpegCmd()
+		ffmpegPath = "ffmpeg"
+		ffmpegErr = nil
+	})
+	Describe("createFFmpegCommand", func() {
+		It("creates a valid command line", func() {
+			args := createFFmpegCommand("ffmpeg -i %s -b:a %bk mp3 -", "/music library/file.mp3", 123, 0)
+			Expect(args).To(Equal([]string{"ffmpeg", "-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
+		})
+		It("handles extra spaces in the command string", func() {
+			args := createFFmpegCommand("ffmpeg    -i %s -b:a    %bk      mp3 -", "/music library/file.mp3", 123, 0)
+			Expect(args).To(Equal([]string{"ffmpeg", "-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
+		})
+		Context("when command has time offset param", func() {
+			It("creates a valid command line with offset", func() {
+				args := createFFmpegCommand("ffmpeg -i %s -b:a %bk -ss %t mp3 -", "/music library/file.mp3", 123, 456)
+				Expect(args).To(Equal([]string{"ffmpeg", "-i", "/music library/file.mp3", "-b:a", "123k", "-ss", "456", "mp3", "-"}))
+			})
+
+		})
+		Context("when command does not have time offset param", func() {
+			It("adds time offset after the input file name", func() {
+				args := createFFmpegCommand("ffmpeg -i %s -b:a %bk mp3 -", "/music library/file.mp3", 123, 456)
+				Expect(args).To(Equal([]string{"ffmpeg", "-i", "/music library/file.mp3", "-ss", "456", "-b:a", "123k", "mp3", "-"}))
+			})
+		})
+	})
+
+	Describe("createProbeCommand", func() {
+		It("creates a valid command line", func() {
+			args := createProbeCommand(probeCmd, []string{"/music library/one.mp3", "/music library/two.mp3"})
+			Expect(args).To(Equal([]string{"ffmpeg", "-i", "/music library/one.mp3", "-i", "/music library/two.mp3", "-f", "ffmetadata"}))
+		})
+	})
+
+	When("ffmpegPath is set", func() {
+		It("returns the correct ffmpeg path", func() {
+			ffmpegPath = "/usr/bin/ffmpeg"
+			args := createProbeCommand(probeCmd, []string{"one.mp3"})
+			Expect(args).To(Equal([]string{"/usr/bin/ffmpeg", "-i", "one.mp3", "-f", "ffmetadata"}))
+		})
+		It("returns the correct ffmpeg path with spaces", func() {
+			ffmpegPath = "/usr/bin/with spaces/ffmpeg.exe"
+			args := createProbeCommand(probeCmd, []string{"one.mp3"})
+			Expect(args).To(Equal([]string{"/usr/bin/with spaces/ffmpeg.exe", "-i", "one.mp3", "-f", "ffmetadata"}))
+		})
+	})
+
+	Describe("FFmpeg", func() {
+		Context("when FFmpeg is available", func() {
+			var ff FFmpeg
+
+			BeforeEach(func() {
+				ffOnce = sync.Once{}
+				ff = New()
+				// Skip if FFmpeg is not available
+				if !ff.IsAvailable() {
+					Skip("FFmpeg not available on this system")
+				}
+			})
+
+			It("should interrupt transcoding when context is cancelled", func() {
+				ctx, cancel := context.WithTimeout(GinkgoT().Context(), 5*time.Second)
+				defer cancel()
+
+				// Use a command that generates audio indefinitely
+				// -f lavfi uses FFmpeg's built-in audio source
+				// -t 0 means no time limit (runs forever)
+				command := "ffmpeg -f lavfi -i sine=frequency=1000:duration=0 -f mp3 -"
+
+				// The input file is not used here, but we need to provide a valid path to the Transcode function
+				stream, err := ff.Transcode(ctx, command, "tests/fixtures/test.mp3", 128, 0)
+				Expect(err).ToNot(HaveOccurred())
+				defer stream.Close()
+
+				// Read some data first to ensure FFmpeg is running
+				buf := make([]byte, 1024)
+				_, err = stream.Read(buf)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Cancel the context
+				cancel()
+
+				// Next read should fail due to cancelled context
+				_, err = stream.Read(buf)
+				Expect(err).To(HaveOccurred())
+			})
+
+			It("should handle immediate context cancellation", func() {
+				ctx, cancel := context.WithCancel(GinkgoT().Context())
+				cancel() // Cancel immediately
+
+				// This should fail immediately
+				_, err := ff.Transcode(ctx, "ffmpeg -i %s -f mp3 -", "tests/fixtures/test.mp3", 128, 0)
+				Expect(err).To(MatchError(context.Canceled))
+			})
+		})
+
+		Context("with mock process behavior", func() {
+			var longRunningCmd string
+			BeforeEach(func() {
+				// Use a long-running command for testing cancellation
+				switch runtime.GOOS {
+				case "windows":
+					// Use PowerShell's Start-Sleep
+					ffmpegPath = "powershell"
+					longRunningCmd = "powershell -Command Start-Sleep -Seconds 10"
+				default:
+					// Use sleep on Unix-like systems
+					ffmpegPath = "sleep"
+					longRunningCmd = "sleep 10"
+				}
+			})
+
+			It("should terminate the underlying process when context is cancelled", func() {
+				ff := New()
+				ctx, cancel := context.WithTimeout(GinkgoT().Context(), 5*time.Second)
+				defer cancel()
+
+				// Start a process that will run for a while
+				stream, err := ff.Transcode(ctx, longRunningCmd, "tests/fixtures/test.mp3", 0, 0)
+				Expect(err).ToNot(HaveOccurred())
+				defer stream.Close()
+
+				// Give the process time to start
+				time.Sleep(50 * time.Millisecond)
+
+				// Cancel the context
+				cancel()
+
+				// Try to read from the stream, which should fail
+				buf := make([]byte, 100)
+				_, err = stream.Read(buf)
+				Expect(err).To(HaveOccurred(), "Expected stream to be closed due to process termination")
+
+				// Verify the stream is closed by attempting another read
+				_, err = stream.Read(buf)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+})