add find-and-enflac pcm compressor

find-and-enflac/main.go

@@ -0,0 +1,121 @@
+// Command find-and-enflac walks a directory tree, finds every
+// uncompressed PCM audio file, and losslessly compresses them all in
+// parallel. An original is deleted only after its encoded replacement
+// has been verified to decode back to bit-identical audio.
+//
+// Integer PCM becomes FLAC. IEEE float PCM becomes WavPack, which is
+// the only common lossless codec that stores float samples exactly;
+// FLAC has no float sample type at all.
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log/slog"
+	"os"
+	"os/exec"
+	"os/signal"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"syscall"
+)
+
+func main() {
+	jobs := flag.Int("jobs", runtime.NumCPU(), "files to encode concurrently")
+	threads := flag.Int("threads", runtime.NumCPU(), "threads per ffmpeg")
+	dryRun := flag.Bool("n", false, "report what would be done, change nothing")
+
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "usage: %s [flags] [directory]\n\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "Losslessly compress PCM audio under directory (default \".\").\n\n")
+		flag.PrintDefaults()
+	}
+	flag.Parse()
+
+	if flag.NArg() > 1 {
+		flag.Usage()
+		os.Exit(2)
+	}
+
+	root := "."
+	if flag.NArg() == 1 {
+		root = flag.Arg(0)
+	}
+
+	if err := run(root, *jobs, *threads, *dryRun); err != nil {
+		slog.Error("fatal", "err", err)
+		os.Exit(1)
+	}
+}
+
+func run(root string, jobs, threads int, dryRun bool) error {
+	for _, tool := range []string{"ffmpeg", "ffprobe"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			return fmt.Errorf("%s not found in PATH: %w", tool, err)
+		}
+	}
+
+	if jobs < 1 || threads < 1 {
+		return fmt.Errorf("jobs and threads must be at least 1")
+	}
+
+	info, err := os.Stat(root)
+	if err != nil {
+		return err
+	}
+	if !info.IsDir() {
+		return fmt.Errorf("not a directory: %s", root)
+	}
+
+	// Ctrl-C cancels in-flight ffmpeg runs; a killed encode fails
+	// verification, so its partial output is removed and its source
+	// is left alone.
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	srcs, err := findPCM(root)
+	if err != nil {
+		return err
+	}
+	if len(srcs) == 0 {
+		slog.Info("no PCM audio found", "root", root)
+		return nil
+	}
+	slog.Info("found PCM audio", "files", len(srcs), "jobs", jobs, "threads", threads)
+
+	enc := &encoder{threads: threads, dryRun: dryRun}
+
+	var failed atomic.Int64
+	queue := make(chan string)
+	var wg sync.WaitGroup
+
+	for range jobs {
+		wg.Go(func() {
+			for src := range queue {
+				if err := enc.encodeOne(ctx, src); err != nil {
+					slog.Error("failed", "src", src, "err", err)
+					failed.Add(1)
+				}
+			}
+		})
+	}
+
+	for _, src := range srcs {
+		if ctx.Err() != nil {
+			break
+		}
+		queue <- src
+	}
+	close(queue)
+	wg.Wait()
+
+	if n := failed.Load(); n > 0 {
+		return fmt.Errorf("%d of %d file(s) failed", n, len(srcs))
+	}
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+	return nil
+}