fix: language filter also checks the title's original language (v1.0.0.15)

AllowedLanguages only filtered on each video's iso_639_1 tag, and TMDB
often tags subtitled foreign trailers as "en". With en,fr selected, 6 of
27 downloaded trailers were Korean, Chinese or Zulu titles. Candidates
now also need an allowed original_language (from the list results, so
no extra API calls).

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

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;">

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.11</AssemblyVersion>
-    <FileVersion>1.0.0.11</FileVersion>
+    <AssemblyVersion>1.0.0.15</AssemblyVersion>
+    <FileVersion>1.0.0.15</FileVersion>
     <Nullable>enable</Nullable>
     <GenerateDocumentationFile>false</GenerateDocumentationFile>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>

Jellyfin.Plugin.CinemaTrailers4Jellyfins/ScheduledTasks/DownloadTrailersTask.cs

@@ -177,6 +177,14 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                     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);
 
@@ -217,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(
@@ -283,6 +292,14 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.ScheduledTasks
                     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);
 
@@ -323,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/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
     {
@@ -170,6 +170,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 +178,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))
@@ -236,7 +237,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 +263,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

@@ -63,8 +63,10 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
 
             if (!string.IsNullOrWhiteSpace(ytDlpPath) && File.Exists(ytDlpPath))
             {
-                return await DownloadWithYtDlpAsync(youtubeKey, outputPath, preferredHeight, ytDlpPath, 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)
@@ -224,13 +226,16 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
         {
             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.
+                // Format selects the best video at or below preferredHeight merged with the best audio,
+                // 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}\"");
 
@@ -252,11 +257,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;
@@ -273,6 +282,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

@@ -147,12 +147,12 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
                 }
                 else
                 {
-                    // Animation is a style, not a topic: animated trailers (anime included) only play
-                    // before animated content. Applied before the fallback below, so a live-action
-                    // feature never gets one — it gets no trailer instead.
-                    var eligible = IsAnimated(feature)
+                    // Anime trailers only play before anime. Applied before the fallback below, so
+                    // non-anime content never gets one — it gets no trailer instead. Western animation
+                    // is not affected and follows the normal filters.
+                    var eligible = IsAnimeFeature(feature)
                         ? pairs
-                        : pairs.Where(p => !IsAnimated(p.Movie)).ToList();
+                        : 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);
@@ -236,11 +236,19 @@ namespace Jellyfin.Plugin.CinemaTrailers4Jellyfins.Services
             return new IntroInfo { ItemId = movie.Id, Path = movie.Path };
         }
 
-        // TMDB tags anime as "Animation"; anime metadata providers (e.g. AniDB) use "Anime".
-        private static readonly string[] AnimatedGenres = { "Animation", "Anime" };
+        // 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 IsAnimated(BaseItem item)
-            => item.Genres.Any(g => AnimatedGenres.Contains(g, StringComparer.OrdinalIgnoreCase));
+        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,

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.11
+version: 1.0.0.15
 name: CinemaTrailers4Jellyfins
 guid: b581493e-1046-40ed-b6dc-cb8027624984
 description: >
@@ -12,11 +12,10 @@ category: General
 owner: 514mart
 targetAbi: 10.11.0.0
 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
+  - 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
 
 dotnetProjects:
   - name: Jellyfin.Plugin.CinemaTrailers4Jellyfins

manifest.json

@@ -8,6 +8,38 @@
         "owner": "514mart",
         "imageUrl": "https://www.git.quarantinedstudio.com/mvezina/CinemaTrailers4Jellyfins/raw/branch/main/Jellyfin.Plugin.CinemaTrailers4Jellyfins/Images/logo.svg",
         "versions": [
+            {
+                "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",