Ignore publish/ build output

Extract in-filename suffix release tag (e.g. -DemiHuman) and
move it to a [DemiHuman] bracket prefix, stripping it from the
filename. File-level tag takes priority over folder-derived tag.

.gitignore

@@ -1,5 +1,6 @@
 bin/
 obj/
+publish/
 *.user
 history.json
 settings.json

Futonizer.csproj

@@ -9,6 +9,8 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <AssemblyName>Futonizer</AssemblyName>
     <RootNamespace>Futonizer</RootNamespace>
+    <Version>1.0.4</Version>
+    <FileVersion>1.0.4.0</FileVersion>
     <ApplicationIcon>Assets\app.ico</ApplicationIcon>
   </PropertyGroup>
 

MainWindow.xaml

@@ -175,7 +175,7 @@
                                                        Foreground="#F44336" VerticalAlignment="Center"
                                                        Visibility="{Binding IsIncorrect, Converter={StaticResource BoolToVis}}"/>
 
-                                            <TextBlock Grid.Column="1" Text="{Binding FileName}"
+                                            <TextBlock Grid.Column="1" Text="{Binding DisplayFileName}"
                                                        FontSize="12" VerticalAlignment="Center" Margin="6,0"
                                                        TextTrimming="CharacterEllipsis"/>
 
@@ -230,6 +230,7 @@
                                   GridLinesVisibility="None"
                                   VirtualizingPanel.ScrollUnit="Pixel"
                                   PreviewMouseWheel="SmoothList_PreviewMouseWheel"
+                                  PreviewKeyDown="TrackGrid_PreviewKeyDown"
                                   ScrollViewer.HorizontalScrollBarVisibility="Auto"
                                   ScrollViewer.VerticalScrollBarVisibility="Auto">
                             <DataGrid.RowStyle>
@@ -330,6 +331,15 @@
                     </Grid>
                 </Border>
 
+                <!-- Processing overlay: dims the entire content area while stripping is running -->
+                <Border x:Name="ProcessingOverlay"
+                        Grid.ColumnSpan="3"
+                        Background="#99000000"
+                        CornerRadius="8"
+                        Visibility="Collapsed"
+                        IsHitTestVisible="True"
+                        Panel.ZIndex="10"/>
+
                 <!-- Loading overlay: blocks interaction until every queued file has finished loading -->
                 <Border x:Name="LoadingOverlay"
                         Grid.ColumnSpan="3"

MainWindow.xaml.cs

@@ -131,6 +131,15 @@ public partial class MainWindow : FluentWindow
         RunButton.ToolTip = allCorrect
             ? null
             : "Every file in the queue needs exactly one audio and one subtitle track selected before stripping.";
+
+        UpdateRunButtonLabel();
+    }
+
+    private void UpdateRunButtonLabel()
+    {
+        bool anyRename = _fileQueue.Any(f =>
+            !string.Equals(f.DisplayFileName, f.FileName, StringComparison.Ordinal));
+        RunButton.Content = anyRename ? "Rename and Strip Tracks" : "Strip Tracks";
     }
 
     private void QueuedFileItem_PropertyChanged(object? sender, PropertyChangedEventArgs e)
@@ -403,6 +412,13 @@ public partial class MainWindow : FluentWindow
     /// Windows has associated with .mkv files (typically the default video
     /// player), so the user can quickly preview a file without leaving the app.
     /// </summary>
+    private void TrackGrid_PreviewKeyDown(object sender, System.Windows.Input.KeyEventArgs e)
+    {
+        if (e.Key != System.Windows.Input.Key.Space) return;
+        OpenSelectedFileInDefaultPlayer();
+        e.Handled = true;
+    }
+
     private void OpenSelectedFileInDefaultPlayer()
     {
         if (FileQueueList.SelectedItem is not QueuedFileItem item) return;
@@ -493,6 +509,7 @@ public partial class MainWindow : FluentWindow
         _isProcessing = true;
         RunButton.IsEnabled = false;
         StatusText.Text = string.Empty;
+        ProcessingOverlay.Visibility = Visibility.Visible;
 
         var progressWin = new ProgressWindow(readyFiles, _settings.MkvMergePath, _settings.OutputFolder, MaxConcurrentStrips)
         {
@@ -501,6 +518,7 @@ public partial class MainWindow : FluentWindow
         progressWin.Closed += (_, _) =>
         {
             _isProcessing = false;
+            ProcessingOverlay.Visibility = Visibility.Collapsed;
             if (progressWin.ShouldClearQueue)
             {
                 foreach (var item in _fileQueue)

Models/QueuedFileItem.cs

@@ -3,6 +3,7 @@ using System.Collections.Specialized;
 using System.ComponentModel;
 using System.IO;
 using System.Runtime.CompilerServices;
+using Futonizer.Services;
 
 namespace Futonizer.Models;
 
@@ -32,6 +33,13 @@ public class QueuedFileItem : INotifyPropertyChanged
 
     public string FilePath { get; }
     public string FileName => Path.GetFileName(FilePath);
+
+    /// <summary>
+    /// The filename as it will appear after rename adjustments (release-tag prefix
+    /// and/or show-name injection).  Equals <see cref="FileName"/> when no
+    /// changes would be applied.
+    /// </summary>
+    public string DisplayFileName => FileNameHelper.ComputeOutputFileName(FilePath);
     public string FileSizeDisplay { get; }
     public ObservableCollection<TrackItem> Tracks { get; } = new();
 

Services/FileNameHelper.cs

@@ -0,0 +1,153 @@
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace Futonizer.Services;
+
+/// <summary>
+/// Pure static helpers for computing the final output filename from a source
+/// file path, applying release-tag prefixing and show-name injection.
+/// </summary>
+public static class FileNameHelper
+{
+    // Folder suffix release tag:  "Show Name-TTGA"  →  tag = "TTGA"
+    // All-uppercase, 2-8 chars, at end of folder name.
+    private static readonly Regex FolderSuffixTagRegex =
+        new(@"-([A-Z][A-Z0-9]{1,7})$", 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".
+    private static readonly Regex FileSuffixTagRegex =
+        new(@"-([A-Za-z][A-Za-z0-9]{2,20})$", RegexOptions.Compiled);
+
+    // Prefix release tag:  "[KAA] Show Name"  →  tag = "KAA"
+    private static readonly Regex PrefixTagRegex =
+        new(@"^\[(.+?)\]", RegexOptions.Compiled);
+
+    // Episode-only filename: starts with S01E01, S1E1, etc. (no show name present)
+    private static readonly Regex EpisodeOnlyRegex =
+        new(@"^S\d+E\d+", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+
+    // Individual metadata-token patterns used to find where the show name ends
+    // inside a folder name.
+    private static readonly Regex[] MetadataPatterns =
+    [
+        new(@"^S\d+$",                                                              RegexOptions.IgnoreCase | RegexOptions.Compiled), // S01
+        new(@"^S\d+E\d+",                                                          RegexOptions.IgnoreCase | RegexOptions.Compiled), // S01E01...
+        new(@"^E[Pp]?\d+$",                                                        RegexOptions.IgnoreCase | RegexOptions.Compiled), // E01, EP01
+        new(@"^\d{3,4}[pP]$",                                                      RegexOptions.Compiled),                           // 1080p, 720p
+        new(@"^(4K|UHD|2160p)$",                                                   RegexOptions.IgnoreCase | RegexOptions.Compiled), // 4K, UHD
+        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(@"^(HDR|SDR|10bit|8bit|HDR10|DV|DoVi)$",                              RegexOptions.IgnoreCase | RegexOptions.Compiled), // HDR / bit-depth
+    ];
+
+    // -------------------------------------------------------------------------
+
+    /// <summary>
+    /// Computes the final output filename for a given source file path, applying
+    /// (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>
+    ///   <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>
+    ///   <item>Release-tag prefix — a <c>[TAG]</c> bracket prefix, sourced from
+    ///         the filename suffix, the folder suffix, or the folder prefix,
+    ///         in that priority order.</item>
+    /// </list>
+    /// Returns the original filename unchanged when no transformations apply.
+    /// </summary>
+    public static string ComputeOutputFileName(string sourceFilePath)
+    {
+        string fileName    = Path.GetFileName(sourceFilePath);
+        string ext         = Path.GetExtension(fileName);
+        string stemNoExt   = Path.GetFileNameWithoutExtension(fileName);
+        string? folder     = Path.GetDirectoryName(sourceFilePath);
+        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"
+        string? fileTag = null;
+        var fileSuffixMatch = FileSuffixTagRegex.Match(stemNoExt);
+        if (fileSuffixMatch.Success)
+        {
+            fileTag  = fileSuffixMatch.Groups[1].Value;
+            stemNoExt = stemNoExt[..fileSuffixMatch.Index];
+            fileName  = stemNoExt + ext;
+        }
+
+        // 2. Determine the release tag: filename suffix > folder tag.
+        string? tag = fileTag;
+        if (string.IsNullOrEmpty(tag) && !string.IsNullOrEmpty(folderName))
+            tag = ExtractReleaseTag(folderName);
+
+        // 3. Inject show name when only an episode code is present.
+        if (EpisodeOnlyRegex.IsMatch(stemNoExt) && !string.IsNullOrEmpty(folderName))
+        {
+            string showName = ExtractShowName(folderName);
+            if (!string.IsNullOrEmpty(showName))
+                fileName = showName + " " + fileName;
+        }
+
+        // 4. Prepend release tag if not already present.
+        if (!string.IsNullOrEmpty(tag))
+        {
+            string tagPrefix = $"[{tag}]";
+            if (!fileName.StartsWith(tagPrefix, StringComparison.OrdinalIgnoreCase))
+                fileName = tagPrefix + " " + fileName;
+        }
+
+        return fileName;
+    }
+
+    /// <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.
+    /// </summary>
+    public static string? ExtractReleaseTag(string folderName)
+    {
+        var suffixMatch = FolderSuffixTagRegex.Match(folderName);
+        if (suffixMatch.Success) return suffixMatch.Groups[1].Value;
+
+        var prefixMatch = PrefixTagRegex.Match(folderName);
+        if (prefixMatch.Success) return prefixMatch.Groups[1].Value;
+
+        return null;
+    }
+
+    /// <summary>
+    /// Derives the show name from a folder name by stripping any release tag
+    /// (prefix or suffix) and then taking all words that precede the first
+    /// recognised metadata token (season, quality, source, codec, etc.).
+    /// </summary>
+    public static string ExtractShowName(string folderName)
+    {
+        // Strip release tags first.
+        string name = FolderSuffixTagRegex.Replace(folderName, "").Trim();
+        name = PrefixTagRegex.Replace(name, "").Trim();
+
+        // Collect words up to the first metadata token.
+        var words     = name.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+        var showWords = new List<string>();
+        foreach (var word in words)
+        {
+            if (IsMetadataToken(word)) break;
+            showWords.Add(word);
+        }
+
+        return string.Join(" ", showWords).Trim();
+    }
+
+    private static bool IsMetadataToken(string token)
+    {
+        foreach (var pattern in MetadataPatterns)
+            if (pattern.IsMatch(token)) return true;
+        return false;
+    }
+}

Views/ProgressWindow.xaml.cs

@@ -144,7 +144,8 @@ public partial class ProgressWindow : FluentWindow
             {
                 await semaphore.WaitAsync(ct);
 
-                var job = new JobProgressItem { FileName = file.FileName, FileSizeBytes = SafeFileLength(file.FilePath) };
+                string computedFileName = FileNameHelper.ComputeOutputFileName(file.FilePath);
+                var job = new JobProgressItem { FileName = computedFileName, FileSizeBytes = SafeFileLength(file.FilePath) };
                 job.PropertyChanged += (_, args) =>
                 {
                     if (args.PropertyName == nameof(JobProgressItem.MegabytesPerSecond))
@@ -157,9 +158,11 @@ public partial class ProgressWindow : FluentWindow
 
                 try
                 {
+                    string sourceDir = Path.GetDirectoryName(file.FilePath) ?? "";
+
                     string outputFilePath = overwritingInPlace
-                        ? file.FilePath
+                        ? Path.Combine(sourceDir, computedFileName)
-                        : Path.Combine(_outputFolder, file.FileName);
+                        : Path.Combine(_outputFolder, computedFileName);
 
                     var videoIds = file.Tracks
                         .Where(t => t.Type == "video" && t.Copy)
@@ -187,7 +190,7 @@ public partial class ProgressWindow : FluentWindow
                             progress, ct);
 
                     string tag = result.Success ? "[DONE]" : "[FAIL]";
-                    AppendLog($"{tag} {result.FileName} — {result.Message}");
+                    AppendLog($"{tag} {Path.GetFileName(result.OutputFilePath)} — {result.Message}");
 
                     HistoryService.Add(new HistoryEntry
                     {