v3.6: duplicate-aware queue, delete source after processing, README refresh

- Queue duplicate detection by resolved, case-normalized path (also within a
  single drop/batch); skipped files reported in the status line
- New 'Delete Source Files After Processing' option: removes each source right
  after its encode is verified, one by one; with 'Replace Original Files' the
  .old backup is dropped too; start dialog warns when enabled
- Fix queue rows not showing running/success/failed colours (item stylesheet
  overrode per-item backgrounds); add state glyphs, auto-scroll to current file
- README rewritten around current feature set; new screenshot

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: hclivess

README.md

@@ -1,42 +1,86 @@
 # videer
 
-FFmpeg batch GUI with AviSynth support for **deinterlacing** and profile configuration that can be used in [*
-*frameserving**](https://github.com/satishsampath/frame-server). Created as a replacement for inflexible batch files
+FFmpeg batch GUI with AviSynth+ support for **deinterlacing** and profile configuration that can be used in
+[**frameserving**](https://github.com/satishsampath/frame-server). Created as a replacement for inflexible batch files
 that do not allow multiple encodings at the same time easily.
 Videer integrates `QTGMC`, which provides much smoother results than
 ffmpeg's `yadif`, [see for yourself](https://www.youtube.com/watch?v=jE47A57T5FA). `QTGMC` is the best deinterlacer in
 existence. Including AI and DaVinci Studio.
 
-## Notice
-
-If you are not using a frameserver and are just trying to transcode video with any feature that requires Avisynth+, and are running into issues, you should try with ffms2 enabled.
+![videer processing a queue](thumb.png)
 
 ## Why
 
 FFmpeg is a superior command line video encoding tool. Videer serves as a GUI for it.
 
-## New features:
-
-- Multithreading using `SetFilterMTMode`
-- AviSynth+
-- 64bit Implementation
-- Matroska format as it is the only one to support `pgssub`
-- CUDA GPU acceleration support
-- Live queue: add files or drag-drop while encoding is running — new files are appended and processed without restarting
-- Optional resolution scaling (2160p → 360p presets or custom W×H, "never upscale" guard, selectable lanczos/bicubic/spline/bilinear/neighbor scaler)
-- Deinterlacer choice: `QTGMC` (AviSynth+, Windows) or FFmpeg's `bwdif` / `yadif` (any OS, any input)
-- AV1 (SVT-AV1) and VP9 encoders with per-encoder speed presets; NVENC uses the modern `p1`–`p7` presets
-- Live progress panel: per-file and total ETA, fps, speed, bitrate, output size, position — parsed from FFmpeg's machine-readable `-progress` output
-- Settings sanity check before starting (container/codec mismatches, ignored options, missing AviSynth plugins)
-- Cross-platform: runs on Windows, Linux and macOS (AviSynth+/QTGMC features are Windows-only); no shell or PowerShell calls
-
-## Requirements:
-
-- [FFmpeg](https://ffmpeg.org/) in the system PATH or next to videer (a Windows build is attached to the [latest release](https://github.com/hclivess/videer/releases/latest) as `ffmpeg.7z`)
-- For QTGMC deinterlacing / AviSynth+ processing (Windows): [AviSynth+](https://avs-plus.net/) — the tested MT installer is attached to the [latest release](https://github.com/hclivess/videer/releases/latest) as `AviSynthPlus-MT-r2772.exe`
-- No need to install AviSynth plugins, all are bundled in `plugins/`
-- Python 3.9+ — on Windows run `run.cmd` (installs `requirements.txt` via pip and starts the app), or manually `pip install -r requirements.txt && python main.py`
+## Notice
+
+If you are not using a frameserver and are just trying to transcode video with any feature that requires AviSynth+, and
+are running into issues, you should try with ffms2 enabled.
+
+## Features
+
+### Queue
+
+- Add files, add folders (recursive), or drag & drop files/folders onto the list; batches are sorted naturally
+  (`Tape 1, Tape 2, Tape 10` — not `1, 10, 2`)
+- **Duplicate detection**: a file already in the queue is skipped, even if it is added again under a different spelling
+  (relative/absolute path, different letter case, symlink) or appears twice in the same drop. Skipped files are
+  reported in the status line.
+- **Live queue**: add or remove files while encoding is running — pending entries are appended/removed without
+  restarting; files already processed or in progress cannot be removed
+- Drag entries to reorder; each entry is coloured by state (▶ running, ✔ done, ✖ failed) and shows its VMAF score
+  when enabled
+- **Pause / Resume** the whole run (suspends FFmpeg and its children, ETAs are corrected for the pause) and **Stop**
 
-### Preview:
+### Encoding
 
-![thumb](thumb.png)
+- Video: H.264 (x264), H.265/HEVC (x265), AV1 (SVT-AV1), VP9, NVIDIA NVENC H.264/HEVC (`p1`–`p7` presets), ProRes,
+  raw, or stream copy; CRF quality and per-encoder speed presets
+- Audio: AAC, MP3, Opus, AC3, FLAC, PCM, or stream copy; bitrate control and optional stereo downmix
+- Containers: MKV (the only one that carries `pgssub`), MP4, AVI, MOV, WebM
+- Deinterlacer choice: `QTGMC` (AviSynth+, Windows) or FFmpeg's `bwdif` / `yadif` (any OS, any input); field order
+  and optional frame-rate halving
+- Optional resolution scaling (2160p → 360p presets or custom W×H, "never upscale" guard, lanczos / bicubic / spline /
+  bilinear / neighbor scaler)
+- PAR / DAR presets and custom values, with metadata-only or resampling handling
+- AviSynth+ pipeline with `SetFilterMTMode` multithreading, ffms2 source filter, optional raw pre-transcode for
+  problematic inputs, and a free-form script box; all required AviSynth plugins are bundled in `plugins/`
+- CUDA GPU acceleration support; 64-bit implementation
+- Extra FFmpeg arguments pass-through; save / load your own presets, plus bundled Web / High Quality / Archive / AV1
+  presets; `defaults.json` support for your own startup defaults
+
+### File handling
+
+- Output is written next to the source as `<name>_<vcodec>_<acodec>_crf<N>_abr<N>[_<res>].<ext>`; timestamps are
+  copied from the original
+- **Replace Original Files**: the encode takes over the original filename; the original is kept as `<name>.old<ext>`
+- **Delete Source Files After Processing**: permanently deletes each source right after *its* encode succeeds — one by
+  one as the queue progresses, so disk space is freed while long batches are still running. The source is only removed
+  when the output exists and is non-empty; files that fail or are stopped keep their source. Combined with *Replace
+  Original Files* the `.old` backup is removed too. There is no recycle bin and no undo — the start dialog warns you
+  when this is on.
+- Per-file `<name>.log` with the full FFmpeg command line and output; temporary `.avs` / `.ffindex` / `.trans.avi`
+  files are cleaned up
+
+### Feedback
+
+- Live progress panel: per-file and total ETA, fps, speed, bitrate, output size, position — parsed from FFmpeg's
+  machine-readable `-progress` output
+- Settings sanity check before starting (container/codec mismatches, ignored options, missing AviSynth plugins,
+  destructive options)
+- Opt-in VMAF score after encoding (requires `libvmaf` in FFmpeg)
+- Cross-platform: runs on Windows, Linux and macOS (AviSynth+/QTGMC features are Windows-only); no shell or
+  PowerShell calls
+
+## Requirements
+
+- [FFmpeg](https://ffmpeg.org/) in the system PATH or next to videer (a Windows build is attached to the
+  [latest release](https://github.com/hclivess/videer/releases/latest) as `ffmpeg.7z`)
+- For QTGMC deinterlacing / AviSynth+ processing (Windows): [AviSynth+](https://avs-plus.net/) — the tested MT
+  installer is attached to the [latest release](https://github.com/hclivess/videer/releases/latest) as
+  `AviSynthPlus-MT-r2772.exe`
+- No need to install AviSynth plugins, all are bundled in `plugins/`
+- Python 3.9+ — on Windows run `run.cmd` (installs `requirements.txt` via pip and starts the app), or manually
+  `pip install -r requirements.txt && python main.py`. Prebuilt binaries for Windows / Linux / macOS are attached to
+  each release.

config.py

@@ -8,7 +8,7 @@
 
 # Application info
 APP_NAME = "videer"
-APP_VERSION = "3.5"
+APP_VERSION = "3.6"
 WINDOW_MIN_WIDTH = 1200
 WINDOW_MIN_HEIGHT = 900
 
@@ -192,6 +192,7 @@
     "transcode_audio": False,
     "corrupt_fix": False,
     "replace_files": False,
+    "delete_source": False,
     "threads": DEFAULT_THREADS,
     "par_mode": "auto",
     "par_value": "1:1",

main.py

@@ -55,6 +55,7 @@ def connect_signals(self):
         # File manager signals
         self.file_manager.files_updated.connect(self.ui_manager.update_file_list)
         self.file_manager.file_count_changed.connect(self.ui_manager.update_file_count)
+        self.file_manager.duplicates_skipped.connect(self._on_duplicates_skipped)
 
         # Process manager signals
         self.process_manager.progress_updated.connect(self.ui_manager.update_progress)
@@ -133,6 +134,13 @@ def _on_files_updated_during_processing(self, files):
         if self.process_manager.is_processing():
             self.process_manager.sync_pending(files)
 
+    def _on_duplicates_skipped(self, paths):
+        """Tell the user which dropped/selected files were already in the queue"""
+        names = [os.path.basename(p) for p in paths]
+        shown = ", ".join(names[:5]) + (f" (+{len(names) - 5} more)" if len(names) > 5 else "")
+        self.ui_manager.update_status(
+            f"Skipped {len(names)} duplicate file{'s' if len(names) != 1 else ''} already in queue: {shown}")
+
     def _on_files_removed(self, indices):
         """Safe removal: block removal of already-processed or in-progress files"""
         if self.process_manager.is_processing():

models/file_models.py

@@ -8,12 +8,25 @@
 from typing import Optional, List, Dict, Any
 
 
+def canonical_path(filepath: str) -> str:
+    """
+    Identity key for duplicate detection: absolute, symlink-resolved,
+    case-normalized (case-insensitive filesystems on Windows/macOS).
+    """
+    try:
+        resolved = os.path.realpath(os.path.abspath(filepath))
+    except OSError:
+        resolved = os.path.abspath(filepath)
+    return os.path.normcase(resolved)
+
+
 class VideoFile:
     """Represents a video file to be processed"""
 
     def __init__(self, filepath: str, index: int = 0):
         self.index = index
         self.filepath = filepath
+        self.canonical = canonical_path(filepath)
         self.filename = os.path.basename(filepath)
         self.directory = os.path.dirname(os.path.abspath(filepath))
         self.basename = os.path.splitext(self.filename)[0]
@@ -213,8 +226,9 @@ def clear(self):
         self.files.clear()
 
     def contains(self, filepath: str) -> bool:
-        """Check if filepath is already in queue"""
-        return any(f.filepath == filepath for f in self.files)
+        """Check if filepath (or another spelling of the same file) is already in queue"""
+        key = canonical_path(filepath)
+        return any(f.canonical == key for f in self.files)
 
     def get_all(self) -> List[VideoFile]:
         """Get all files in queue"""

modules/file_manager.py

@@ -8,7 +8,7 @@
 from typing import List, Optional
 from PySide6.QtCore import QObject, Signal
 
-from models.file_models import VideoFile, FileQueue
+from models.file_models import VideoFile, FileQueue, canonical_path
 from config import VIDEO_EXTENSIONS
 
 
@@ -24,44 +24,56 @@ class FileManager(QObject):
     # Signals
     files_updated = Signal(list)  # List of VideoFile objects
     file_count_changed = Signal(int)  # Number of files in queue
+    duplicates_skipped = Signal(list)  # Paths that were already queued (or repeated in the drop)
 
     def __init__(self):
         super().__init__()
         self.queue = FileQueue()
 
     def add_files(self, filepaths: List[str]) -> int:
         """
-        Add files to the queue
-        Returns number of files added
+        Add files to the queue, skipping duplicates.
+        A file counts as a duplicate if it is already queued *or* appears twice
+        in the same batch — compared by resolved, case-normalized path, so
+        `C:\\Video\\a.mkv`, `c:/video/A.MKV` and a symlink to it are all one file.
+        Returns number of files added.
         """
-        added_count = 0
         valid_files = []
+        skipped = []
+        seen = set()
+
+        def consider(candidate: str):
+            if not self._is_valid_video_file(candidate):
+                return
+            key = canonical_path(candidate)
+            if key in seen or self.queue.contains(candidate):
+                skipped.append(candidate)
+                return
+            seen.add(key)
+            valid_files.append(candidate)
 
         for filepath in filepaths:
             # Dropped folders: expand recursively to the video files they contain
             if os.path.isdir(filepath):
                 for root, dirs, entries in os.walk(filepath):
                     dirs.sort(key=_natural_sort_key)
                     for entry in sorted(entries, key=_natural_sort_key):
-                        candidate = os.path.join(root, entry)
-                        if self._is_valid_video_file(candidate) and not self.queue.contains(candidate):
-                            valid_files.append(candidate)
-                            added_count += 1
+                        consider(os.path.join(root, entry))
                 continue
-            if self._is_valid_video_file(filepath):
-                if not self.queue.contains(filepath):
-                    valid_files.append(filepath)
-                    added_count += 1
-        
+            consider(filepath)
+
         if valid_files:
             # Multi-selects arrive in OS selection order (often lexicographic:
             # 1, 10, 2, 20) — order each added batch naturally instead
             if len(valid_files) > 1:
                 valid_files.sort(key=_natural_sort_key)
             self.queue.add_files(valid_files)
             self._emit_updates()
-        
-        return added_count
+
+        if skipped:
+            self.duplicates_skipped.emit(skipped)
+
+        return len(valid_files)
 
     def add_folder(self, folder_path: str) -> int:
         """

modules/preset_manager.py

@@ -215,7 +215,7 @@ def apply_settings(self, settings: Dict[str, Any]):
         checkbox_fields = [
             'stereo', 'deinterlace', 'tff', 'reduce_fps',
             'use_avisynth', 'use_ffms2', 'transcode_video',
-            'transcode_audio', 'corrupt_fix', 'replace_files',
+            'transcode_audio', 'corrupt_fix', 'replace_files', 'delete_source',
             'calculate_vmaf', 'no_upscale'
         ]
 

modules/process_manager.py

@@ -124,10 +124,19 @@ def run(self):
                         and self.settings.get('video_codec') != 'copy'):
                     self._calculate_vmaf(file, file.get_full_output_path(), index)
 
+                output_path = file.get_full_output_path()
+                delete_source = bool(self.settings.get('delete_source'))
                 if self.settings.get('replace_files'):
-                    self.file_ops.replace_file(file.get_full_output_path(), file.filepath, file.logger)
+                    # With delete_source the .old backup is dropped as well
+                    self.file_ops.replace_file(output_path, file.filepath, file.logger,
+                                               keep_backup=not delete_source)
                 else:
-                    self.file_ops.preserve_timestamps(file.filepath, file.get_full_output_path(), file.logger)
+                    self.file_ops.preserve_timestamps(file.filepath, output_path, file.logger)
+                    if delete_source:
+                        # Free space as we go: remove this source right after its
+                        # encode is verified, before moving on to the next file
+                        if self.file_ops.delete_source(file.filepath, output_path, file.logger):
+                            self.info_signal.emit(f"Deleted source: {file.filename}")
 
             file.cleanup_temp_files()
             self._completed_wall_times.append(time.time() - self._file_start_time)
@@ -656,6 +665,9 @@ def validate_settings(settings: Dict[str, Any]) -> List[str]:
             issues.append(f"{output_format.upper()} cannot carry text subtitles — they will be dropped.")
         if settings.get('transcode_video') or settings.get('transcode_audio'):
             issues.append("Raw pre-transcode uses an AVI intermediate: subtitles are not carried over.")
+        if settings.get('delete_source'):
+            issues.append("Delete Source Files is ON: each original is permanently deleted "
+                          "as soon as its encode succeeds (no .old backup, no recycle bin).")
         if settings.get('calculate_vmaf') and settings.get('deinterlace') and settings.get('reduce_fps'):
             issues.append("VMAF needs matching frame rates; halving FPS while deinterlacing will make it fail.")