Initial commit: CinemaTrailers4Jellyfins plugin

Adapted from Trailers4Jellyfin: keeps TMDB/YouTube trailer downloading,
the scheduled task, language/source/date filters, and trailer rotation,
but drops cinema-mode/IIntroProvider entirely. Each trailer now ships in
its own fake-movie folder (placeholder video + locked NFO + trailer) for
use with a Cinema Mode / trailer pre-roll plugin.

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerDownloadService.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using YoutubeExplode;
+using YoutubeExplode.Videos.Streams;
+
+namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
+{
+    public class TrailerDownloadService : IDisposable
+    {
+        private readonly ILogger<TrailerDownloadService> _logger;
+        private readonly HttpClient _httpClient;
+
+        public TrailerDownloadService(ILogger<TrailerDownloadService> logger)
+        {
+            _logger = logger;
+
+            // Force IPv4 to avoid ~80s delay when IPv6 is unreachable (Happy Eyeballs fallback).
+            var handler = new SocketsHttpHandler
+            {
+                ConnectCallback = async (ctx, ct) =>
+                {
+                    var entry = await Dns.GetHostEntryAsync(ctx.DnsEndPoint.Host, AddressFamily.InterNetwork, ct).ConfigureAwait(false);
+                    var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+                    socket.NoDelay = true;
+                    try
+                    {
+                        await socket.ConnectAsync(entry.AddressList[0], ctx.DnsEndPoint.Port, ct).ConfigureAwait(false);
+                        return new NetworkStream(socket, ownsSocket: true);
+                    }
+                    catch
+                    {
+                        socket.Dispose();
+                        throw;
+                    }
+                }
+            };
+            _httpClient = new HttpClient(handler) { Timeout = TimeSpan.FromMinutes(10) };
+        }
+
+        public void Dispose() => _httpClient.Dispose();
+
+        /// <summary>
+        /// Downloads a YouTube video by key to outputPath.
+        /// Uses yt-dlp when a valid path is configured (supports 1080p+, requires ffmpeg on PATH).
+        /// Falls back to YoutubeExplode for built-in download (max 720p, no external tools needed).
+        /// </summary>
+        public async Task<bool> DownloadAsync(
+            string youtubeKey,
+            string outputPath,
+            int preferredHeight,
+            string ytDlpPath,
+            CancellationToken ct)
+        {
+            Directory.CreateDirectory(Path.GetDirectoryName(outputPath)!);
+
+            if (!string.IsNullOrWhiteSpace(ytDlpPath) && File.Exists(ytDlpPath))
+            {
+                return await DownloadWithYtDlpAsync(youtubeKey, outputPath, preferredHeight, ytDlpPath, ct)
+                    .ConfigureAwait(false);
+            }
+
+            return await DownloadWithYoutubeExplodeAsync(youtubeKey, outputPath, preferredHeight, ct)
+                .ConfigureAwait(false);
+        }
+
+        private async Task<bool> DownloadWithYoutubeExplodeAsync(
+            string key,
+            string outputPath,
+            int preferredHeight,
+            CancellationToken ct)
+        {
+            try
+            {
+                var youtube = new YoutubeClient(_httpClient);
+                var manifest = await youtube.Videos.Streams
+                    .GetManifestAsync($"https://www.youtube.com/watch?v={key}", ct)
+                    .ConfigureAwait(false);
+
+                // Muxed streams include audio+video in one file. Quality is capped at 720p by YouTube.
+                var muxedStreams = manifest.GetMuxedStreams().ToList();
+                if (muxedStreams.Count == 0)
+                {
+                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No muxed streams available for {Key}. Consider configuring yt-dlp for 1080p support.", key);
+                    return false;
+                }
+
+                // Prefer the highest quality at or below the configured height limit.
+                var stream = muxedStreams
+                    .Where(s => s.VideoQuality.MaxHeight <= preferredHeight)
+                    .OrderByDescending(s => s.VideoQuality.MaxHeight)
+                    .FirstOrDefault()
+                    ?? muxedStreams.OrderByDescending(s => s.VideoQuality.MaxHeight).First();
+
+                _logger.LogInformation(
+                    "|CinemaTrailers4Jellyfins| Downloading {Key} at {Quality} to {Path}",
+                    key, stream.VideoQuality.Label, outputPath);
+
+                await youtube.Videos.Streams
+                    .DownloadAsync(stream, outputPath, cancellationToken: ct)
+                    .ConfigureAwait(false);
+
+                return true;
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| YoutubeExplode download failed for {Key}", key);
+                return false;
+            }
+        }
+
+        private async Task<bool> DownloadWithYtDlpAsync(
+            string key,
+            string outputPath,
+            int preferredHeight,
+            string ytDlpPath,
+            CancellationToken ct)
+        {
+            try
+            {
+                // Format selects the best video at or below preferredHeight merged with the best audio.
+                // --merge-output-format mp4 ensures the output is always an mp4.
+                var args = string.Join(" ",
+                    $"-f \"bestvideo[height<={preferredHeight}]+bestaudio/best[height<={preferredHeight}]\"",
+                    "--merge-output-format mp4",
+                    "--no-playlist",
+                    "--no-warnings",
+                    $"-o \"{outputPath}\"",
+                    $"\"https://www.youtube.com/watch?v={key}\"");
+
+                _logger.LogInformation(
+                    "|CinemaTrailers4Jellyfins| Downloading {Key} via yt-dlp at max {Height}p to {Path}",
+                    key, preferredHeight, outputPath);
+
+                using var process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = ytDlpPath,
+                        Arguments = args,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true,
+                        UseShellExecute = false,
+                        CreateNoWindow = true,
+                    }
+                };
+
+                process.Start();
+                await process.WaitForExitAsync(ct).ConfigureAwait(false);
+
+                if (process.ExitCode != 0)
+                {
+                    var stderr = await process.StandardError.ReadToEndAsync(ct).ConfigureAwait(false);
+                    _logger.LogError("|CinemaTrailers4Jellyfins| yt-dlp exited with code {Code} for {Key}: {Error}",
+                        process.ExitCode, key, stderr);
+                    return false;
+                }
+
+                return File.Exists(outputPath);
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "|CinemaTrailers4Jellyfins| yt-dlp download failed for {Key}", key);
+                return false;
+            }
+        }
+    }
+}