Recognize trailing [tag] on folder, guard metadata tags

Folders that carry their release tag as a bracket at the end (rather than a -TAG suffix or [TAG] prefix), e.g.: Gravity Falls 2012 Season 2 Complete + EXTRAS 720p BluRay x264 [i_c] now have that tag ([i_c]) prepended to the episode filename. Also fixes a real bug where a title's own hyphenated word (e.g. "Scary-oke") could be mistaken for a "-GroupName" suffix; the word before the dash must now itself look like quality/source/codec metadata for that pattern to fire. Every tag-extraction path (file dash-suffix, file trailing-parens group, folder dash-suffix, folder bracket-suffix, folder bracket- prefix) now also refuses to promote something that's obviously a metadata token itself (e.g. WEB, 1080p, HDR, WEBRip) to a release tag.
Extract release group from trailing (...) metadata
2026-07-08 11:18:01 +02:00 · 2026-07-08 10:59:21 +02:00 · 2026-07-08 10:53:48 +02:00
3 changed files with 94 additions and 20 deletions
@@ -9,8 +9,8 @@
    <ImplicitUsings>enable</ImplicitUsings>
    <AssemblyName>Futonizer</AssemblyName>
    <RootNamespace>Futonizer</RootNamespace>
-    <Version>1.0.6</Version>
-    <FileVersion>1.0.6.0</FileVersion>
+    <Version>1.0.9</Version>
+    <FileVersion>1.0.9.0</FileVersion>
    <ApplicationIcon>Assets\app.ico</ApplicationIcon>
  </PropertyGroup>

@@ -14,11 +14,28 @@ public static class FileNameHelper
    private static readonly Regex FolderSuffixTagRegex =
        new(@"-([A-Z][A-Z0-9]{1,7})$", RegexOptions.Compiled);

+    // Folder suffix bracket release tag:  "Show Name ... x264 [i_c]"  →  tag = "i_c"
+    // A bracketed tag at the very end of the folder name (as opposed to
+    // PrefixTagRegex, which matches one at the start).
+    private static readonly Regex FolderSuffixBracketTagRegex =
+        new(@"\[([^\[\]]+)\]$", RegexOptions.Compiled);
+
    // File suffix release tag:  "…HEVC-DemiHuman"  →  tag = "DemiHuman"
    // Mixed case, 3-21 chars (no dots/spaces), at end of filename stem.
-    // Min 3 chars avoids false-positives like "-v2" or "-HD".
+    // Min 3 chars avoids false-positives like "-v2" or "-HD". The word
+    // immediately preceding the dash must itself be recognisable quality/
+    // source/codec metadata (checked by the caller via IsMetadataToken), so
+    // an ordinary hyphenated title word (e.g. "Scary-oke") is never mistaken
+    // for a "-GroupName" suffix.
    private static readonly Regex FileSuffixTagRegex =
-        new(@"-([A-Za-z][A-Za-z0-9]{2,20})$", RegexOptions.Compiled);
+        new(@"(?:^|[\s.])([A-Za-z0-9]+)-([A-Za-z][A-Za-z0-9]{2,20})$", RegexOptions.Compiled);
+
+    // Trailing parenthesised metadata block ending in the release group as its
+    // last word, e.g. "... (1080p AMZN WEB-DL x265 Celdra)" → group="Celdra".
+    // Common on Amazon/streaming rips that don't set the group off with a
+    // "-" or its own brackets.
+    private static readonly Regex TrailingParenGroupRegex =
+        new(@"\(([^()]*)\)$", RegexOptions.Compiled);

    // Prefix release tag:  "[KAA] Show Name"  →  tag = "KAA"
    private static readonly Regex PrefixTagRegex =
@@ -45,7 +62,8 @@ public static class FileNameHelper
        new(@"^(BD|BluRay|Blu-Ray|WEB|WEB-DL|WEBRip|HDTV|AMZN|NF|DSNP|HULU|MAX)$",RegexOptions.IgnoreCase | RegexOptions.Compiled), // sources
        new(@"^(Remux|Encode)$",                                                   RegexOptions.IgnoreCase | RegexOptions.Compiled), // processing
        new(@"^(HEVC|AVC|x264|x265|H\.?264|H\.?265|VP9)$",                        RegexOptions.IgnoreCase | RegexOptions.Compiled), // video codecs
-        new(@"^(FLAC|AAC|DTS|TrueHD|Atmos|AC3|EAC3|Opus|MP3)$",                  RegexOptions.IgnoreCase | RegexOptions.Compiled), // audio codecs
+        new(@"^(FLAC|AAC|DTS(-HD)?|TrueHD|Atmos|E?AC3|DDP?|Opus|MP3)(\d(\.\d)?)?$", RegexOptions.IgnoreCase | RegexOptions.Compiled), // audio codecs (+ optional channel suffix, e.g. DDP5.1)
+        new(@"^\d\.\d$",                                                           RegexOptions.Compiled),                           // bare channel count, e.g. 5.1
        new(@"^(HDR|SDR|10bit|8bit|HDR10|DV|DoVi)$",                              RegexOptions.IgnoreCase | RegexOptions.Compiled), // HDR / bit-depth
    ];

@@ -56,8 +74,10 @@ public static class FileNameHelper
    /// (in order):
    /// <list type="number">
    ///   <item>Filename suffix tag extraction — a trailing <c>-GroupName</c> on
-    ///         the filename stem is stripped and promoted to a bracket prefix.
-    ///         Takes priority over any folder-derived tag.</item>
+    ///         the filename stem, or a release group tucked in as the last word
+    ///         of a trailing <c>(...)</c> metadata block (e.g. Amazon rips like
+    ///         <c>(1080p AMZN WEB-DL x265 Celdra)</c>), is stripped and promoted
+    ///         to a bracket prefix. Takes priority over any folder-derived tag.</item>
    ///   <item>Show-name injection — if the (now tag-free) filename starts with
    ///         an episode code (e.g. S01E01) the show name is derived from the
    ///         parent folder and prepended.</item>
@@ -76,15 +96,45 @@ public static class FileNameHelper
        string folderName  = string.IsNullOrEmpty(folder) ? "" : (Path.GetFileName(folder) ?? "");

        // 1. Extract in-filename suffix tag and remove it from the stem.
-        //    e.g. "...HEVC-DemiHuman" → tag="DemiHuman", stem="...HEVC"
+        //    e.g. "...x264-DemiHuman" → tag="DemiHuman", stem="...x264"
+        //    Only fires when the word right before the dash is itself a
+        //    recognised metadata token (codec/source/etc.), so ordinary
+        //    hyphenated title words are left alone.
        string? fileTag = null;
        var fileSuffixMatch = FileSuffixTagRegex.Match(stemNoExt);
-        if (fileSuffixMatch.Success)
+        if (fileSuffixMatch.Success
+            && IsMetadataToken(fileSuffixMatch.Groups[1].Value)
+            && !IsMetadataToken(fileSuffixMatch.Groups[2].Value))
        {
-            fileTag  = fileSuffixMatch.Groups[1].Value;
-            stemNoExt = stemNoExt[..fileSuffixMatch.Index];
+            fileTag  = fileSuffixMatch.Groups[2].Value;
+            stemNoExt = stemNoExt[..(fileSuffixMatch.Groups[2].Index - 1)];
            fileName  = stemNoExt + ext;
        }
+        else
+        {
+            // 1b. Extract a release group tucked in as the last word of a
+            //     trailing "(...)" metadata block, e.g.
+            //     "... (1080p AMZN WEB-DL x265 Celdra)" → tag="Celdra",
+            //     stem="... (1080p AMZN WEB-DL x265)".
+            var parenMatch = TrailingParenGroupRegex.Match(stemNoExt);
+            if (parenMatch.Success)
+            {
+                string parenContent = parenMatch.Groups[1].Value;
+                var words = parenContent.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+                // Only treat the last word as a release group if the rest of the
+                // block is recognisable quality/source/codec metadata — this
+                // avoids misfiring on unrelated parentheticals like "(2020)" or
+                // "(Dual Audio)" that don't carry a group name.
+                if (words.Length >= 2 && !IsMetadataToken(words[^1]) && words[..^1].Any(IsMetadataToken))
+                {
+                    fileTag = words[^1];
+                    string remaining = string.Join(" ", words[..^1]);
+                    string beforeParen = stemNoExt[..parenMatch.Index].TrimEnd();
+                    stemNoExt = string.IsNullOrEmpty(remaining) ? beforeParen : $"{beforeParen} ({remaining})";
+                    fileName = stemNoExt + ext;
+                }
+            }
+        }

        // 2. Determine the release tag: filename suffix > folder tag.
        string? tag = fileTag;
@@ -134,17 +184,24 @@ public static class FileNameHelper
    }

    /// <summary>
-    /// Extracts the release tag string (without brackets) from a folder name.
-    /// Suffix pattern (<c>-TAG</c>) takes priority over prefix pattern
-    /// (<c>[TAG]</c>).  Returns <c>null</c> when neither is present.
+    /// Extracts the release tag string (without brackets) from a folder name,
+    /// checking (in priority order): a dash suffix (<c>-TAG</c>), a bracketed
+    /// suffix (<c>[tag]</c> at the end), then a bracketed prefix (<c>[tag]</c>
+    /// at the start). Returns <c>null</c> when none are present.
    /// </summary>
    public static string? ExtractReleaseTag(string folderName)
    {
        var suffixMatch = FolderSuffixTagRegex.Match(folderName);
-        if (suffixMatch.Success) return suffixMatch.Groups[1].Value;
+        if (suffixMatch.Success && !IsMetadataToken(suffixMatch.Groups[1].Value))
+            return suffixMatch.Groups[1].Value;
+
+        var bracketSuffixMatch = FolderSuffixBracketTagRegex.Match(folderName);
+        if (bracketSuffixMatch.Success && !IsMetadataBracket(bracketSuffixMatch.Groups[1].Value))
+            return bracketSuffixMatch.Groups[1].Value;

        var prefixMatch = PrefixTagRegex.Match(folderName);
-        if (prefixMatch.Success) return prefixMatch.Groups[1].Value;
+        if (prefixMatch.Success && !IsMetadataBracket(prefixMatch.Groups[1].Value))
+            return prefixMatch.Groups[1].Value;

        return null;
    }
@@ -163,6 +220,7 @@ public static class FileNameHelper
    {
        // Strip release tags first.
        string name = FolderSuffixTagRegex.Replace(folderName, "").Trim();
+        name = FolderSuffixBracketTagRegex.Replace(name, "").Trim();
        name = PrefixTagRegex.Replace(name, "").Trim();

        // Nothing left, or what remains immediately starts with a bracket — no show name.
@@ -191,4 +249,16 @@ public static class FileNameHelper
            if (pattern.IsMatch(token)) return true;
        return false;
    }
+
+    /// <summary>
+    /// True when every word inside a bracketed block is recognisable quality/
+    /// source/codec metadata (e.g. "[HEVC]", "[1080p-FLAC]"), meaning it's
+    /// just another metadata tag rather than an actual release group name
+    /// (e.g. "[i_c]").
+    /// </summary>
+    private static bool IsMetadataBracket(string content)
+    {
+        var parts = content.Split(new[] { ' ', '-' }, StringSplitOptions.RemoveEmptyEntries);
+        return parts.Length > 0 && parts.All(IsMetadataToken);
+    }
 }
@@ -93,9 +93,12 @@ public class MkvService

    /// <summary>
    /// Builds the list of <see cref="TrackItem"/> objects for a file. Video
-    /// tracks are always pre-checked. Exactly one audio track is pre-checked:
-    /// among Japanese/Chinese/undefined-language tracks, a stereo (2-channel)
-    /// track is preferred, otherwise the first matching track in file order.
+    /// tracks are always pre-checked. Exactly one audio track is always
+    /// pre-checked: among Japanese/Chinese/undefined-language tracks, a
+    /// stereo (2-channel) track is preferred, otherwise the first matching
+    /// track in file order. If no such track exists (e.g. only English
+    /// audio), the very first audio track in the file is pre-checked instead,
+    /// so a file is never left with no audio track selected.
    /// Subtitle tracks are never pre-checked — the user picks one via the
    /// track table, and the choice propagates to other queued files.
    /// </summary>
@@ -108,7 +111,8 @@ public class MkvService
            .ToList();

        MkvTrack? preferredAudio = eligibleAudio.FirstOrDefault(t => t.Properties?.AudioChannels == 2)
-                                    ?? eligibleAudio.FirstOrDefault();
+                                    ?? eligibleAudio.FirstOrDefault()
+                                    ?? audioTracks.FirstOrDefault();

        var items = info.Tracks.Select(t =>
        {