FFmpeg locator (TASK 4 ship step 2) + licensing: notices, About, LGPL-shared pin

IFfmpegLocator seam that resolves ffmpeg.exe (PATH -> cache -> pinned download), plus the licensing compliance that makes a paid GA product defensible. NOTE FOR USERS: this change shows NO difference in the app's behavior except a new top-bar "About" button (opens THIRD-PARTY-NOTICES.txt). It is scaffolding for the encoder/streaming work. - Services/Encoder/: IFfmpegLocator + FfmpegLocator. Pin is BtbN lgpl-shared autobuild-2026-08-09-13-03 (NOT gyan.dev/GPL or static: LGPLv2.1 §6 static relink material avoided by dynamic linking); extracts ffmpeg.exe + libav*.dll via a staging dir so a crash never leaves a partial cache - THIRD-PARTY-NOTICES.txt: LGPL/BSD/MIT notices + source offer, copied to the build output, surfaced by the About button; v1 gate = bundle full license texts (TASK 4 requirement 9) - ai.md "Licensing - do not violate" guardrails (never GPL/nonfree/static/latest- tag, never link FFmpeg in, never drop notices); TASKS.md + Services/index.md updated - Tests: FfmpegLocatorTests - hermetic decision-ladder integration test + shared- build DLL extraction + edge cases; docs updated (78 tests passing, 0 warnings)
2026-08-10 11:02:26 -07:00
parent 18a21010bb
commit 8c7938aca0
10 changed files with 529 additions and 6 deletions
@@ -0,0 +1,129 @@
+using System.IO;
+using System.IO.Compression;
+using System.Net.Http;
+using ytLive.Helpers;
+
+namespace ytLive.Services.Encoder;
+
+/// <summary>
+/// The default <see cref="IFfmpegLocator"/>: probe PATH first (the user's own
+/// install wins), then the cache in <c>%APPDATA%\ytLlive\tools</c>, then pull the
+/// pinned BtbN **lgpl-shared** build (TASK 4 ship step 2). The shared variant is a
+/// deliberate licensing choice: dynamic linking means LGPL compliance is "license
+/// text + source offer", with no static-relink (LGPL §6) material required. The
+/// shared zip puts <c>ffmpeg.exe</c> plus the <c>libav*.dll</c> family in <c>bin/</c>,
+/// so both are extracted — Windows resolves the DLLs from the exe's own directory.
+/// Search dirs, tools dir, and the downloader are constructor-injected so tests
+/// fake the network and stay on a temp directory.
+/// </summary>
+public sealed class FfmpegLocator : IFfmpegLocator
+{
+    public const string FileName = "ffmpeg.exe";
+
+    /// <summary>Pinned BtbN LGPL-shared win64 build (immutable autobuild tag; see TASKS.md).</summary>
+    public const string PinnedUrl =
+        "https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2026-08-09-13-03/ffmpeg-master-latest-win64-lgpl-shared.zip";
+
+    private readonly string[] _searchDirs;
+    private readonly string _toolsDir;
+    private readonly Func<string, CancellationToken, Task<byte[]>> _downloader;
+
+    public FfmpegLocator(
+        string[]? searchDirs = null,
+        string? toolsDir = null,
+        Func<string, CancellationToken, Task<byte[]>>? downloader = null)
+    {
+        _searchDirs = searchDirs ?? ParsePath();
+        _toolsDir = toolsDir ?? Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ytLlive", "tools");
+        _downloader = downloader ?? DefaultDownload;
+    }
+
+    public async Task<string> LocateAsync(CancellationToken cancellationToken = default)
+    {
+        foreach (var dir in _searchDirs)
+        {
+            if (string.IsNullOrEmpty(dir)) continue;
+            var candidate = Path.Combine(dir, FileName);
+            if (File.Exists(candidate)) return candidate;
+        }
+
+        var cached = Path.Combine(_toolsDir, FileName);
+        if (File.Exists(cached) && new FileInfo(cached).Length > 0) return cached;
+
+        try
+        {
+            var zip = await _downloader(PinnedUrl, cancellationToken).ConfigureAwait(false);
+            if (zip.Length == 0)
+                throw new IOException($"FFmpeg download from {PinnedUrl} returned an empty payload.");
+            Directory.CreateDirectory(_toolsDir);
+            ExtractBinaries(zip, _toolsDir);
+            return cached;
+        }
+        catch (Exception ex) when (ex is IOException or InvalidDataException or NotSupportedException)
+        {
+            AppLog.Write(ex, "FFmpeg locator: download/extract failed");
+            throw;
+        }
+    }
+
+    /// <summary>
+    /// Extract <c>ffmpeg.exe</c> and every <c>*.dll</c> into <c>toolsDir</c> via a
+    /// staging directory, so a failed extract never leaves a partially-populated
+    /// cache behind (the previous good cache stays until every move succeeds).
+    /// </summary>
+    private static void ExtractBinaries(byte[] zip, string toolsDir)
+    {
+        var staging = toolsDir + ".stage";
+        if (Directory.Exists(staging)) Directory.Delete(staging, recursive: true);
+        Directory.CreateDirectory(staging);
+        try
+        {
+            using var stream = new MemoryStream(zip, writable: false);
+            using var archive = new ZipArchive(stream, ZipArchiveMode.Read);
+            var exe = archive.Entries.FirstOrDefault(
+                    e => e.FullName.EndsWith("/" + FileName, StringComparison.OrdinalIgnoreCase))
+                ?? throw new InvalidDataException($"The pinned FFmpeg archive does not contain {FileName}.");
+            ExtractOne(exe, Path.Combine(staging, FileName));
+            foreach (var entry in archive.Entries)
+            {
+                if (entry.FullName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
+                    ExtractOne(entry, Path.Combine(staging, Path.GetFileName(entry.FullName)));
+            }
+            foreach (var file in Directory.GetFiles(staging))
+                File.Move(file, Path.Combine(toolsDir, Path.GetFileName(file)), overwrite: true);
+        }
+        finally
+        {
+            if (Directory.Exists(staging)) Directory.Delete(staging, recursive: true);
+        }
+    }
+
+    private static void ExtractOne(ZipArchiveEntry entry, string destination)
+    {
+        var temp = destination + ".tmp";
+        try
+        {
+            using (var source = entry.Open())
+            using (var target = File.Create(temp))
+                source.CopyTo(target);
+            File.Move(temp, destination);
+        }
+        finally
+        {
+            if (File.Exists(temp)) File.Delete(temp);
+        }
+    }
+
+    private static async Task<byte[]> DefaultDownload(string url, CancellationToken ct)
+    {
+        using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(10) };
+        return await http.GetByteArrayAsync(url, ct).ConfigureAwait(false);
+    }
+
+    private static string[] ParsePath()
+    {
+        var raw = Environment.GetEnvironmentVariable("PATH") ?? "";
+        return raw.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);
+    }
+}
@@ -0,0 +1,20 @@
+namespace ytLive.Services.Encoder;
+
+/// <summary>
+/// Resolves an absolute path to a usable <c>ffmpeg.exe</c>, downloading it on
+/// first use if neither the user's PATH nor the local cache provides one — the
+/// encoder's one external dependency is never shipped in the repo (TASK 4 ship
+/// step 2; see TASKS.md). Seam so the encoder step and the tests can fake it.
+/// </summary>
+public interface IFfmpegLocator
+{
+    /// <summary>
+    /// Returns the path to <c>ffmpeg.exe</c>: the first PATH candidate that
+    /// exists, else the cached copy, else a freshly downloaded one (ffmpeg.exe +
+    /// its libav DLLs extracted from the pinned BtbN LGPL-shared zip into the
+    /// tools directory).
+    /// </summary>
+    /// <exception cref="IOException">The download/extract produced no usable
+    /// binary (offline, expired pin, corrupt archive) — recoverable, logged.</exception>
+    Task<string> LocateAsync(CancellationToken cancellationToken = default);
+}
@@ -31,6 +31,8 @@ External-facing logic: YouTube API, persistence. See
 | `Compositor/CompositorOptions.cs` | The active tier's output rect (source space over the 1920×1080 master, integer-aligned — `MainViewModel.OutputRectX` can be 656.5) + target W×H |
 | `Compositor/StretchMath.cs` | Pure pixel math: the WPF `UniformToFill` cover-crop, clamped bilinear sample/scale (unit-tested half of the compositor) |
 | `Compositor/StaticPixelCache.cs` | Asset bytes → cached BGRA8 `VideoFrame`, decoded once per content hash — the output path's raw-pixel source (the preview uses ImageCache's `BitmapImage`) |
+| `Encoder/IFfmpegLocator.cs` | **TASK 4 ship step 2 seam**: resolves an absolute path to `ffmpeg.exe` (PATH first → cached `%APPDATA%\ytLlive\tools\ffmpeg.exe` → pinned BtbN LGPL-shared zip download). The encoder step and tests fake it |
+| `Encoder/FfmpegLocator.cs` | The default locator: PATH probe wins, then the cache, then pull+extract (`ffmpeg.exe` **+ the `libav*.dll` family** via a staging dir, failures via `AppLog`). Pinned to BtbN `autobuild-2026-08-09-13-03` **lgpl-shared** (dynamic linking = LGPL compliance without static-relink §6 material; no GPL libx264; NVENC/QSV/AMF + libopenh264 + native AAC — see `ai.md` → Licensing). Search dirs / tools dir / downloader constructor-injected for hermetic tests. Not yet constructed by the app (the encoder step wires it) |

 Related: constructed in [`ViewModels/MainViewModel.cs`](../ViewModels/MainViewModel.cs)
 (no DI container yet). Models in [`Models/index.md`](../Models/index.md).