feat: TMDB Discover source + retry yt-dlp once before fallback (v1.0.0.17)

The fixed TV lists are mostly long-running shows whose first_air_date is
outside ReleaseDateRangeMonths, and paging stops at the first page with no
in-range title, so only ~7 TV candidates were found (5 then dropped by
language). Add a "discover" source per media type that asks /discover for
recent titles in AllowedLanguages, sorted by popularity (1600+ TV results
for en|fr today). TV Discover defaults on, movie Discover off.

yt-dlp failures were mostly passing HTTP 403s from back-to-back requests;
the built-in fallback is sometimes only offered 360p. Retry yt-dlp once
after 15s before falling back.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/PluginConfiguration.cs

@@ -14,6 +14,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Configuration
         public bool SourceUpcoming { get; set; } = true;
         public bool SourcePopular { get; set; } = false;
         public bool SourceTopRated { get; set; } = false;
+        // TMDB Discover: newest titles in the allowed languages, most popular first.
+        public bool SourceDiscover { get; set; } = false;
 
         // ── Sources (TV Shows) ───────────────────────────────────────────────
 
@@ -21,6 +23,9 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Configuration
         public bool SourceTvOnTheAir { get; set; } = true;
         public bool SourceTvPopular { get; set; } = false;
         public bool SourceTvTopRated { get; set; } = false;
+        // TMDB Discover: newest shows in the allowed languages, most popular first. On by default:
+        // the TV lists above are mostly long-running shows the date range filters out.
+        public bool SourceTvDiscover { get; set; } = true;
 
         // ── Date Range ────────────────────────────────────────────────────────
 

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Configuration/config.html

@@ -45,7 +45,9 @@
                     <fieldset class="verticalSection verticalSection-extrabottompadding">
                         <legend><h3 class="sectionTitle">Trailer Languages</h3></legend>
                         <p class="fieldDescription">
-                            Only download trailers in the selected languages.
+                            Only download trailers in the selected languages. Both the trailer and the
+                            movie/show itself (its original language) must be in one of them, so a
+                            subtitled foreign trailer is skipped.
                             Leave everything unchecked to allow all languages.
                         </p>
                         <div style="display:grid;grid-template-columns:1fr 1fr;gap:0 2em;">
@@ -118,6 +120,16 @@
                                 Highest rated movies on TMDB, filtered by the date range below.
                             </div>
                         </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-discover" />
+                                <span>Discover</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Newest movies in your selected languages, most popular first.
+                            </div>
+                        </div>
                     </fieldset>
 
                     <!-- TV Show Sources -->
@@ -167,6 +179,16 @@
                                 Highest rated TV shows on TMDB, filtered by the date range below.
                             </div>
                         </div>
+
+                        <div class="checkboxContainer checkboxContainer-withDescription">
+                            <label>
+                                <input is="emby-checkbox" type="checkbox" id="source-tv-discover" />
+                                <span>Discover (recommended)</span>
+                            </label>
+                            <div class="fieldDescription checkboxFieldDescription">
+                                Newest TV shows in your selected languages, most popular first. The lists above are mostly long-running shows that the date range drops.
+                            </div>
+                        </div>
                     </fieldset>
 
                     <!-- Date Range -->
@@ -430,10 +452,12 @@
                     document.getElementById('source-upcoming').checked      = config.SourceUpcoming !== false;
                     document.getElementById('source-popular').checked       = !!config.SourcePopular;
                     document.getElementById('source-top-rated').checked     = !!config.SourceTopRated;
+                    document.getElementById('source-discover').checked      = !!config.SourceDiscover;
                     document.getElementById('source-tv-airing-today').checked = config.SourceTvAiringToday !== false;
                     document.getElementById('source-tv-on-the-air').checked   = config.SourceTvOnTheAir !== false;
                     document.getElementById('source-tv-popular').checked      = !!config.SourceTvPopular;
                     document.getElementById('source-tv-top-rated').checked    = !!config.SourceTvTopRated;
+                    document.getElementById('source-tv-discover').checked     = config.SourceTvDiscover !== false;
                     document.getElementById('date-range').value             = String(config.ReleaseDateRangeMonths ?? 6);
                     document.getElementById('download-folder').value        = config.DownloadFolder || '';
                     document.getElementById('max-trailers').value           = config.MaxTrailersToDownload ?? 20;
@@ -466,10 +490,12 @@
                     config.SourceUpcoming         = document.getElementById('source-upcoming').checked;
                     config.SourcePopular          = document.getElementById('source-popular').checked;
                     config.SourceTopRated         = document.getElementById('source-top-rated').checked;
+                    config.SourceDiscover         = document.getElementById('source-discover').checked;
                     config.SourceTvAiringToday    = document.getElementById('source-tv-airing-today').checked;
                     config.SourceTvOnTheAir       = document.getElementById('source-tv-on-the-air').checked;
                     config.SourceTvPopular        = document.getElementById('source-tv-popular').checked;
                     config.SourceTvTopRated       = document.getElementById('source-tv-top-rated').checked;
+                    config.SourceTvDiscover       = document.getElementById('source-tv-discover').checked;
                     config.ReleaseDateRangeMonths = parseInt(document.getElementById('date-range').value, 10);
                     config.DownloadFolder         = document.getElementById('download-folder').value;
                     config.MaxTrailersToDownload  = parseIntOrDefault(document.getElementById('max-trailers').value, 20);

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Jellyfin.Plugin.CinemaTrailers4Jellyfins.csproj

@@ -3,8 +3,8 @@
   <PropertyGroup>
     <TargetFramework>net9.0</TargetFramework>
     <RootNamespace>Jellyfin.Plugin.CinemaTrailers4Jellyfins</RootNamespace>
-    <AssemblyVersion>1.0.0.5</AssemblyVersion>
+    <AssemblyVersion>1.0.0.17</AssemblyVersion>
-    <FileVersion>1.0.0.5</FileVersion>
+    <FileVersion>1.0.0.17</FileVersion>
     <Nullable>enable</Nullable>
     <GenerateDocumentationFile>false</GenerateDocumentationFile>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
@@ -13,7 +13,7 @@
   <ItemGroup>
     <PackageReference Include="Jellyfin.Controller" Version="10.11.0" />
     <PackageReference Include="Jellyfin.Model" Version="10.11.0" />
-    <PackageReference Include="YoutubeExplode" Version="6.*" />
+    <PackageReference Include="YoutubeExplode" Version="6.6.2" />
   </ItemGroup>
 
   <ItemGroup>

Jellyfin.Plugin.CinemaTrailers4Jellyfins/ScheduledTasks/DownloadTrailersTask.cs

@@ -171,12 +171,20 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
 
                 var paths = BuildMediaPaths(movie.Title, movie.Year, config);
 
-                if (config.SkipAlreadyDownloaded && Directory.Exists(paths.MediaFolder))
+                if (config.SkipAlreadyDownloaded && File.Exists(paths.TrailerPath))
                 {
                     _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MediaFolder);
                     continue;
                 }
 
+                // A trailer's own language tag is often "en" just because it has English
+                // subtitles, so also require the title itself to be in an allowed language.
+                if (allowedLanguages != null && !allowedLanguages.Contains(movie.OriginalLanguage))
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Skipping '{Title}': original language '{Lang}' is not allowed", movie.Title, movie.OriginalLanguage);
+                    continue;
+                }
+
                 var trailers = await _tmdbService.GetTrailersAsync(
                     "movie", movie.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);
 
@@ -197,7 +205,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                     cancellationToken).ConfigureAwait(false);
 
                 if (!success)
+                {
+                    // Don't leave an empty folder behind: it would count toward MaxTotalTrailers
+                    // (pushing out real trailers) and would never be retried.
+                    TryDeleteFolder(paths.MediaFolder);
                     continue;
+                }
 
                 var fakeMovieReady = await _fakeMovieService.CopyFakeMovieAsync(paths.FakeMoviePath, cancellationToken).ConfigureAwait(false);
                 if (!fakeMovieReady)
@@ -212,7 +225,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                 var metadata = await _tmdbService.GetMediaMetadataAsync(
                     "movie", movie.Id.ToString(), config.TmdbApiKey, cancellationToken).ConfigureAwait(false);
 
-                _fakeMovieService.WriteNfo(paths.NfoPath, movie.Title, movie.Year, metadata.Genres, metadata.Certification);
+                _fakeMovieService.WriteNfo(paths.NfoPath, movie.Title, movie.Year, metadata.Genres, metadata.Certification,
+                    metadata.IsAnime ? new[] { TrailerTags.Anime } : null);
 
                 downloaded++;
                 _logger.LogInformation(
@@ -272,12 +286,20 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
 
                 var paths = BuildMediaPaths(show.Title, show.Year, config);
 
-                if (config.SkipAlreadyDownloaded && Directory.Exists(paths.MediaFolder))
+                if (config.SkipAlreadyDownloaded && File.Exists(paths.TrailerPath))
                 {
                     _logger.LogDebug("|CinemaTrailers4Jellyfins| Already downloaded: {Path}", paths.MediaFolder);
                     continue;
                 }
 
+                // A trailer's own language tag is often "en" just because it has English
+                // subtitles, so also require the title itself to be in an allowed language.
+                if (allowedLanguages != null && !allowedLanguages.Contains(show.OriginalLanguage))
+                {
+                    _logger.LogDebug("|CinemaTrailers4Jellyfins| Skipping '{Title}': original language '{Lang}' is not allowed", show.Title, show.OriginalLanguage);
+                    continue;
+                }
+
                 var trailers = await _tmdbService.GetTrailersAsync(
                     "tv", show.Id.ToString(), config.TmdbApiKey, allowedLanguages, cancellationToken).ConfigureAwait(false);
 
@@ -298,7 +320,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                     cancellationToken).ConfigureAwait(false);
 
                 if (!success)
+                {
+                    // Don't leave an empty folder behind: it would count toward MaxTotalTrailers
+                    // (pushing out real trailers) and would never be retried.
+                    TryDeleteFolder(paths.MediaFolder);
                     continue;
+                }
 
                 var fakeMovieReady = await _fakeMovieService.CopyFakeMovieAsync(paths.FakeMoviePath, cancellationToken).ConfigureAwait(false);
                 if (!fakeMovieReady)
@@ -313,7 +340,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                 var metadata = await _tmdbService.GetMediaMetadataAsync(
                     "tv", show.Id.ToString(), config.TmdbApiKey, cancellationToken).ConfigureAwait(false);
 
-                _fakeMovieService.WriteNfo(paths.NfoPath, show.Title, show.Year, metadata.Genres, metadata.Certification, new[] { TrailerTags.TvShow });
+                _fakeMovieService.WriteNfo(paths.NfoPath, show.Title, show.Year, metadata.Genres, metadata.Certification,
+                    metadata.IsAnime ? new[] { TrailerTags.TvShow, TrailerTags.Anime } : new[] { TrailerTags.TvShow });
 
                 downloaded++;
                 _logger.LogInformation(

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/FakeMovieService.cs

@@ -109,16 +109,11 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                     "-f mp4",
                     $"\"{tempPath}\"");
 
-                // Prefer Jellyfin's bundled ffmpeg; fall back to whatever is on PATH.
-                var ffmpegPath = File.Exists("/usr/lib/jellyfin-ffmpeg/ffmpeg")
-                    ? "/usr/lib/jellyfin-ffmpeg/ffmpeg"
-                    : "ffmpeg";
-
                 using var process = new Process
                 {
                     StartInfo = new ProcessStartInfo
                     {
-                        FileName = ffmpegPath,
+                        FileName = FfmpegLocator.Path,
                         Arguments = args,
                         RedirectStandardOutput = true,
                         RedirectStandardError = true,

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/FfmpegLocator.cs

@@ -0,0 +1,12 @@
+using System.IO;
+
+namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
+{
+    internal static class FfmpegLocator
+    {
+        private const string JellyfinFfmpeg = "/usr/lib/jellyfin-ffmpeg/ffmpeg";
+
+        // Prefer Jellyfin's bundled ffmpeg; fall back to whatever is on PATH.
+        public static string Path => File.Exists(JellyfinFfmpeg) ? JellyfinFfmpeg : "ffmpeg";
+    }
+}

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TmdbService.cs

@@ -14,12 +14,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 {
     public record TmdbVideo(string Key, string Name, string Language, bool Official, int Size);
 
-    public record TmdbMediaResult(int Id, string Title, string ReleaseDate)
+    public record TmdbMediaResult(int Id, string Title, string ReleaseDate, string OriginalLanguage)
     {
         public int? Year => DateTime.TryParse(ReleaseDate, out var d) ? d.Year : (int?)null;
     }
 
-    public record TmdbMediaMetadata(IReadOnlyList<string> Genres, string? Certification);
+    public record TmdbMediaMetadata(IReadOnlyList<string> Genres, string? Certification, bool IsAnime);
 
     public class TmdbService : IDisposable
     {
@@ -84,6 +84,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             if (config.SourceUpcoming)   sources.Add("upcoming");
             if (config.SourcePopular)    sources.Add("popular");
             if (config.SourceTopRated)   sources.Add("top_rated");
+            if (config.SourceDiscover)   sources.Add(DiscoverSource);
 
             return GetCandidatesAsync("movie", sources, config, ct);
         }
@@ -101,6 +102,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             if (config.SourceTvOnTheAir)    sources.Add("on_the_air");
             if (config.SourceTvPopular)     sources.Add("popular");
             if (config.SourceTvTopRated)    sources.Add("top_rated");
+            if (config.SourceTvDiscover)    sources.Add(DiscoverSource);
 
             return GetCandidatesAsync("tv", sources, config, ct);
         }
@@ -120,7 +122,10 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 
             foreach (var endpoint in sourceEndpoints)
             {
-                var items = await FetchSourcePagesAsync(mediaType, endpoint, config.TmdbApiKey, releasedAfter, config.MaxPagesPerSource, ct)
+                var path = endpoint == DiscoverSource
+                    ? DiscoverPath(mediaType, releasedAfter, config.AllowedLanguages)
+                    : $"{mediaType}/{endpoint}";
+                var items = await FetchSourcePagesAsync(mediaType, path, config.TmdbApiKey, releasedAfter, config.MaxPagesPerSource, ct)
                     .ConfigureAwait(false);
 
                 foreach (var item in items)
@@ -133,9 +138,31 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             return results;
         }
 
+        private const string DiscoverSource = "discover";
+
+        // /discover asks TMDB directly for recent titles in the allowed languages, sorted by
+        // popularity, unlike the fixed lists, which are mostly older titles the date range drops.
+        private static string DiscoverPath(string mediaType, DateTime? releasedAfter, string allowedLanguages)
+        {
+            var query = new List<string> { "sort_by=popularity.desc" };
+            if (releasedAfter.HasValue)
+            {
+                var dateParam = mediaType == "movie" ? "primary_release_date.gte" : "first_air_date.gte";
+                query.Add($"{dateParam}={releasedAfter.Value:yyyy-MM-dd}");
+            }
+
+            var languages = (allowedLanguages ?? string.Empty)
+                .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+            if (languages.Length > 0)
+                query.Add("with_original_language=" + Uri.EscapeDataString(string.Join("|", languages)));
+
+            return $"discover/{mediaType}?" + string.Join("&", query);
+        }
+
+        // path is relative to the API root, e.g. "tv/popular" or "discover/tv?sort_by=...".
         private async Task<List<TmdbMediaResult>> FetchSourcePagesAsync(
             string mediaType,
-            string endpoint,
+            string path,
             string apiKey,
             DateTime? releasedAfter,
             int maxPages,
@@ -153,7 +180,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 
                 try
                 {
-                    var url = $"{BaseUrl}/{mediaType}/{endpoint}?language=en-US&page={page}";
+                    var url = $"{BaseUrl}/{path}{(path.Contains('?') ? '&' : '?')}language=en-US&page={page}";
                     using var request = new HttpRequestMessage(HttpMethod.Get, url);
                     ApplyAuth(request, apiKey);
                     using var response = await _httpClient.SendAsync(request, ct).ConfigureAwait(false);
@@ -170,6 +197,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                         var releaseDate = entry.TryGetProperty(dateField, out var rd) ? rd.GetString() ?? string.Empty : string.Empty;
                         var title = entry.TryGetProperty(titleField, out var t) ? t.GetString() ?? string.Empty : string.Empty;
                         var id = entry.GetProperty("id").GetInt32();
+                        var originalLanguage = entry.TryGetProperty("original_language", out var ol) ? ol.GetString() ?? string.Empty : string.Empty;
 
                         if (releasedAfter.HasValue && DateTime.TryParse(releaseDate, out var parsed))
                         {
@@ -177,7 +205,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                         }
 
                         anyInRange = true;
-                        results.Add(new TmdbMediaResult(id, title, releaseDate));
+                        results.Add(new TmdbMediaResult(id, title, releaseDate, originalLanguage));
                     }
 
                     if (page >= totalPages || (releasedAfter.HasValue && !anyInRange))
@@ -189,7 +217,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 }
                 catch (Exception ex)
                 {
-                    _logger.LogError(ex, "|CinemaTrailers4Jellyfins| Failed to fetch TMDB source '{MediaType}/{Endpoint}' page {Page}", mediaType, endpoint, page);
+                    _logger.LogError(ex, "|CinemaTrailers4Jellyfins| Failed to fetch TMDB source '{Path}' page {Page}", path, page);
                     break;
                 }
             }
@@ -236,7 +264,7 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             try
             {
                 var appendField = mediaType == "movie" ? "release_dates" : "content_ratings";
-                var url = $"{BaseUrl}/{mediaType}/{tmdbId}?append_to_response={appendField}&language=en-US";
+                var url = $"{BaseUrl}/{mediaType}/{tmdbId}?append_to_response={appendField},keywords&language=en-US";
                 using var request = new HttpRequestMessage(HttpMethod.Get, url);
                 ApplyAuth(request, apiKey);
                 using var response = await _httpClient.SendAsync(request, ct).ConfigureAwait(false);
@@ -262,16 +290,40 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                     ? GetMovieCertification(doc)
                     : GetTvCertification(doc);
 
-                return new TmdbMediaMetadata(genres.AsReadOnly(), certification);
+                return new TmdbMediaMetadata(genres.AsReadOnly(), certification, IsAnime(doc, mediaType, genres));
             }
             catch (OperationCanceledException) { throw; }
             catch (Exception ex)
             {
                 _logger.LogError(ex, "|CinemaTrailers4Jellyfins| GetMediaMetadata failed for {MediaType} TMDB ID {Id}", mediaType, tmdbId);
-                return new TmdbMediaMetadata(Array.Empty<string>(), null);
+                return new TmdbMediaMetadata(Array.Empty<string>(), null, false);
             }
         }
 
+        private static readonly string[] AnimeKeywords = { "anime", "based on manga" };
+        private static readonly string[] AnimeLanguages = { "ja", "zh", "ko" };
+
+        // Anime vs. Western animation: both carry TMDB's "Animation" genre, so use the "anime" /
+        // "based on manga" keywords, or Animation made in Japanese, Chinese or Korean.
+        private static bool IsAnime(JsonDocument doc, string mediaType, List<string> genres)
+        {
+            // Movie keywords live under keywords.keywords, TV keywords under keywords.results.
+            var listName = mediaType == "movie" ? "keywords" : "results";
+            if (doc.RootElement.TryGetProperty("keywords", out var kw)
+                && kw.TryGetProperty(listName, out var list)
+                && list.ValueKind == JsonValueKind.Array
+                && list.EnumerateArray().Any(k =>
+                    k.TryGetProperty("name", out var n)
+                    && AnimeKeywords.Contains(n.GetString(), StringComparer.OrdinalIgnoreCase)))
+            {
+                return true;
+            }
+
+            return genres.Contains("Animation", StringComparer.OrdinalIgnoreCase)
+                && doc.RootElement.TryGetProperty("original_language", out var lang)
+                && AnimeLanguages.Contains(lang.GetString(), StringComparer.OrdinalIgnoreCase);
+        }
+
         // Finds the US theatrical certification (G, PG, PG-13, R, NC-17) from release_dates.
         private static string? GetMovieCertification(JsonDocument doc)
         {

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerDownloadService.cs

@@ -45,6 +45,8 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             _httpClient = new HttpClient(handler) { Timeout = TimeSpan.FromMinutes(10) };
         }
 
+        private static readonly TimeSpan YtDlpRetryDelay = TimeSpan.FromSeconds(15);
+
         public void Dispose() => _httpClient.Dispose();
 
         /// <summary>
@@ -63,8 +65,18 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 
             if (!string.IsNullOrWhiteSpace(ytDlpPath) && File.Exists(ytDlpPath))
             {
-                return await DownloadWithYtDlpAsync(youtubeKey, outputPath, preferredHeight, ytDlpPath, ct)
+                if (await DownloadWithYtDlpAsync(youtubeKey, outputPath, preferredHeight, ytDlpPath, ct).ConfigureAwait(false))
-                    .ConfigureAwait(false);
+                    return true;
+
+                // YouTube answers back-to-back downloads with occasional HTTP 403s that clear on
+                // their own. One more try after a pause usually gets full quality, where the
+                // built-in fallback may only be offered a 360p stream.
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| yt-dlp failed for {Key}; retrying in {Seconds}s.", youtubeKey, YtDlpRetryDelay.TotalSeconds);
+                await Task.Delay(YtDlpRetryDelay, ct).ConfigureAwait(false);
+                if (await DownloadWithYtDlpAsync(youtubeKey, outputPath, preferredHeight, ytDlpPath, ct).ConfigureAwait(false))
+                    return true;
+
+                _logger.LogWarning("|CinemaTrailers4Jellyfins| yt-dlp failed for {Key}; falling back to the built-in downloader.", youtubeKey);
             }
 
             return await DownloadWithYoutubeExplodeAsync(youtubeKey, outputPath, preferredHeight, ct)
@@ -77,6 +89,10 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             int preferredHeight,
             CancellationToken ct)
         {
+            // Separate video/audio downloads land next to the output and are always removed,
+            // whether the merge succeeds or not.
+            var videoTemp = outputPath + ".video.tmp";
+            var audioTemp = outputPath + ".audio.tmp";
             try
             {
                 var youtube = new YoutubeClient(_httpClient);
@@ -84,30 +100,48 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                     .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.
+                // Best video-only stream at or below the height limit. MP4 (H.264) is preferred for
+                // client compatibility; any container is the fallback.
+                var videoStreams = manifest.GetVideoOnlyStreams().ToList();
+                var audioStreams = manifest.GetAudioOnlyStreams().ToList();
+                var mp4Video = videoStreams.Where(s => s.Container == Container.Mp4).ToList();
+                var video = videoStreams.Count > 0
+                    ? PickByHeight(mp4Video.Count > 0 ? mp4Video : videoStreams, preferredHeight)
+                    : null;
+
+                // Muxed streams (audio+video in one file) need no merge, but YouTube only serves
+                // them at 360p. Use one only when the separate streams can't do better.
                 var muxedStreams = manifest.GetMuxedStreams().ToList();
-                if (muxedStreams.Count == 0)
+                if (muxedStreams.Count > 0)
                 {
-                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No muxed streams available for {Key}. Consider configuring yt-dlp for 1080p support.", key);
+                    var muxed = PickByHeight(muxedStreams, preferredHeight);
-                    return false;
+                    if (video == null || audioStreams.Count == 0
+                        || muxed.VideoQuality.MaxHeight >= video.VideoQuality.MaxHeight)
+                    {
+                        _logger.LogInformation(
+                            "|CinemaTrailers4Jellyfins| Downloading {Key} at {Quality} (muxed) to {Path}",
+                            key, muxed.VideoQuality.Label, outputPath);
+                        await youtube.Videos.Streams.DownloadAsync(muxed, outputPath, cancellationToken: ct).ConfigureAwait(false);
+                        return true;
+                    }
                 }
 
-                // Prefer the highest quality at or below the configured height limit.
+                if (video == null || audioStreams.Count == 0)
-                var stream = muxedStreams
+                {
-                    .Where(s => s.VideoQuality.MaxHeight <= preferredHeight)
+                    _logger.LogWarning("|CinemaTrailers4Jellyfins| No usable video/audio streams for {Key}.", key);
-                    .OrderByDescending(s => s.VideoQuality.MaxHeight)
+                    return false;
-                    .FirstOrDefault()
+                }
-                    ?? muxedStreams.OrderByDescending(s => s.VideoQuality.MaxHeight).First();
+                var mp4Audio = audioStreams.Where(s => s.Container == Container.Mp4).ToList();
+                var audio = (mp4Audio.Count > 0 ? mp4Audio : audioStreams).GetWithHighestBitrate();
 
                 _logger.LogInformation(
-                    "|CinemaTrailers4Jellyfins| Downloading {Key} at {Quality} to {Path}",
+                    "|CinemaTrailers4Jellyfins| Downloading {Key} at {Quality} (video + audio, merged with ffmpeg) to {Path}",
-                    key, stream.VideoQuality.Label, outputPath);
+                    key, video.VideoQuality.Label, outputPath);
 
-                await youtube.Videos.Streams
+                await youtube.Videos.Streams.DownloadAsync(video, videoTemp, cancellationToken: ct).ConfigureAwait(false);
-                    .DownloadAsync(stream, outputPath, cancellationToken: ct)
+                await youtube.Videos.Streams.DownloadAsync(audio, audioTemp, cancellationToken: ct).ConfigureAwait(false);
-                    .ConfigureAwait(false);
 
-                return true;
+                return await MergeAsync(key, videoTemp, audioTemp, outputPath, ct).ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
@@ -118,6 +152,85 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 _logger.LogError(ex, "|CinemaTrailers4Jellyfins| YoutubeExplode download failed for {Key}", key);
                 return false;
             }
+            finally
+            {
+                TryDeleteFile(videoTemp);
+                TryDeleteFile(audioTemp);
+            }
+        }
+
+        // Highest quality at or below the configured height limit, else the lowest available.
+        private static T PickByHeight<T>(System.Collections.Generic.IReadOnlyList<T> streams, int preferredHeight)
+            where T : IVideoStreamInfo
+            => streams
+                .Where(s => s.VideoQuality.MaxHeight <= preferredHeight)
+                .OrderByDescending(s => s.VideoQuality.MaxHeight)
+                .FirstOrDefault()
+               ?? streams.OrderBy(s => s.VideoQuality.MaxHeight).First();
+
+        // Stream-copies (no re-encode) the video and audio tracks into one MP4.
+        // Writes to a temp file first so a failed merge never leaves a broken trailer.
+        private async Task<bool> MergeAsync(string key, string videoPath, string audioPath, string outputPath, CancellationToken ct)
+        {
+            var mergeTemp = outputPath + ".merge.tmp";
+            try
+            {
+                var args = string.Join(" ",
+                    "-y -loglevel error",
+                    $"-i \"{videoPath}\"",
+                    $"-i \"{audioPath}\"",
+                    "-map 0:v:0 -map 1:a:0 -c copy -movflags +faststart",
+                    "-f mp4",
+                    $"\"{mergeTemp}\"");
+
+                using var process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = FfmpegLocator.Path,
+                        Arguments = args,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true,
+                        UseShellExecute = false,
+                        CreateNoWindow = true,
+                    }
+                };
+
+                process.Start();
+                // Drain both pipes while ffmpeg runs so a full buffer can never block it.
+                var stdoutTask = process.StandardOutput.ReadToEndAsync(ct);
+                var stderrTask = process.StandardError.ReadToEndAsync(ct);
+                await process.WaitForExitAsync(ct).ConfigureAwait(false);
+                await stdoutTask.ConfigureAwait(false);
+                var stderr = await stderrTask.ConfigureAwait(false);
+
+                if (process.ExitCode != 0 || !File.Exists(mergeTemp))
+                {
+                    _logger.LogError("|CinemaTrailers4Jellyfins| ffmpeg merge failed for {Key} (exit code {Code}): {Error}",
+                        key, process.ExitCode, stderr);
+                    return false;
+                }
+
+                File.Move(mergeTemp, outputPath, overwrite: true);
+                return true;
+            }
+            finally
+            {
+                TryDeleteFile(mergeTemp);
+            }
+        }
+
+        private void TryDeleteFile(string path)
+        {
+            try
+            {
+                if (File.Exists(path))
+                    File.Delete(path);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "|CinemaTrailers4Jellyfins| Could not delete temporary file {Path}", path);
+            }
         }
 
         private async Task<bool> DownloadWithYtDlpAsync(
@@ -129,13 +242,16 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
         {
             try
             {
-                // Format selects the best video at or below preferredHeight merged with the best audio.
+                // 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.
+                // preferring H.264 + AAC (plays or hardware-transcodes on every client; VP9/AV1 often
+                // need a CPU transcode). --merge-output-format mp4 ensures the output is always an mp4.
                 var args = string.Join(" ",
-                    $"-f \"bestvideo[height<={preferredHeight}]+bestaudio/best[height<={preferredHeight}]\"",
+                    $"-f \"bestvideo[height<={preferredHeight}][vcodec^=avc1]+bestaudio[ext=m4a]/bestvideo[height<={preferredHeight}]+bestaudio/best[height<={preferredHeight}]\"",
                     "--merge-output-format mp4",
                     "--no-playlist",
                     "--no-warnings",
+                    "--no-progress",
+                    $"--ffmpeg-location \"{FfmpegLocator.Path}\"",
                     $"-o \"{outputPath}\"",
                     $"\"https://www.youtube.com/watch?v={key}\"");
 
@@ -157,11 +273,15 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 };
 
                 process.Start();
+                // Drain both pipes while yt-dlp runs so a full buffer can never block it.
+                var stdoutTask = process.StandardOutput.ReadToEndAsync(ct);
+                var stderrTask = process.StandardError.ReadToEndAsync(ct);
                 await process.WaitForExitAsync(ct).ConfigureAwait(false);
+                await stdoutTask.ConfigureAwait(false);
+                var stderr = await stderrTask.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;
@@ -178,6 +298,32 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 _logger.LogError(ex, "|CinemaTrailers4Jellyfins| yt-dlp download failed for {Key}", key);
                 return false;
             }
+            finally
+            {
+                DeleteYtDlpLeftovers(outputPath);
+            }
+        }
+
+        // yt-dlp names its separate/partial downloads "<output name>.f137.mp4.part", ".f140.m4a",
+        // ".ytdl", ... It removes them after a successful merge, but not when it fails. Everything
+        // sharing the output's "<name>." prefix (other than the output itself) is one of those.
+        private void DeleteYtDlpLeftovers(string outputPath)
+        {
+            var folder = Path.GetDirectoryName(outputPath);
+            if (folder == null || !Directory.Exists(folder))
+                return;
+
+            var outputName = Path.GetFileName(outputPath);
+            var prefix = Path.GetFileNameWithoutExtension(outputPath) + ".";
+            foreach (var file in Directory.EnumerateFiles(folder))
+            {
+                var name = Path.GetFileName(file);
+                if (name.StartsWith(prefix, StringComparison.Ordinal)
+                    && !string.Equals(name, outputName, StringComparison.Ordinal))
+                {
+                    TryDeleteFile(file);
+                }
+            }
         }
     }
 }

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerIntroProvider.cs

@@ -48,6 +48,16 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             var preRollEnabled = !string.IsNullOrEmpty(config.TrailerPreRollLibraryId);
             var featurePreRollEnabled = !string.IsNullOrEmpty(config.FeaturePreRollLibraryId);
 
+            _logger.LogInformation(
+                "|CinemaTrailers4Jellyfins| GetIntros called for {Type} '{Name}' (Path={Path}). "
+                + "trailersEnabled={Trailers} preRollEnabled={PreRoll} featurePreRollEnabled={FeaturePreRoll}",
+                item.GetType().Name,
+                item.Name,
+                item.Path,
+                trailersEnabled,
+                preRollEnabled,
+                featurePreRollEnabled);
+
             if (!trailersEnabled && !preRollEnabled && !featurePreRollEnabled)
                 return Task.FromResult(Enumerable.Empty<IntroInfo>());
 
@@ -65,16 +75,23 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 
                 case Episode episode:
                     if (!config.TrailersForEpisodes)
+                    {
+                        _logger.LogInformation("|CinemaTrailers4Jellyfins| Skipping: TrailersForEpisodes is disabled.");
                         return Task.FromResult(Enumerable.Empty<IntroInfo>());
+                    }
 
                     if (!IsFirstEpisodeOfDay(user.Id))
+                    {
+                        _logger.LogInformation("|CinemaTrailers4Jellyfins| Skipping: not the first episode of the day for this user.");
                         return Task.FromResult(Enumerable.Empty<IntroInfo>());
+                    }
 
                     feature = episode.Series ?? (BaseItem)episode;
                     isEpisode = true;
                     break;
 
                 default:
+                    _logger.LogInformation("|CinemaTrailers4Jellyfins| Skipping: item type {Type} is not a Movie or Episode.", item.GetType().Name);
                     return Task.FromResult(Enumerable.Empty<IntroInfo>());
             }
 
@@ -85,13 +102,16 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             // (covers both the fake-movie files and their trailer extras).
             if (!string.IsNullOrEmpty(outputFolder)
                 && item.Path?.StartsWith(outputFolder, StringComparison.OrdinalIgnoreCase) == true)
+            {
+                _logger.LogInformation("|CinemaTrailers4Jellyfins| Skipping: item path is inside the output folder ({Folder}).", outputFolder);
                 return Task.FromResult(Enumerable.Empty<IntroInfo>());
+            }
 
             var intros = new List<IntroInfo>();
 
             if (preRollEnabled)
             {
-                var preRoll = GetRandomLibraryMovieIntro(config.TrailerPreRollLibraryId, item.Id);
+                var preRoll = GetRandomLibraryMovieIntro("Trailer Pre-Roll", config.TrailerPreRollLibraryId, item.Id, user);
                 if (preRoll != null)
                     intros.Add(preRoll);
             }
@@ -109,6 +129,9 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                     .Where(m =>
                         m.Path?.StartsWith(outputFolder, StringComparison.OrdinalIgnoreCase) == true
                         && m.LocalTrailers.Count > 0
+                        // Skip items the user can't actually play (e.g. library not in their access list) —
+                        // some clients hang indefinitely trying to play an inaccessible item.
+                        && m.IsVisibleStandalone(user)
                         // Keep TV show trailers for episodes and movie trailers for movies separate.
                         && m.Tags.Contains(TrailerTags.TvShow, StringComparer.OrdinalIgnoreCase) == isEpisode)
                     .SelectMany(m => m.LocalTrailers.Select(t => (Movie: m, Trailer: t)))
@@ -124,9 +147,16 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 }
                 else
                 {
-                    // Apply enabled filters. If nothing survives, fall back to the full pool.
+                    // Anime trailers only play before anime. Applied before the fallback below, so
-                    var filtered = ApplyFilters(pairs, feature, config);
+                    // non-anime content never gets one — it gets no trailer instead. Western animation
-                    var pool = filtered.Count > 0 ? filtered : pairs;
+                    // is not affected and follows the normal filters.
+                    var eligible = IsAnimeFeature(feature)
+                        ? pairs
+                        : pairs.Where(p => !IsAnimeTrailer(p.Movie)).ToList();
+
+                    // Apply enabled filters. If nothing survives, fall back to the eligible pool.
+                    var filtered = ApplyFilters(eligible, feature, config);
+                    var pool = filtered.Count > 0 ? filtered : eligible;
 
                     // Prefer unseen trailers within the pool; reset the cycle when all have been shown.
                     pool = ApplyAvoidRepeats(pool, user.Id, config.AvoidRepeats);
@@ -145,11 +175,16 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 
             if (featurePreRollEnabled)
             {
-                var featureRoll = GetRandomLibraryMovieIntro(config.FeaturePreRollLibraryId, item.Id);
+                var featureRoll = GetRandomLibraryMovieIntro("Feature Pre-Roll", config.FeaturePreRollLibraryId, item.Id, user);
                 if (featureRoll != null)
                     intros.Add(featureRoll);
             }
 
+            _logger.LogInformation(
+                "|CinemaTrailers4Jellyfins| Returning {Count} intro(s): {Paths}",
+                intros.Count,
+                string.Join(", ", intros.Select(i => i.Path)));
+
             return Task.FromResult<IEnumerable<IntroInfo>>(intros);
         }
 
@@ -157,29 +192,64 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
         /// Picks a random Movie from the given Jellyfin library (VirtualFolder ItemId) to use as a
         /// pre-roll/post-roll bumper, excluding the item currently being played.
         /// </summary>
-        private IntroInfo? GetRandomLibraryMovieIntro(string libraryId, Guid excludeId)
+        private IntroInfo? GetRandomLibraryMovieIntro(string label, string libraryId, Guid excludeId, User user)
         {
             if (!Guid.TryParse(libraryId, out var parsedId))
-                return null;
-
-            var movies = _libraryManager
-                .GetItemList(new InternalItemsQuery
             {
-                    IncludeItemTypes = new[] { BaseItemKind.Movie },
+                _logger.LogWarning(
-                    TopParentIds = new[] { parsedId },
+                    "|CinemaTrailers4Jellyfins| {Label} library ID '{LibraryId}' is not a valid GUID — check the plugin settings.",
-                    Recursive = true,
+                    label,
-                })
+                    libraryId);
+                return null;
+            }
+
+            if (_libraryManager.GetItemById(parsedId) is not Folder folder)
+            {
+                _logger.LogWarning(
+                    "|CinemaTrailers4Jellyfins| {Label} library {LibraryId} could not be found.",
+                    label,
+                    parsedId);
+                return null;
+            }
+
+            var movies = folder.GetRecursiveChildren()
                 .OfType<Movie>()
-                .Where(m => m.Id != excludeId)
+                .Where(m => m.Id != excludeId && m.IsVisibleStandalone(user))
                 .ToList();
 
             if (movies.Count == 0)
+            {
+                _logger.LogInformation(
+                    "|CinemaTrailers4Jellyfins| {Label} library {LibraryId} has no eligible Movie items visible to this user. "
+                    + "Ensure the library has been scanned, contains at least one other Movie, and is in this user's library access list.",
+                    label,
+                    parsedId);
                 return null;
+            }
 
             var movie = movies[_rng.Next(movies.Count)];
+            _logger.LogInformation(
+                "|CinemaTrailers4Jellyfins| {Label}: picked '{Title}' ({Path}).",
+                label,
+                movie.Name,
+                movie.Path);
             return new IntroInfo { ItemId = movie.Id, Path = movie.Path };
         }
 
+        // Library items: anime providers (e.g. AniDB) set the "Anime" genre; TMDB-scraped items
+        // carry TMDB keywords as tags ("anime", "based on manga"). "Animation" alone is not enough —
+        // it also covers Western animation.
+        private static readonly string[] AnimeFeatureTags = { "anime", "based on manga" };
+
+        private static bool IsAnimeFeature(BaseItem item)
+            => item.Genres.Contains("Anime", StringComparer.OrdinalIgnoreCase)
+               || item.Tags.Any(t => AnimeFeatureTags.Contains(t, StringComparer.OrdinalIgnoreCase));
+
+        // Trailers are tagged at download time from TMDB data (see TmdbService.IsAnime).
+        private static bool IsAnimeTrailer(BaseItem item)
+            => item.Tags.Contains(TrailerTags.Anime, StringComparer.OrdinalIgnoreCase)
+               || item.Genres.Contains("Anime", StringComparer.OrdinalIgnoreCase);
+
         private static List<(Movie Movie, BaseItem Trailer)> ApplyFilters(
             List<(Movie Movie, BaseItem Trailer)> pairs,
             BaseItem feature,

Jellyfin.Plugin.CinemaTrailers4Jellyfins/Services/TrailerTags.cs

@@ -2,11 +2,14 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 {
     /// <summary>
     /// Tags written into each downloaded trailer's NFO so <see cref="TrailerIntroProvider"/>
-    /// can tell movie trailers and TV show trailers apart within the shared output folder.
+    /// can tell movie trailers, TV show trailers and anime trailers apart within the shared output folder.
     /// </summary>
     public static class TrailerTags
     {
         /// <summary>Marks a fake-movie folder as containing a TV show trailer.</summary>
         public const string TvShow = "ct4j-tvshow";
+
+        /// <summary>Marks a trailer as anime, so it only plays before anime content.</summary>
+        public const string Anime = "ct4j-anime";
     }
 }

build.yaml

@@ -1,5 +1,5 @@
 ---
-version: 1.0.0.5
+version: 1.0.0.17
 name: CinemaTrailers4Jellyfins
 guid: b581493e-1046-40ed-b6dc-cb8027624984
 description: >
@@ -12,10 +12,14 @@ category: General
 owner: 514mart
 targetAbi: 10.11.0.0
 changelog:
-  - Add Trailer Pre-Roll and Feature Pre-Roll bumpers via IIntroProvider — pick
+  - New "Discover" source for TV shows (on by default) and movies (off by
-    existing Jellyfin Movie libraries in settings and a random movie from each is
+    default). It asks TMDB for the newest titles in your selected
-    played before the trailer block ("Now Playing") and/or right before the
+    languages, most popular first. The TV lists (Popular, Top Rated, On The
-    feature ("Feature Presentation"); both are independent and disabled by default
+    Air, Airing Today) are mostly long-running shows that the date range
+    drops, so very few TV trailers were found before
+  - When yt-dlp fails (often a passing HTTP 403 from YouTube), it is tried
+    once more after 15 seconds before the built-in downloader takes over,
+    which YouTube sometimes only offers 360p
 
 dotnetProjects:
   - name: Jellyfin.Plugin.CinemaTrailers4Jellyfins

manifest.json

@@ -8,6 +8,102 @@
         "owner": "514mart",
         "imageUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/raw/branch/main/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Images/logo.svg",
         "versions": [
+            {
+                "checksum": "5329a3a0daf9f82849b441ca2784f622",
+                "changelog": "- The built-in downloader no longer picks YouTube's 360p combined file when separate video and audio streams give a better picture. This mostly showed up when yt-dlp failed and the built-in downloader took over\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.16/cinematrailers4jellyfins_1.0.0.16.zip",
+                "timestamp": "2026-10-06T01:40:16Z",
+                "version": "1.0.0.16"
+            },
+            {
+                "checksum": "211f58d992857f9e91263293306fbd0d",
+                "changelog": "- Trailer Languages now also checks the original language of the movie or show. Before, only the trailer's own language tag was checked, and TMDB often tags subtitled foreign trailers as English, so Korean, Chinese or Japanese trailers got through\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.15/cinematrailers4jellyfins_1.0.0.15.zip",
+                "timestamp": "2026-10-05T22:28:03Z",
+                "version": "1.0.0.15"
+            },
+            {
+                "checksum": "10ecbc35b84e98bade61576bbfc41864",
+                "changelog": "- When yt-dlp fails part-way, its partial download files (.part, .ytdl, separate video/audio) are now deleted instead of being left in the trailer folder\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.14/cinematrailers4jellyfins_1.0.0.14.zip",
+                "timestamp": "2026-10-05T22:19:38Z",
+                "version": "1.0.0.14"
+            },
+            {
+                "checksum": "f1fe201e7b0238fa432ae7fb5dbb1844",
+                "changelog": "- yt-dlp now prefers H.264 + AAC (plays or hardware-transcodes on every client; VP9/AV1 often needed a CPU transcode) and uses Jellyfin's own ffmpeg for the merge\n- If yt-dlp fails, the built-in downloader is tried instead\n- Fix a possible hang. yt-dlp's output is now read while it runs, so a full output buffer can no longer block it\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.13/cinematrailers4jellyfins_1.0.0.13.zip",
+                "timestamp": "2026-10-05T22:11:03Z",
+                "version": "1.0.0.13"
+            },
+            {
+                "checksum": "d7a565b0e4d47effb9db40fb44847920",
+                "changelog": "- Anime trailers now only play before anime. Western animation (Pixar, Disney, ...) is no longer blocked and follows the normal genre filter again. A trailer counts as anime when TMDB tags it \"anime\" or \"based on manga\", or it is animation in Japanese, Chinese or Korean; it is marked with a ct4j-anime tag in its NFO at download time. Your anime is recognised by the \"Anime\" genre or the same TMDB keywords\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.12/cinematrailers4jellyfins_1.0.0.12.zip",
+                "timestamp": "2026-10-05T21:57:24Z",
+                "version": "1.0.0.12"
+            },
+            {
+                "checksum": "ccb45ef4bda23b245e47f6226e3c06fc",
+                "changelog": "- Animated trailers (anime included) now only play before animated content. Before, an anime trailer could play before a live-action movie or show when they shared a genre like Drama or Action, or when no trailer matched the genre filter. A live-action feature now gets no trailer rather than an animated one\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.11/cinematrailers4jellyfins_1.0.0.11.zip",
+                "timestamp": "2026-10-05T21:52:47Z",
+                "version": "1.0.0.11"
+            },
+            {
+                "checksum": "13e6467ce568b1abe987ef5a8a0ee95d",
+                "changelog": "- Fix trailer downloads, broken by a YouTube change. YouTube no longer serves combined video+audio files, so the built-in downloader now fetches the video and audio separately, merges them with ffmpeg (no re-encode) and deletes the separate files afterwards\n- A failed download no longer leaves an empty trailer folder behind. Empty folders counted toward \"Max trailers to keep\" (pushing out real trailers) and were never retried\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.10/cinematrailers4jellyfins_1.0.0.10.zip",
+                "timestamp": "2026-10-05T21:42:55Z",
+                "version": "1.0.0.10"
+            },
+            {
+                "checksum": "9594d14a5fed94ee5eea55d72c71728c",
+                "changelog": "- Skip trailers and pre-roll/feature pre-roll bumpers the current user can't actually access (e.g. a library not in their library access list) \u2014 some Cinema Mode clients hang indefinitely trying to play an inaccessible item, so these are now filtered out per-user instead\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.9/cinematrailers4jellyfins_1.0.0.9.zip",
+                "timestamp": "2026-06-10T17:07:24Z",
+                "version": "1.0.0.9"
+            },
+            {
+                "checksum": "89c66caa789da56ead7d60e01d3207a5",
+                "changelog": "- Fix Trailer Pre-Roll / Feature Pre-Roll bumpers not being found \u2014 the library lookup now walks the configured library folder's children directly instead of relying on TopParentIds matching, which could fail to match movies even when they appear correctly in the library\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.8/cinematrailers4jellyfins_1.0.0.8.zip",
+                "timestamp": "2026-06-10T15:28:02Z",
+                "version": "1.0.0.8"
+            },
+            {
+                "checksum": "a52f1354c9737cf9ec92f588bb4e750e",
+                "changelog": "- Add Information-level diagnostic logging to IIntroProvider.GetIntros \u2014 logs every call (item, path, and which features are enabled), why an item is skipped, and the outcome of Trailer/Feature Pre-Roll lookups, to help troubleshoot why a pre-roll bumper isn't playing\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.7/cinematrailers4jellyfins_1.0.0.7.zip",
+                "timestamp": "2026-06-10T15:10:56Z",
+                "version": "1.0.0.7"
+            },
+            {
+                "checksum": "96e0624e5173e5e6bf829d47118e1b40",
+                "changelog": "- Add diagnostic logging for Trailer Pre-Roll and Feature Pre-Roll bumpers \u2014 logs a warning if the configured library ID is invalid, and a debug message when no eligible movie is found or which movie was picked, to help troubleshoot why a bumper isn't playing\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.6/cinematrailers4jellyfins_1.0.0.6.zip",
+                "timestamp": "2026-06-10T14:35:52Z",
+                "version": "1.0.0.6"
+            },
+            {
+                "checksum": "6c88aaeb38023b327e9b042181dc0708",
+                "changelog": "- Add Trailer Pre-Roll and Feature Pre-Roll bumpers via IIntroProvider \u2014 pick existing Jellyfin Movie libraries in settings and a random movie from each is played before the trailer block (\"Now Playing\") and/or right before the feature (\"Feature Presentation\"); both are independent and disabled by default\n",
+                "targetAbi": "10.11.0.0",
+                "sourceUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/releases/download/v1.0.0.5/cinematrailers4jellyfins_1.0.0.5.zip",
+                "timestamp": "2026-06-10T05:14:23Z",
+                "version": "1.0.0.5"
+            },
             {
                 "checksum": "af6051b002939e4e5cd6ef4baf5c85d4",
                 "changelog": "- Add TV show trailer downloads \u2014 separate TMDB sources (Airing Today, On The Air, Popular, Top Rated) and a \"Max TV show trailers per run\" cap independent from movies; set either cap to 0 to skip that category entirely\n- Add trailers before TV episodes via IIntroProvider \u2014 only the first episode a user watches each day gets trailers, picked using the show's genre/rating for filtering\n- Movie and TV trailers are now kept separate \u2014 movies only ever get movie trailers and episodes only ever get TV show trailers, via a tag written to each trailer's NFO at download time\n",