Development log

DMDNet Relicensed as User-Installed, Disabled by Default (BREAKING)

• Corrected license. Upstream DMDNet (csxmli2016/DMDNet) is CC-BY-NC-SA-4.0 — non-commercial with a share-alike obligation. ATR had recorded it three different ways, all wrong: MODEL_LICENSES.md said Apache-2.0/commercial-OK, the engine source header said MIT, and EngineMetadata.license_spdx said "MIT". The Apache-2.0 claim came from DMDNet crediting BasicSR; a dependency's license does not relicense the derivative built on it.
• Four gates were silently inert. With non_commercial unset, the preflight job warning, is_commercial_safe("dmdnet"), AutoPilot's license_flags (so allow_non_commercial: false could not block a DMDNet plan), and the model-browser filter all treated DMDNet as commercial-safe. Fixed by license_spdx="CC-BY-NC-SA-4.0" + non_commercial=True.
• Removed ~627 lines of inlined upstream architecture from face_dmdnet.py. That code was compiled into the shipped EXE, which is a redistribution problem no runtime gate can fix (NonCommercial, ShareAlike, and — until now — no attribution entry at all).
• DMDNet is now user-installed and disabled by default. ATR bundles no DMDNet code and no weights and never downloads either. To use it for non-commercial work: clone the upstream repo, fetch DMDNet.pth, set dmdnet_dir (or ATR_DMDNET_DIR), and set ATR_ENABLE_DMDNET=1.
• Removed from commercial feature and tier tables. DMDNet is no longer presented as a capability of the paid product.
• Migration: users who had DMDNet working now fall back to GFPGAN for matched reference faces until they install the upstream checkout. Their existing dmdnet.pth stays valid — the official checkpoint is a bare state_dict, so the architecture must come from the checkout.
• Files: ai_models/engines/face_dmdnet.py, ai_models/models/registry.yaml, core/processor.py, core/planner/registries/nodes.yaml, gui/pages/reference_library_page.py, licensing/MODEL_LICENSES.md, licensing/THIRD_PARTY_LICENSES.html, docs/commercial/README.html, docs/commercial/RELEASE_NOTES.md
• Design doc: docs/design/DMDNET_LICENSING.md
• Still open: written commercial authorization from the upstream authors.

Full-Frame Stabilizer - Temporal Donor Search Radius 5 -> 15

• Full-Frame AI Stabilize now searches 15 neighbouring frames for real border content instead of 5. At 5 the mode was not clean — 23 frames of the validation clip still carried replicated edge pixels, at 9.99% mean crop. The radius is a CEILING, not a fixed cost: the fill stops walking outward the moment the border is covered, so easy footage still finishes at distance 1-2 and pays nothing.
• Controlled timing, 3 reps on real DV (900 frames, 60p, Balanced, 12% budget), medians — crop and over-budget figures were bit-identical across every rep:

• +16% wall time to make the mode clean and hand back ~3.9% of frame. The two full-frame modes now differ by how much frame they save rather than by whether the output is honest: Full-Frame AI Stabilize 6.1% crop at 295 s, Full-Frame AI + Border Rebuild 3.8% at 377 s.
• The 5 was stale rather than tuned: it predates the crop budget, when a wider search bought little. With the budget behind it every extra donor directly buys back frame area that would otherwise be cropped.

Full-Frame Stabilizer - Border Artifact Fixes

Both full-frame border policies produced visible edge artifacts on real DV footage (720x480 BFF, QTGMC bob to 60fps, Balanced), on runs whose neural path succeeded completely — so neither was a degraded-path symptom.

• Curved seam under roll (Full-Frame AI + Border Rebuild). Donor content was mapped into the frame by translation alone, with rotation explicitly dropped. Across the whole-window donor pool the atlas policy uses, that dropped rotation bent straight architectural lines into a curve where synthesized border met real frame. Donors are now mapped by the exact composed affine (correction_i . D(P_i) . D(P_j)^-1), which also warps the ORIGINAL source frame rather than an already-resampled render, removing a resampling generation.
• Horizontal smearing where no donor exists (Full-Frame AI Stabilize). The renderer kept BORDER_REPLICATE, stretching the outermost column outward — measured at 8.8 mean / 40 peak replicated columns (5.5% of frame width) against a source with none. Added a crop/zoom budget: a geometry-only planning pass finds the pixels no temporal donor can cover and the renderer zooms just enough to push them out of frame, rate-limited across each continuous path run so the zoom never pumps or steps at a window boundary. Only affected frames pay any crop.
• Added Restore → Stabilization → Max border crop (Off / 6% / 12% / 20%, default 12%) for the full-frame AI modes. Off restores the previous behavior exactly, edge artifacts included. Disabled for Gaussian, which renders its own borders.
• Stabilization reports and the job log now carry the crop outcome, including frames_over_budget — frames whose artifacts the budget could not cover and which therefore still ship replicated edges. With the budget off the counts are marked unmeasured rather than reported as zero.
• Classic fallback windows now honour the budget too. A window the neural path refuses renders through classic_2d, which defaulted to the same full-frame + BORDER_REPLICATE policy — and unlike the LDI path it has no border fill behind it, so that smear was final. On the validation clip those windows carried mean 6.0 / peak 11 replicated lines that the LDI-side crop budget never touched. Note this is the classic_2d fallback INSIDE the full-frame engine, not the shipping crop-based presets in core/stabilizer.py, which were never affected.
• Added replicated-edge-column and straight-line-continuity regression tests, plus quality_metrics.replicated_edge_extent(), the detector that found the defect.
• Validated on real DV graduation footage (720x480 BFF, QTGMC Very Slow bob to 60p, 900 frames, Balanced; 27 LDI / 0 degraded / 2 classic-fallback windows):
• Genuine replicated lines per frame, whole clip: **mean 2.94 / peak 24 -> 0.000 / 0** with Full-Frame AI + Border Rebuild at the 12% default — cleaner than the source itself (0.006 / 1).
• Border reconstruction accuracy against ground truth (real plate, synthetic camera with +/-3.5 deg roll, so the lost border is recoverable and scoreable): MAE 14.34 -> 0.99, PSNR 19.78 -> 42.48 dB, a 93% error reduction — the direct measure of the seam-geometry fix.
• Atlas needs materially less crop than temporal for a better result (mean 3.8% vs 10.0%, 32 vs 83 over-budget frames): the wider donor pool means less frame sacrificed, which is what the donor-aware planner is for.
• Cut border-fill planning cost from ~300 ms to ~15 ms per frame at DV resolution by testing only surviving border pixels and skipping donors that map to within half a pixel of one already tried.

Professional GUI - ProPainter Setup

• Added Settings → Default Paths → ProPainter with a read-only configured path, readiness summary, and Configure action that opens the existing guided setup/test assistant.
• Added nested-install detection for the standard C:\ProPainter\ProPainter layout and immediate propainter_path persistence through the shared settings manager.
• Wired the Professional processing service to pass the latest configured path into each job's VideoProcessor instead of silently constructing ProPainter without it.

Full-Frame AI Stabilizer - Run 5 Model

• Promoted the calibrated Run 5 feed-forward predictor as model v1.1: blind-holdout mask IoU improved from 0.1694 to 0.2027, depth error improved from 0.2069 to 0.1986, and the CUDA end-to-end stabilization gate passed.
• Versioned the calibrated dynamic-mask threshold (0.7) in checkpoint and ONNX metadata so PyTorch and ONNX runtimes apply identical postprocessing.
• Updated the guided Model Manager import to require the pinned v1.1 artifact at fullframe_stabilizer/1.1/predictor.onnx; v1.0 remains on disk as rollback material but is no longer accepted as the current model.

Full-Frame Stabilizer - Phase 5 Product Surface

• Added Full-Frame AI + Border Rebuild, which uses the trained predictor and LDI renderer with a full-scene-window temporal atlas for exposed-edge reconstruction.
• Added Tape-Aware Stabilize, which bridges isolated bad tape frames identified by adjacent motion resets while preserving real scene cuts and longer damage runs.
• Added Fast Preview, Balanced, Pro Full Frame, and Labs Gaussian operating modes with bounded scene windows and 720p/1080p/full-resolution analysis policies; output remains at source resolution.
• Wired new modes through Restore settings, preset restoration, processing options, runtime routing, missing-model UI guidance, and headless model preflight.
• Added a Draft 2020-12 JSON Schema for classic, LDI, and gsplat stabilization reports and normalized classic report fields across success, give-up, and empty-input paths.
• Hardened mixed-quality footage handling with frame-weighted consistency telemetry, scene-cut-aware honesty gating, uniform LDI re-rendering after Gaussian degradation, deinterlace-first routing tests, and an explicit completion warning when stabilization is safely skipped.

Security - CVE-2026-8461 (FFmpeg PixelSmash / MagicYUV)

• Added centralized FFmpeg resolver and security gate (core/ffmpeg_security.py): ATR now prefers the bundled, vetted FFmpeg (runtime/ffmpeg/bin) and treats any FFmpeg below 8.1.2 as unsafe for decoding MagicYUV media (heap out-of-bounds write).
• All decode/preview/analysis paths (core/processor.py, core/preview_generator.py, core/auto_analyzer.py), the CLI (plan render-variants, new exit code 7 with structured FFMPEG_SECURITY_BLOCK JSON error), and the MCP atr_render_preview_variants tool now run a MagicYUV preflight and refuse to silently use an unsafe FFmpeg.
• Settings page gained an FFmpeg status panel, a "Recheck FFmpeg" action, and an opt-in "Use custom FFmpeg" toggle (off by default).
• Startup now logs the resolved FFmpeg path/version/source and warns if the bundled binary fails integrity checks.
• Build pipeline records the bundled FFmpeg version + SHA256 into build_scripts/ffmpeg_manifest.json via build_scripts/record_ffmpeg_manifest.py; the installer carries a security release note.

Model Manager - 1-Click Installs

• Added 1-click Install for pip-based VapourSynth plugin models (BasicVSR++, SwinIR, RIFE): new PipPluginInstallWorker runs pip install <pkg> + python -m <pkg> in the system Python with streaming progress, cancel, and timeout handling.
• Made BiT++ Real-World and BiT++ Synthetic 1-click: registry now points at the direct Google Drive checkpoint files (latest.ckpt saved as bit_standard.pth / bit_light.pth) instead of the folder link.
• Corrected BiT/BiT++ licensing from Apache-2.0 to the upstream MIT license, added the required copyright/license notice to installer payloads, and documented that upstream does not publish a separate checkpoint-specific license statement; ATR continues to download checkpoints externally rather than bundling them.
• Made Video Swin-UNet (Tape-Specialized) 1-click: downloads best.ckpt from the authors' Google Drive and auto-converts it to ONNX via a new registry post_install hook (download_target + _run_post_install in ModelManager).
• Fixed FLAVR registry file entries (filename + path split form was ignored by ModelManager), so the existing Google Drive 1-click downloads now land at flavr/FLAVR_{2,4,8}x.pth and install status is detected correctly; FLAVR ONNX entries now point at the real onnx_models/flavr/ export paths.
• Model cards now always preserve the manual path: a "Manual Install" button (opening the step-by-step guide) is shown next to Install/Retry for every auto-downloadable model with guidance, and the Setup Guide remains available after installation.
• Models that stay manual-only and why: CodeFormer (NTU S-Lab non-commercial license requires user install), DarkIR Large (authors' OneDrive only), Stable Video Diffusion (complex diffusers setup), DeOldify (must install into VapourSynth's bundled Python), InsightFace (self-managed auto-download), FLAVR ONNX (local export), MiniCPM (scaffold).

Visual QA Completion

• Added Visual QA planner arbitration and manifest embedding for plan promote --use-visual-qa-hints and plan create-job --with-visual-qa, including persisted visual_qa payloads in restore job manifests.
• Added Visual QA influence mode wiring (off / note / guidance) from Restore UI through processing options and planner integration.
• Added per-job and aggregate batch Visual QA report generation (qa_report.json/qa_report.html, qa_aggregate.json/qa_aggregate.html) with runtime metadata propagation to output sidecars.
• Added Visual QA model acquisition workflow in Diagnostics (download, install-from-folder, progress, cancel, license acceptance persistence).
• Added Visual QA marketing explain mode via atr visual explain --marketing and new prompt template core/visual_qa/prompts/v1/explain_marketing.j2.
• Added Visual QA sidecar client backends and sidecar launcher scaffolding for transformers/llama.cpp integration paths.
• Added Visual QA sampling improvements (scene-aware, defect-triggered, face-aware composition), evidence thumbnail generation, and clickable evidence seek integration in Scene Editor and Compare Presets ranking explanation.
• Added new unit/plugin coverage for arbitration, aggregate reporting, model manager install/download behavior, marketing explain output, and planner Visual QA integration paths.
• Added Addendum A runtime bootstrap flow for sidecar Visual QA venv provisioning and transformers capability probing with resolved-version persistence.
• Added Addendum A hardware preflight, MiniCPM chat-path backend updates, bounded JSON retry extraction, warmup + idle-eviction lifecycle, download progress/cancel/resume handling, transformers self-test gates, and diagnostics live-runtime status actions.

Visual QA - Packet 3

• Added atr visual install CLI verb with fake/folder installs, status, uninstall/purge, and GUI-required guard for licensed modes.
• Wired Diagnostics "Manage in Plugins page" to a concrete navigation contract that opens Add-ons, switches to Community Plugins, and highlights the featured Visual QA card.
• Added constrained suite-crash triage workflow and quarantine guardrails for non-slow/non-gpu test execution.

Visual QA - Packet 4

• Rewrote the transformers in-process backend to use native transformers multimodal generation (AutoProcessor + apply_chat_template + AutoModelFor* + generate) and removed .chat() usage.
• Added runtime strategy bootstrap enforcement during folder/download installs so transformers installs fail fast when runtime bootstrapping is unavailable instead of writing a false-installed state.

DaVinci Resolve Connector

• Added core/resolve_bridge/ library: discovery, connection, MediaPool, markers, render, job contract.
• Added tools/atr_resolve_bridge.py helper EXE (atr-resolve-bridge.exe) with ping, ingest, and status subcommands (JSON protocol on stdout).
• Added resolve_scripts/atr/ Resolve-hosted scripts: send_to_atr.py (Workspace > Scripts entry point), _dialog.py (Tk preset picker), _runner.py (atr-cli subprocess driver), _state.py (marker state I/O).
• Added gui/widgets/resolve_status_card.py: colour-coded status pill, Test Connection, Install Resolve Scripts, and Open Scripts Folder actions.
• Added "Send to DaVinci Resolve…" button to the Post-Process page External Tools card; runs via ResolveIngestWorker(QThread) to avoid UI blocking.
• Added resolve.* settings defaults in SettingsManager (api/lib path overrides, bin template, marker/timeline preferences).
• Added build_scripts/atr_resolve_bridge_v6.0.spec for standalone PyInstaller packaging of the bridge helper.
• Added docs/design/RESOLVE_CONNECTOR_v6.0.md design notes.
• Requires DaVinci Resolve Studio edition; Free edition is detected and shows a clear error rather than silently failing.

ATR AutoPilot Headless Batch & Signed Tokens (Phase 5 Preview)

• Added headless serial batch orchestration via orchestrate batch <manifest> for unattended multi-source runs.
• Added signed token file workflows with orchestrate token mint and orchestrate token verify.
• Added per-entry batch progress events and batch summary reporting with deterministic reason codes.
• Added Phase 5 orchestration tests covering manifest validation, serial execution, policy blocks, stop-on-failure, and signed token handling.

ATR AutoPilot External Agent Adapter (Phase 4 Preview)

• Added AutoPilot external-agent adapter with a tool-allowlisted orchestration runner and full runlog trail.
• Added provider support for scripted (offline deterministic) and optional openai_agents (env-key gated) modes.
• Added hard safety caps for external-agent runs (max_steps, max_wallclock_s) plus cancellation and failure handling.
• Added AutoPilot GUI controls for Use external agent, provider, model, and API key environment variable name.

ATR AutoPilot Policy Engine & Editor (Phase 3 Preview)

• Added AutoPilot policy engine with runtime/VRAM/license gates enforced before approval token mint.
• Added deterministic proposal estimation for est_runtime_seconds and est_vram_mb.
• Added canonical policy file policies/auto_run.yaml and new CLI commands orchestrate policy show|validate.
• Added optional --override-policy on orchestrate approve with audit trail stamping.
• Added a new top-level Policy GUI page for editing and validating policy thresholds.

ATR AutoPilot GUI Approval Surface (Phase 2 Preview)

• Added AutoPilot GUI approval surface (Phase 2 Preview).
• Added a new AutoPilot navigation page that runs orchestrate plan in a background worker, renders proposal/policy/preview outputs, and supports Approve & Execute.
• Added GUI cancellation handling for active AutoPilot subprocesses with clean UI recovery.
• Added GUI test coverage for plan/approve/execute flow and cancellation handling.

ATR AutoPilot Orchestration CLI (Phase 1 Preview)

• Added new top-level CLI verb orchestrate with subcommands plan, approve, execute, and run for approval-gated restoration orchestration.
• orchestrate plan now runs planner stages through existing CLI verbs (profile, candidates, validate, compile, render-variants, compare) and writes proposal.json plus orchestration_log.jsonl.
• orchestrate approve validates/mints signed approval tokens and persists approval.json.
• orchestrate execute enforces approval, then chains promote -> create-job -> job run using existing CLI operations only, and writes restoration_report.json.
• Added core orchestration primitives under core/orchestration/ and initial pytest coverage under tests/orchestration/.

Scene Editor Subtitle Export & Transcription Integration

• Subtitle export modes (NEW): Scene Editor export card now includes 4-option Subtitles combo: None (default), Sidecar transcript (SRT), Burn-in subtitles, Sidecar + Burn-in. Matches the full transcription workflow from Transcription page.
• Auto-transcription gate (NEW): When exporting from Scene Editor with subtitle modes requiring transcription, a modal QProgressDialog prompts the user to transcribe first if not already cached. Uses the same TranscriptionWorker from gui/pages/transcription_page.py for consistency.
• Per-scene subtitle clipping (NEW): Transcription segments are automatically clipped to the export trim window and timestamps are shifted to start at 0, ensuring subtitles align perfectly with the rendered scene.
• Post-processing pipeline (NEW): After rendering, subtitle post-processing writes sidecar SRT files and/or invokes core.transcription.burn_in.burn_in_subtitles() to re-encode with burned captions.
• Merged-mode sidecar (NEW): When rendering multiple scenes as a batch, a final merged SRT is written alongside the concatenated output (if sidecar mode requested).
• MCP & CLI exposure (NEW): Four new CLI verbs under scene subcommand: write-srt (extract SRT from transcription JSON), burn-in (FFmpeg burn SRT), render (single scene with optional subs), transcribe-and-burn (end-to-end). Wrapped in separate MCP server atr_scene_mcp.py with 4 tools: atr_scene_write_srt, atr_scene_burn_in, atr_scene_render, atr_scene_transcribe_burn.
• Files: gui/pages/scene_editor_page.py, gui/pages/transcription_page.py, gui/main_window_fluent.py, cli/commands/scene.py, mcp_server/atr_scene_mcp.py, core/transcription/burn_in.py, core/transcription/result.py

Temporal Shadow Recovery (TSR)

• New deterministic restoration engine: Temporal Shadow Recovery adds motion-aware shadow detail recovery for underexposed tape footage without requiring model downloads.
• Restore UI card: Added a Temporal Shadow Recovery card after Denoise with presets (Off / Light / Medium / Heavy / Custom), strength, temporal window, highlight protection, chroma protection, flicker guard, denoise coordination, and expert luma controls.
• Processing pipeline integration: TSR runs as a direct Python/FFmpeg pre-filter before VapourSynth script generation, then feeds a lossless FFV1 intermediate into the normal restoration pipeline while final audio remains mapped from the original source.
• Preview parity: Preview generation runs TSR in preview mode before VapourSynth so before/after samples reflect the enabled settings.
• Engine diagnostics and preflight: Registered TSR through the EngineBase system and device scheduler/preflight model map with no external model assets required.
• Auto-Analyzer support: Underexposed footage can now receive TSR recommendations with an Analysis-page apply button for recommended TSR settings.
• Tests: Added unit coverage for TSR masks, highlight protection, gain stabilization, and luma reconstruction behavior.
• Files: core/tsr/*, ai_models/engines/tsr_engine.py, core/processor.py, core/preview_generator.py, core/options_builder.py, core/auto_analyzer.py, gui/widgets/restore_tab_simple.py, gui/pages/analysis_page.py, gui/main_window_fluent.py, tests/unit/test_tsr_phase1.py

ACE-Step 1.5 Music Source Integration (Experimental, Local AI)

• New optional music source: ACE-Step 1.5 local generation provider added to ONLINE_SOURCES in core/music_engine.py
• Guarded availability: ACE-Step source is only registered when acestep package is installed; no dead source appears in UI when dependency is missing
• Local generation backend: AceStepMusicSource wraps ACE-Step Python API (GenerationParams, GenerationConfig, generate_music) and returns generated files as MusicTrack entries
• Model path convention: ACE-Step checkpoints are routed to %LOCALAPPDATA%\Advanced_Tape_Restorer\acestep_models via ACESTEP_CHECKPOINTS_DIR
• Music Library UI wiring: source-aware behavior for ACE-Step with dedicated generation options card (lyrics, duration, BPM, key, instrumental, reasoning, inference steps, batch size, output format)
• API key gating fixed: API-key controls now depend on source capability (requires_api_key), so local ACE-Step generation runs without key prompts
• Settings persistence: Added music_acestep_* keys in MusicLibraryPage settings snapshot for ACE-Step generation options
• Files: core/music_engine.py, gui/pages/music_library_page.py

DMDNet ONNX Backend Archived

• DMDNet ONNX removed from active backends — Architecture uses three ONNX-incompatible patterns: .cpu().numpy() on location tensors mid-forward, data-dependent tensor slicing in roi_align_self(), and data-dependent paste-back in reconstruct(). These prevent torch.onnx.export().
• Code archived in-place — All ONNX inference methods preserved as commented _ARCHIVED_ONNX block in face_dmdnet.py with restoration instructions and notes on possible future solutions (hardcoded locs, opset improvements, community .onnx files).
• Metadata updated — DMDNetEngine.metadata().backends now (PYTORCH,) only.
• Asset service updated — Removed dmdnet.onnx from fallback ONNX lookup dict.
• PyTorch path unaffected — DMDNet face restoration continues to work normally via PyTorch.
• Files: ai_models/engines/face_dmdnet.py, ai_models/asset_service.py

LavaSR ONNX Model Export & All-Modes Benchmark

• ATR ONNX model export — scripts/export_lavasr_onnx.py exports 3 ONNX models from PyTorch LavaSR checkpoint (backbone 49.4MB, spec_head 4.0MB, denoiser 1.1MB)
• Static denoiser shapes — Removed dynamic batch axis from denoiser export, fixing 45% DirectML slowdown vs external models
• ONNX runner refactored — lavasr_onnx_runner.py now loads ATR models by default, falls back to Topping1 if missing
• All-modes benchmark — scripts/benchmark_all_modes.py compares 6 inference modes: ONNX ATR+CPU, ATR+DirectML, Topping1+CPU, Topping1+DirectML, PyTorch CPU eager, TorchScript JIT CPU
• Result: ONNX ATR + DirectML is fastest — 3.2ms neural total (4.3x faster than PyTorch CPU, 3.5x faster than ONNX CPU)
• All modes numerically equivalent — Max diff < 0.0002, PSNR > 102dB, correlation 1.000000 across all modes
• Benchmark documentation — Full results in docs/LAVASR_INFERENCE_BENCHMARK.md
• Files: scripts/export_lavasr_onnx.py (modified), scripts/benchmark_all_modes.py (new), scripts/compare_onnx_models.py (new), ai_models/engines/lavasr_onnx_runner.py (modified), docs/LAVASR_INFERENCE_BENCHMARK.md (new)

Dependency Version Registry & Diagnostics Improvements

• Dependency version registry — New core/dependency_registry.py validates package versions at startup (torch, torchaudio, PySide6, numpy, opencv, etc.)
• Sync group validation — Detects torch↔torchaudio major.minor+CUDA tag mismatches automatically
• Startup dependency check — main_window_fluent.py shows QMessageBox with detailed version-mismatch report on launch (500ms timer, non-blocking)
• Diagnostics incremental scanning — Engine cards appear immediately with "🔵 Scanning..." status, then update in-place as each engine check completes
• First-run fix — _prepopulate_scanning_cards() now calls get_all_engine_metadata() to trigger lazy engine loading on first page visit
• Fork bomb fix — Removed accidental DiagnosticsWorker spawn inside _on_engine_checked() that caused exponential worker creation (20 engines → 20 new scans → CPU spike)
• base.py probe caching reverted — Reverted failed system-python probe caching optimization back to v5.0 original (caching caused deoldify timeout on py-3.13 instead of falling through to py-3.12)
• Files: core/dependency_registry.py (new), gui/main_window_fluent.py (extended), gui/pages/diagnostics_page.py (extended), ai_models/engines/base.py (reverted)

Per-Frame Temporal Quality Metrics

• Per-frame VMAF/PSNR/SSIM capture — QualityMetrics dataclass extended with vmaf_per_frame, psnr_per_frame, ssim_per_frame, reference_fps fields
• VMAF per-frame parsing — _compute_vmaf() now extracts frame-level scores from libvmaf JSON frames[] array
• PSNR/SSIM per-frame retention — _compute_psnr() and _compute_ssim() return per-frame lists alongside mean values
• Temporal quality graph — New matplotlib-based chart card on Analysis page with multi-metric overlay (VMAF blue, PSNR green normalized, SSIM orange x100)
• CSV export — Export per-frame metrics as CSV with frame number, timecode, VMAF, PSNR, SSIM columns
• PNG export — Export temporal graph as high-resolution (150 DPI) PNG image
• Frame/Timecode toggle — X-axis mode switch between frame numbers and timecode (seconds)
• Graceful fallback — matplotlib import guarded; notice shown if not installed
• Files: core/quality_metrics.py (extended), gui/pages/analysis_page.py (extended ~1100 lines)

Track A Core Reliability (All 4 Tiers)

• Tier 1: Colorspace injection, Source Type selector
• Tier 2: Engine loading race fix, error surfacing, preflight coverage
• Tier 3: Non-commercial license warning, user-friendly import errors
• Tier 4: Dead code removal (lazy_imports.py, async_io.py), spec cleanup
• Signal-storm fix: blockSignals guards in apply_settings()

Planning & Documentation

• Updated docs/planning/v6.0.md with Track A/C audit results
• Updated docs/planning/resolved.md with 15+ newly verified items
• Updated docs/design/IN_OUT_MARKERS_DESIGN.md status to FULLY IMPLEMENTED

Initial Development Space

• Created v6.0 development space from v5.0.10 baseline
• Updated all version references to 6.0.0
• Renamed build files (spec, ISS, PS1, BAT) to v6.0 naming
• Fresh venv with Python 3.12, PyTorch 2.9.1+cu128, PySide6 6.10.0
• 144 packages installed including full AI/ML stack

---

Music Library Page (✅ COMPLETE — Opus APPROVED)

• Jamendo integration — Real royalty-free music backend via Jamendo API v3.0 (client_id authentication, CC-licensed tracks)
• ElevenLabs AI Music — Text-to-music generation via ElevenLabs music.compose() API (model: music_v1, MP3 44.1kHz 128kbps output)
• Local library scanning — Import music from local folders with metadata extraction via ffprobe (title, artist, album, genre, duration, sample rate)
• Download-before-add workflow — Online tracks are downloaded locally before being added to the restoration project
• Preview streaming — Stream track previews directly from Jamendo (96kbps MP3)
• License metadata — Each track carries preview_url, license_url, and Creative Commons license hints
• Source-aware UI — ElevenLabs source shows "Generate" button and prompt placeholder; Jamendo shows "Search" button
• NAS snapshot pruning — _SKIP_DIRS set (13 NAS system directory names) prevents duplicate tracks from snapshot directories
• Deferred initialization — QTimer.singleShot for library scan; _normalize_path() replaces Path.resolve() to eliminate NAS network I/O on startup
• Mutagen notice removed — ffprobe handles all needed metadata; mutagen is not required
• Files: core/music_engine.py (new, ~530 lines), gui/pages/music_library_page.py (rewritten, ~1070 lines)

Dead Code Cleanup

• Deleted: core/parallel_processor.py, core/frame_cache.py (zero imports in codebase)
• Removed: 4 Stream-DiffVSR commented-out references in core/vapoursynth_engine.py

Documentation Updates

• ARCHITECTURE.md — Rewritten from v2.0 to v5.0 content
• FEATURES.md — Added Music Library section (Jamendo + ElevenLabs), updated version to v5.0.10
• CLAUDE.md — Added Music Library section, updated version to v5.0.10
• Reconciliation audit — 21 audit items verified against codebase: 12 resolved, 3 should-fix, 6 future/P2
• docs/planning/v5.0.md — Updated with reconciliation results and success criteria check-off
• docs/audits/audit-2026-03-25.md — Reconciliation appendix added

Dependency Changes

• Added: elevenlabs>=2.0.0 to requirements_pip.txt (guarded import — optional)

Code Quality

• Deprecated datetime.utcnow() replaced — All 4 call sites in core/music_engine.py now use datetime.now(timezone.utc) (Python 3.12+ deprecation fix)

---

Timeline In/Out Markers (✅ COMPLETE)

• In/Out range selection — Set start and end markers on the timeline to process only a subclip
• Keyboard shortcuts — I sets In marker, O sets Out marker at current playhead position
• Focus-aware shortcut guard — I/O keys are suppressed when QLineEdit, QSpinBox, QComboBox, or other text input widgets have focus
• Draggable handles — Blue triangle handles on the timeline ruler can be dragged to adjust In/Out range
• Independent handle rendering — Single markers render individually (triangle visible immediately); shaded blue region appears only when both are set
• Right-click context menu — "Set In Here", "Set Out Here", "Clear In/Out" from any timeline position
• Audio trim sync — FFmpeg audio input now receives -ss and -to flags to trim audio to match the video range. Previously, only video was trimmed (via VapourSynth core.std.Trim), causing audio to continue past the Out marker.
• VapourSynth trim — core.std.Trim(video, first=N, last=M) applied as first filter stage after source loading
• Minimum gap enforcement — In and Out markers maintain at least 1 second of separation
• Export injection — Trim range injected into both standard export and quick export paths
• Scrollbar overlay fix — Synthetic QResizeEvent workaround applied to PostProcessPage and DiagnosticsPage to fix QFluentWidgets scrollbar disappearance after page navigation
• LazyPageHost resize — resizeEvent propagation added to refresh scroll geometry on window resize/maximize
• Files: gui/widgets/timeline_widget.py, gui/widgets/bottom_strip.py, gui/main_window_fluent.py, core/options_builder.py, core/vapoursynth_engine.py, core/processor.py, core/ffmpeg_encoder.py, gui/pages/postprocess_page.py, gui/pages/diagnostics_page.py
• Opus-review: ✅ APPROVED (2 issues caught and resolved: shortcut focus guard, independent handle rendering)

---

Plugin System — pre_filter Hook & Drag-to-Reorder (✅ COMPLETE)

• pre_filter pipeline hook — Plugins declaring pipeline_hooks: ["pre_filter"] now run before VapourSynth restoration (Step 4b in processor pipeline), using the same separate-pass approach as post_filter
• filter_frame support for pre_filter — plugin_manager.py::run_pipeline_plugin() extended to support per-frame numpy processing for both pre_filter and post_filter hooks
• Drag-to-reorder plugin chain — Pipeline Plugins card now displays reorderable rows with ▲/▼ buttons per plugin per hook stage; visual order persists in settings and drives execution order
• Pre-Filter UI section — New "Pre-Filter Plugins (before VapourSynth restore)" section in Pipeline Plugins card, alongside existing Post-Filter and Post-Encode sections
• Non-destructive layout rebuild — _detach_layout_widgets() safely reorders rows without deleteLater() crash (caught in Opus review)
• Settings persistence — pipeline_plugins dict extended with pre_filter key; order values serialized from visual layout order and restored on apply_settings
• Files: core/processor.py, core/plugin_manager.py, gui/widgets/control_tabs.py
• Opus-review: ✅ APPROVED (1 MUST-FIX caught and resolved: deleteLater crash on reorder)

---

Email Notification System (✅ COMPLETE)

• SMTP email notifications — core/email_notifier.py sends batch completion and per-job error alerts via configurable SMTP (Gmail, Outlook, custom servers)
• Batch integration — batch_processor.py emits batch_completed / job_error signals wired to email dispatch
• Async sending — EmailWorkerThread (QThread) in main_window.py prevents UI freeze during SMTP operations
• Test email — EmailTestThread validates SMTP settings with a one-click test button
• Settings UI — Email card in Settings page: SMTP server, port, username, password, recipient, TLS toggle, enable checkbox, test button
• closeEvent guard — Both main_window.py and main_window_fluent.py check for in-progress batch before allowing window close

Settings Page — Collapsible Cards (✅ COMPLETE)

• CollapsibleCardWidget migration — All 5 settings cards (Appearance, Paths, Performance, Email Notifications, Advanced) converted from CardWidget to animated CollapsibleCardWidget
• QScrollArea wrapper — Settings page wrapped in scrollable container for smaller displays
• Default expand states — Appearance/Paths/Performance expanded by default; Email/Advanced collapsed
• Email grid layout fix — Fixed email settings alignment on card layout

Batch Scheduling & Per-Job ETA (✅ COMPLETE)

• Scheduled start — Batch jobs can be scheduled for delayed start (date/time picker in batch dialog)
• Per-job ETA — Real-time ETA display per job in batch queue based on frame count and processing speed

Roadmap: SeedVR2 Temporal Consistency Enhancements

• Added to ROADMAP_v4.0.md — Two planned enhancements under SeedVR2 section:
• ☑ SeedVR2 chunk overlap blending (cosine-blend overlap regions between chunks)
• ☐ RIFE-assisted post-upscale temporal smoothing (use existing RIFE engine on chunk boundaries)

Documentation Updates

• ONNX conversion status — Closed GFPGAN and DeOldify ONNX items in docs/planning/v5.0.md as not beneficial (see ONNX_MODEL_STATUS.md)
• Plugin e2e tests — Minor test updates in test_plugin_e2e.py

---

Plugin System Phase 3 — Pipeline Integration (✅ COMPLETE)

• Pipeline hook points — post_filter (runs after VapourSynth/FFmpeg encode, before NVIDIA VFX) and post_encode (runs after all processing including audio enhancement)
• filter_frame() contract — Per-frame numpy processing: filter_frame(frame: ndarray, frame_index: int, total_frames: int, **kwargs) -> ndarray with shape/dtype validation
• Frame-wise execution — FFmpeg decode (rawvideo bgr24 pipe) → filter_frame per frame → FFmpeg encode with audio copy
• Pipeline Plugins UI — CollapsibleCardWidget in AI Models tab with CheckBox toggles per discovered pipeline plugin, Refresh button, info label for empty state
• Processor integration — Step 9a (post_filter) and Step 12 (post_encode) in VideoProcessor pipeline with skip-on-failure, temp-file swap, cancel propagation
• Options passthrough — pipeline_plugins dict flows from AIModelsTab → options_builder → VideoProcessor
• End-to-end tested — 20/20 tests passed (discovery, post_filter filter_frame, post_encode process fallback, cancellation, processor integration)
• Files: core/plugin_manager.py, core/processor.py, core/options_builder.py, gui/widgets/control_tabs.py, docs/PLUGIN_DEVELOPMENT_GUIDE.md, docs/PLUGIN_SYSTEM_ROADMAP.md
• Opus-review: ✅ APPROVED

---

Plugin System Phase 2 — Settings & Progress (✅ COMPLETE)

• Per-plugin settings UI — Dynamically generated from settings_schema() declarations: sliders with live value labels, checkboxes, dropdowns, text inputs
• Progress reporting — Real-time progress bar via progress_callback parameter during plugin execution
• Cancel support — Cancel in-flight plugin operations via threading.Event
• Settings persistence — Per-plugin settings saved to and restored from restoration_settings.json
• Files: gui/pages/plugins_page.py, core/plugin_manager.py, gui/main_window_fluent.py
• Opus-review: ✅ APPROVED

Personal Reference Pipeline — Phase 2 DMDNet Hardening (✅ COMPLETE)

• DMDNet checkpoint validation gate — face_dmdnet.py now verifies loaded weights match expected architecture; incompatible checkpoints raise RuntimeError with clear message instead of silent failure
• InsightFace import guard — gfpgan_checkpoint_processor.py sets _face_app = False sentinel when InsightFace unavailable; per-frame processing skips gracefully with warning
• Registry installation steps — registry.yaml DMDNet entry now includes specialty.installation.steps with guided setup instructions
• Files: ai_models/engines/face_dmdnet.py, core/gfpgan_checkpoint_processor.py, ai_models/models/registry.yaml
• Opus-review: ✅ APPROVED

Personal Reference Pipeline — Phase 3 Speaker Matching (✅ COMPLETE)

• Speaker embedding — Resemblyzer-based 256-d d-vector extraction from reference audio clips
• Speaker diarization — Identify who is speaking in each segment of restored audio
• Resemblyzer import guard — _get_encoder() wraps import in try/except ImportError for graceful degradation
• blockSignals guard — reference_library_page.py wraps combo restoration in blockSignals to prevent signal storms
• Files: core/speaker_matcher.py, gui/pages/reference_library_page.py
• Opus-review: ✅ APPROVED

SeedVR2 Model Download UI (✅ COMPLETE)

• Setup Guide button — Models page shows "Setup Guide" for auto-downloadable models that have specialty.installation.steps (visible in both NOT_INSTALLED and INSTALLED states)
• 6-step installation guide — registry.yaml SeedVR2 entry includes guided setup: clone repo, place alongside models, install deps, click Install, GPU requirements, first-run note
• SeedVR repo dependency check — seedvr2_engine.py::check_dependencies() now calls _resolve_seedvr_repo() and surfaces missing-repo error in diagnostics
• Files: gui/pages/models_page.py, ai_models/models/registry.yaml, ai_models/engines/seedvr2_engine.py
• Opus-review: ✅ APPROVED

---

Documentation Audit & Consistency Pass

• Updated docs/planning/v5.0.md — Marked SeedVR2 DiT as ✅ SUBSTANTIALLY COMPLETE (was listed as TODO), Echoes Over Time as ✅ COMPLETE (was listed as TODO), Reference Pipeline phases 1 & 4 as ✅ COMPLETE with accurate status indicators
• Updated FEATURES.md — Added missing "AI Audio Enhancement" section (LavaSR, Echoes Over Time, Chain mode), fixed engine migration count from "11 of 13" to "13 of 13", added Restormer to AI Restoration list
• Fixed stale documentation — Removed references to deleted files (google_photos.py, amazon_photos.py), corrected audio processor description from "hardcoded LavaSR" to "3-way routing"
• No code changes — Documentation-only update to align docs with actual codebase state

---

Echoes Over Time — Second Audio Enhancement Engine (✅ COMPLETE)

• Echoes Over Time engine — ai_models/engines/audio_echoes.py — VoiceFixer-based speech restoration (mode=2 "train mode")
• Dry/wet mixing — Strength slider (0.0–1.0) blends original with VoiceFixer output to preserve non-speech content
• 3-way audio routing — core/audio_processor.py now routes by model selection: LavaSR / Echoes Over Time / Chain (LavaSR → Echoes)
• Chain mode — Two-stage enhancement: LavaSR broadband cleanup (16kHz→48kHz) then Echoes speech refinement
• Per-engine sample rates — Echoes extracts at 44.1kHz; LavaSR/Chain extracts at 16kHz
• Dependency checking — EchoesEngine declares torch, torchaudio, numpy, soundfile, voicefixer as dependencies
• Graceful degradation — Chain mode falls back to LavaSR output if Echoes dependencies missing
• Commit: cee42b8 (2026-03-17)

Face Reference Library — Cloud Provider Redesign

• Removed Google Photos API — Google OAuth app verification makes API unusable for non-verified apps (403 errors)
• Removed Amazon Photos API — Amazon Drive API deprecated since 2023, no programmatic access
• Removed rclone sync — Google Photos API restricts downloads to photos uploaded by the same third-party app
• New local-folder workflow — All 3 cloud providers (iCloud, Google, Amazon) now import via local folder scanning
• iCloud for Windows checkbox — Auto-detects system iCloud Photos sync folder, or user picks custom folder
• Google Photos — Guided export via Google Takeout with "How to Export" help button
• Amazon Photos — Guided export via Amazon Photos desktop app with "How to Export" help button
• 3 provider buttons — iCloud Photos, Google Photos, Amazon Photos with per-provider folder settings
• Help dialogs — Each provider has a "How to Export" button with step-by-step instructions and optional link to open the provider's export page
• No OAuth required — All cloud import is local-folder based, zero API credentials needed
• Deleted files: google_photos.py, amazon_photos.py, rclone_google.py
• New files: core/cloud_providers/__init__.py, core/cloud_providers/base.py, core/cloud_providers/icloud_photos.py

---

Roadmap Updates

• FLUX.2 Klein 4B (Apache 2.0) — Added to roadmap as primary generative backbone candidate
• Replaces FLUX.1 [schnell] compatibility test (Goal #16) — FLUX.2 Klein is newer, more capable, same license
• 4B distilled: ~0.3s inference, 8.4 GB VRAM; 4B Base: designed for LoRA fine-tuning, 9.2 GB VRAM
• Unblocks Genfocus deblurring LoRA integration (previously blocked by FLUX.1 [dev] non-commercial license)
• Added as alternative local generative backend in LTX Generative Repair v6.0 design brief
• Note: only 4B variants are Apache 2.0; 9B variants remain Non-Commercial

---

NVIDIA VFX SDK Integration (✅ COMPLETE)

• NVIDIA VFX AI Upscaling — TensorRT-accelerated super-resolution via nvvfx.VideoSuperRes
• Quality levels: Bicubic, Low, Medium, High, Ultra
• 2x and 4x upscaling with hardware-optimized inference
• NVIDIA VFX AI Denoising — Real-time video denoising
• Quality levels: Low, Medium, High, Ultra
• NVIDIA VFX AI Deblurring — Motion deblur for tape sources
• Quality levels: Low, Medium, High, Ultra
• Direct Python Processing Path — FFmpeg decode → CUDA tensor → nvvfx → FFmpeg encode
• Bypasses VapourSynth for VFX effects (runs entirely in-process)
• core/nvidia_vfx_processor.py — single-effect and chained multi-effect paths
• ai_models/engines/nvidia_vfx_engine.py — EngineBase wrapper
• Multi-Effect Chaining — Single decode/encode pass for combined denoise + deblur + upscale
• Intelligent effect ordering (denoise → deblur → upscale)
• Resolution tracking through chain (intermediate sizes computed per effect)
• 3 Independent UI Cards — Separate collapsible cards for upscale, denoise, deblur
• Hardware-gated: cards disabled with message when SDK not installed
• Independent enable toggles and quality dropdowns per effect
• Width Alignment Fix — NVIDIA VFX SDK requires 8-pixel width alignment
• Automatic reflect-padding to nearest multiple of 8
• Output cropped back to original width (zero quality loss)
• Zero overhead for already-aligned widths (720, 1920, 3840)
• SeedVR2 Improvements — VRAM gating, OOM recovery, progress reporting fixes

---

New Development Cycle

• Forked from v4.5.0 (commercial-release-1, commit 28358cb)
• Version bump to 5.0.0 for next major development phase
• See docs/planning/v5.0.md for development goals and roadmap

Planned Features (P0 — Must Ship)

• SeedVR2 Full DiT Model — production video super-resolution
• Echoes Over Time — second audio enhancement engine
• Plugin System Phase 2 — settings & progress UI
• Personal Reference Pipeline — identity-preserving restoration using user photos/audio

---

Plugin-Style AI Engine Architecture (Phases 1–6)

Phase 1 — Engine ABC + Dependency Checking (✅ COMPLETE)

• EngineBase abstract base class (ai_models/engines/base.py) with metadata(), apply(), check_dependencies()
• EngineMetadata frozen dataclass: category, backends, VRAM estimates, temporal window, license, scale factors, resolution limits
• DependencySpec: declarative dependency manifest (VapourSynth plugins, Python packages, external binaries, model files)
• _IMPORT_ERRORS dict captures engine import failures with full error messages (replaces silent None returns)
• _register_engine() supports both ABC subclasses and legacy duck-typed apply() functions
• DarkIR engine migrated as first ABC reference implementation

Phase 2 — Bulk Engine Migration (✅ COMPLETE — 13/13 engines on ABC)

• All 13 registered engines are on EngineBase ABC: DarkIR, BiT, RFDA, Video Swin-UNet, RealESRGAN, RIFE, BasicVSR++, SwinIR, DAIN, FILM, DeOldify, GFPGAN, VideoCleaner
• Each engine declares full EngineMetadata with backends, VRAM requirements, scale factors, and dependencies
• Backward-compatible: ENGINE_REGISTRY[name] callable interface unchanged
• ENGINE_METADATA and ENGINE_INSTANCES dicts populated for all ABC engines

Phase 3 — Self-Reported Capabilities (✅ COMPLETE)

• EngineMetadata.max_resolution — engines declare maximum supported input resolution
• EngineMetadata.scale_factors — supported upscale factors (e.g., (2, 4) for RealESRGAN)
• EngineMetadata.supports_tiling — tile-based inference capability flag
• EngineMetadata.needs_rgb_input — colorspace requirement for pipeline integration
• EngineMetadata.non_commercial — license constraint flag for UI gating

Phase 4 — Device Scheduler Integration (✅ COMPLETE)

• core/device_scheduler.py (~800 lines) — VRAM-aware per-model device assignment
• schedule_devices() reads ENGINE_METADATA for VRAM estimates and backend support
• preflight_vram_check() validates total VRAM budget before processing
• apply_schedule() injects per-model device and inference_mode into processing options
• Wired into processing_thread.py, processing_service.py, main_window_fluent.py, diagnostics_page.py

Phase 5 — Diagnostics GUI (✅ COMPLETE)

• gui/pages/diagnostics_page.py — Engine diagnostics page with Fluent UI cards
• Per-engine cards show: status (🟢 Ready / 🟡 Missing Deps / 🔴 Import Error), VRAM estimate, backends, ONNX availability, device assignment
• Summary bar: total engines, ready count, missing deps, import errors, ONNX available, CUDA/DirectML status, VRAM
• Filter: All / Ready Only / Problems Only
• Copy Support Report: generates markdown clipboard export with system info, GPU names, all engine details
• generate_support_report() standalone function for programmatic use

Phase 6 — Plugin Architecture Foundation (✅ COMPLETE)

• ai_models/engines/plugin_api.py — EnginePlugin(EngineBase) contract (API Level 1)
• AssetRequirement frozen dataclass: filename, engine_subdir, sha256, size_mb, optional, description
• SettingsField frozen dataclass: key, label, field_type, default, choices, min/max, advanced, description
• settings_schema(), asset_requirements(), runtime_adapter() extension points
• ai_models/engines/plugin_loader.py — Safe plugin discovery from ai_models/engines/*/plugin.py subdirectories
• Reuses _import_engine() and _register_engine() for consistent error handling
• Errors captured in _IMPORT_ERRORS (never crashes startup)
• ai_models/engines/engine_capabilities.py — Readiness gating and capability routing
• is_engine_ready() → (bool, reason) readiness check per engine
• get_engines_for_category() — query engines by category with optional ready-only filter
• get_eligible_upscalers(), get_eligible_interpolators() — convenience helpers
• check_resolution_compatible() — validate input resolution against engine limits
• ai_models/asset_service.py — Canonical asset path management
• AssetService with model_root, onnx_root, jit_cache_root properties
• Plugin-aware ONNX path resolution with legacy fallback dict
• SHA256 validation via check_asset_exists()
• check_plugin_assets() — validate all declared assets for plugin-style engines
• core/preflight.py — Pre-job validation guardrails
• run_preflight() — checks engine readiness, asset presence, resolution compatibility, VRAM budget
• PreflightReport dataclass with ok, engine_errors, asset_errors, resolution_errors, warnings, summary
• format_preflight_errors() — human-readable error formatting for logs and dialogs
• Integrated into ProcessingWorker.run() — logs preflight results before every job
• Updated ai_models/__init__.py with 7 new lazy imports: AssetService, discover_plugins, is_engine_ready, get_engines_for_category, EnginePlugin, AssetRequirement, SettingsField

New files in v5.0.0:

• ai_models/engines/base.py — EngineBase ABC, EngineMetadata, DependencySpec, EngineCategory, EngineBackend
• ai_models/engines/plugin_api.py — EnginePlugin contract, AssetRequirement, SettingsField
• ai_models/engines/plugin_loader.py — Subdirectory plugin discovery
• ai_models/engines/engine_capabilities.py — Readiness and capability helpers
• ai_models/asset_service.py — Asset path resolution and validation
• core/preflight.py — Pre-job validation guardrails
• core/device_scheduler.py — VRAM-aware device scheduling
• gui/pages/diagnostics_page.py — Engine diagnostics UI

Version bump from v4.2.3 → v5.0.0

Hardware Capture System (✅ COMPLETE)

Real-Time Analog Capture via FFmpeg

• CaptureWorkerThread(QThread) — non-blocking FFmpeg subprocess with user_stopped flag
• DirectShow device detection: USB analog dongles (USB2.0DEVICE, etc.)
• QFileDialog save prompt before capture with codec-appropriate file extensions
• Success/failure InfoBar notifications after capture completes
• Stop button gracefully terminates FFmpeg subprocess

Capture Codecs (7 options)

• HuffYUV — lossless, fast, large files
• FFV1 — lossless archival (smallest lossless)
• Raw AVI — uncompressed (rgb24, uyvy422, yuyv422, nv12)
• UT Video — lossless, fast decode
• MagicYUV — lossless, GPU-accelerated decode (yuv422p, yuv420p, yuv444p, rgb)
• DV — native DV stream copy
• ProRes — Apple ProRes via prores_ks (Proxy, LT, Standard, HQ profiles)

Codec UI

• Dynamic codec settings: ProRes shows Profile dropdown, others show Pixel Format
• CODEC_PRESETS dict in capture/analog_capture.py for all codec/variant combinations
• Codec selection persists across sessions

Embedded ffplay Preview Player

• Win32 SetParent/SetWindowLong pattern to embed ffplay inside a QWidget
• PID-based HWND discovery via win32gui.EnumWindows + win32process.GetWindowThreadProcessId
• eventFilter() on preview widget catches resize events → SetWindowPos + WM_SIZE
• All Win32 calls wrapped in try/except — falls back to external window on failure
• Play/Stop buttons with _last_capture_file tracking
• set_last_capture(filepath) wired from _on_capture_finished on success

New/modified files:

• gui/pages/capture_page.py — Full capture page with device selection, codec settings, preview player
• gui/main_window_fluent.py — CaptureWorkerThread, capture event handlers, set_last_capture wiring
• capture/analog_capture.py — CODEC_PRESETS with all codec variants

---

🎉 Major New Feature: AMD ROCm GPU Support

AMD Radeon GPU Acceleration

• Added full AMD GPU support via ROCm/HIP for AI acceleration
• Compatible with Radeon RX 6000/7000 series (RDNA2/RDNA3)
• Performance: 10-20x faster than CPU (RX 7900 XTX: 20x, RX 6800 XT: 14x)
• Supports all AI models: RealESRGAN, RIFE, BasicVSR++, SwinIR, GFPGAN

New Files:

• scripts/Install_ROCm.bat - Automated ROCm installation
• scripts/Install_ROCm_PyTorch.ps1 - PowerShell installer with verification
• DOCUMENTATION/ROCM_SUPPORT.md - Complete 500+ line guide
• DOCUMENTATION/ROCM_QUICK_START.txt - Quick reference
• WHATS_NEW_V4.2.txt - Release announcement

Core Updates:

• core/multi_gpu_manager.py
• Added InferenceMode.ROCM_FP32 and ROCM_FP16
• Added _detect_pytorch_rocm_gpus() method
• Added _estimate_amd_stream_processors() with RX 6000/7000 estimates
• Added get_pytorch_backend() - detects CUDA vs ROCm vs CPU
• Updated get_recommended_inference_mode() with ROCm logic
• Added _has_directml() for ONNX fallback detection
• core/gpu_accelerator.py
• Updated GPUAccelerator class to support ROCm backend
• Added is_rocm attribute to track AMD vs NVIDIA
• Renamed _init_cuda() to _init_pytorch_gpu() (supports both)
• Updated get_info() to include hip_version and is_rocm
• Updated all VRAM methods to work with ROCm
• Added AMD GPU performance estimates (RX 6000/7000 series)
• Updated check_gpu_requirements() for ROCm detection

Documentation:

• DOCUMENTATION/ROCM_SUPPORT.md - Comprehensive guide
• Installation instructions (automated + manual)
• Performance benchmarks and VRAM requirements
• Troubleshooting guide with common issues
• Hardware compatibility matrix
• Architecture details and FAQ
• DOCUMENTATION/ROCM_QUICK_START.txt - Plain text quick reference
• Updated README.md with ROCm information

Installation Scripts:

• scripts/Install_ROCm.bat - Simple batch launcher
• scripts/Install_ROCm_PyTorch.ps1 - Full PowerShell installer
• Auto-detects AMD GPU
• Checks HIP SDK installation
• Opens AMD download page if needed
• Installs PyTorch ROCm 7.1
• Runs verification test
• Colorized output with troubleshooting tips

Supported Hardware:

• AMD Radeon RX 6600/6650/6700/6750/6800/6900/6950 XT
• AMD Radeon RX 7600/7700/7800/7900 XT/XTX
• AMD Radeon PRO W6xxx/W7xxx
• Minimum: RDNA2 architecture (RX 6000 series)

Performance Gains:

• RX 7900 XTX: ~20x faster than CPU
• RX 6800 XT: ~14x faster than CPU
• RX 7700 XT: ~12x faster than CPU
• RX 6600: ~7x faster than CPU

Inference Modes:

• ROCm FP16 (Recommended): 2x faster, 50% less VRAM
• ROCm FP32 (Max Quality): Full precision, needs 16+ GB VRAM
• Auto: Automatically selects best mode based on VRAM

DirectML Fallback:

• Older AMD GPUs (RX 500/5000, Vega) use DirectML
• Still 5-10x faster than CPU
• Works with any DirectX 12 GPU

🐛 Bug Fixes

• Fixed VRAM usage reporting for non-CUDA backends
• Fixed GPU detection priority order

📚 Documentation

• Added complete ROCm documentation (500+ lines)
• Added quick start guide for AMD users
• Updated README with GPU acceleration section
• Added WHATS_NEW_V4.2.txt for release announcement

🔧 Technical Improvements

• Unified PyTorch GPU backend detection (CUDA + ROCm)
• Improved error messages for GPU initialization
• Added version detection for HIP SDK

---

🚀 Major Features

ONNX Model Conversion & NPU Acceleration

• Convert PyTorch AI models to ONNX format (95-99% size reduction)
• NPU offloading via DirectML (frees 6-8GB GPU VRAM)
• 40x speedup vs CPU inference (2.5ms vs 100ms per frame)
• Enables 4K video processing on 8GB GPUs

Performance Enhancements

• PyTorch JIT compilation (20-30% AI performance boost)
• Threaded I/O operations (2-4x speedup for batch operations)
• Multi-GPU support (NVIDIA + AMD + Intel heterogeneous)

✨ New Features

• GUI inference mode dropdown (Auto/PyTorch/TorchScript/ONNX)
• Automatic VRAM-based mode selection
• Distribution setup script (Install_ONNX_Runtime_NPU.bat)

---

🚀 Major Features

Real DirectShow Capture Device Detection

• Full DirectShow device enumeration via FFmpeg
• Analog capture engine (Composite, S-Video, Component)
• DV/FireWire capture engine with stream copy
• Lazy device loading (fixes loading screen hang)

Build & Distribution

• Standalone EXE distribution strategy
• Automatic PyInstaller cache cleanup
• Utilities folder for troubleshooting

✨ New Features

• Real-time device detection on Capture tab access
• CLI test utilities for device detection
• Comprehensive capture documentation (6 new MD files)

---

🚀 Initial Public Release

Core Features

• VapourSynth-based video processing pipeline
• QTGMC deinterlacing (7 quality presets)
• AI upscaling (RealESRGAN, BasicVSR++, SwinIR)
• Frame interpolation (RIFE)
• Face restoration (GFPGAN)
• Colorization (DeOldify)
• PySide6 GUI with presets and live preview

---

Legend:

• 🚀 Major Features
• ✨ New Features
• 🐛 Bug Fixes
• 📚 Documentation
• 🔧 Technical Improvements
• 🎉 Major Milestones