Forge VSR

Forge VSR e' un'applicazione desktop Windows per processare video in batch con NVIDIA RTX Video Super Resolution, RTX HDR/TrueHDR opzionale e codifica NVENC.

Il progetto combina una UI Avalonia in C# con un worker nativo Zig. La pipeline usa FFmpeg per demux/probe/mux, Direct3D 11 per il percorso GPU, NVIDIA NGX per VSR/HDR e NVENC per l'encoding finale.

Funzioni principali

• Scansione di file o cartelle video, anche ricorsiva.
• Coda batch con stato, progresso, frame processati, FPS, media FPS ed ETA.
• Upscale RTX VSR 2x, 3x o 4x con qualita 1-4.
• Scala di output separata dalla scala RTX: per esempio RTX 4x e output 2x con downscale Lanczos3 su D3D11.
• RTX HDR opzionale con contrasto, saturazione, middle gray e picco luminanza configurabili.
• Rilevamento del picco HDR del monitor primario tramite DXGI, con fallback a 1000 nits.
• Encoding video con h264_nvenc, hevc_nvenc o av1_nvenc.
• Preset, tune, rate control, CQ/QP, bitrate, maxrate, buffer, multipass, AQ, lookahead ed extra option NVENC.
• Selezione stream audio e sottotitoli per ogni file.
• Propagazione selezione stream ai file con layout uguale.
• Audio in copia oppure transcodifica in Opus, AAC, AC3 o FLAC.
• Copia di metadati container, metadati stream e capitoli.
• Output Matroska .mkv con naming pattern personalizzabile.

Requisiti

• Windows x64.
• GPU NVIDIA RTX compatibile con RTX Video/NGX.
• Driver NVIDIA aggiornati con supporto RTX Video Super Resolution e, per HDR, RTX Video HDR/TrueHDR.
• .NET SDK 10.
• Zig 0.16.
• Visual Studio Build Tools o Visual Studio con toolchain C++ MSVC x64.
• Windows SDK.

Dipendenze third-party

FFmpeg e NVIDIA RTX Video SDK non vanno committati nel repository. Prima della build bisogna scaricarli localmente e copiarli dentro third_party con questa struttura.

FFmpeg

Scaricare una build Windows x64 condivisa/full di FFmpeg che includa bin, include e lib. Una build adatta e' la full shared build di gyan.dev.

Estrarre o copiare i file in:

third_party/
  ffmpeg/
    README.txt
    LICENSE
    bin/
      ffprobe.exe
      avcodec-*.dll
      avformat-*.dll
      avutil-*.dll
      swresample-*.dll
      swscale-*.dll
      ...
    include/
      libavcodec/
      libavformat/
      libavutil/
      libswresample/
      libswscale/
      ...
    lib/
      avcodec.lib
      avformat.lib
      avutil.lib
      swresample.lib
      swscale.lib
      ...

La build usa gli header e le librerie in include/lib; l'app copia ffprobe.exe e le DLL runtime da bin.

NVIDIA RTX Video SDK

Scaricare NVIDIA RTX Video SDK dal portale NVIDIA Developer e copiare SDK, headers, import library e DLL runtime in:

third_party/
  rtx_video_sdk/
    NVIDIA_RTX_Video_SDK_License.pdf
    include/
      nvsdk_ngx.h
      nvsdk_ngx_defs.h
      nvsdk_ngx_params.h
      nvsdk_ngx_helpers.h
      nvsdk_ngx_helpers_vsr.h
      nvsdk_ngx_helpers_truehdr.h
      ...
    lib/
      Windows/
        x64/
          nvsdk_ngx_s.lib
          ...
    bin/
      Windows/
        x64/
          rel/
            nvngx_vsr.dll
            nvngx_truehdr.dll

Il worker Zig linka nvsdk_ngx_s.lib; l'app copia nvngx_vsr.dll e nvngx_truehdr.dll nella cartella tools.

Struttura

ForgeVsr.slnx
src/
  ForgeVsr.App/      UI Avalonia/SukiUI
  ForgeVsr.Core/     scansione, ffprobe, naming, pipeline e interop nativo
  ForgeVsr.Native/   target MSBuild che compila il worker Zig
native/
  ForgeVsrWorkerZig/     DLL e CLI native per RTX Video + NVENC
third_party/
  README.md              istruzioni per dipendenze locali
  ffmpeg/                dipendenza locale ignorata da Git
  rtx_video_sdk/         dipendenza locale ignorata da Git

Build

Prima di compilare, preparare third_party/ffmpeg e third_party/rtx_video_sdk come descritto sopra.

Dalla root:

dotnet build .\ForgeVsr.slnx -c Debug

La build:

1. ripristina i pacchetti NuGet;
2. compila il worker Zig in artifacts/worker-zig-build;
3. compila i progetti C#;
4. copia worker, FFmpeg DLL, ffprobe.exe e DLL NGX nella cartella tools dell'app.

Build Release:

dotnet build .\ForgeVsr.slnx -c Release

Esecuzione dalla sorgente:

dotnet run --project .\src\ForgeVsr.App\ForgeVsr.App.csproj -c Debug

Publish

dotnet publish .\src\ForgeVsr.App\ForgeVsr.App.csproj -c Release -r win-x64

L'output contiene anche la cartella tools necessaria al runtime.

Worker nativo

Il worker viene usato dall'app via P/Invoke tramite forge-vsr-worker.dll, ma viene compilata anche una CLI:

.\artifacts\worker-zig-build\bin\forge-vsr-worker-cli.exe --help

Esempio:

.\artifacts\worker-zig-build\bin\forge-vsr-worker-cli.exe `
  --input .\input.mkv `
  --output .\output.mkv `
  --scale 2 `
  --output-scale 2 `
  --vsr-quality 2 `
  --codec av1_nvenc `
  --preset p7 `
  --tune uhq `
  --rc vbr `
  --cq 18

Check e test Zig:

cd .\native\ForgeVsrWorkerZig
zig build check
zig build test

Naming output

Pattern predefinito:

{orig_title}_rtx{scale}_out{output_scale}_{rtx_hdr}.{output_extension}

Token disponibili:

Token	Significato
{orig_title}	titolo container, se presente, altrimenti nome file
{orig_name}	nome file originale senza estensione
{orig_ext}	estensione originale
{output_extension}	estensione di output, attualmente mkv
{scale} / {rtx_scale}	scala RTX
{output_scale}	scala finale
{codec}	encoder video scelto
{rtx_hdr}	rtxhdr oppure sdr
{width} / {height}	risoluzione finale stimata
{date}	data yyyyMMdd

Con input da cartella, l'app conserva la struttura relativa dentro la cartella output.

Pipeline tecnica

Il worker nativo esegue:

FFmpeg demux
-> D3D11VA decode
-> D3D11 video processor BGRA
-> NVIDIA NGX RTX VSR / TrueHDR
-> eventuale downscale Lanczos3 D3D11
-> NVENC D3D11
-> Matroska mux con audio/subtitle selezionati

Per l'HDR vengono impostati colorimetria BT.2020/PQ, metadata mastering display e content light. L'HDR e' bloccato lato UI/Core per H.264: usare HEVC NVENC o AV1 NVENC.

Note toolchain

native/ForgeVsrWorkerZig/build.zig contiene default locali per Windows SDK e MSVC:

• Windows SDK 10.0.26100.0
• MSVC 14.50.35717

Se la macchina usa versioni o percorsi diversi, aggiornare quei default oppure invocare zig build con le opzioni:

zig build `
  -Dwindows-sdk-include="C:\Program Files (x86)\Windows Kits\10\Include\<versione>" `
  -Dwindows-sdk-lib="C:\Program Files (x86)\Windows Kits\10\Lib\<versione>" `
  -Dmsvc-include="C:\Program Files\Microsoft Visual Studio\<versione>\<edizione>\VC\Tools\MSVC\<versione>\include" `
  -Dmsvc-lib="C:\Program Files\Microsoft Visual Studio\<versione>\<edizione>\VC\Tools\MSVC\<versione>\lib\x64"

Troubleshooting

• No NVIDIA adapter found: il worker non vede una GPU NVIDIA RTX compatibile.
• Unable to load nvngx.dll: controllare driver NVIDIA e DLL NGX copiate nella cartella tools.
• RTX Video DX11 initialization failed: driver, SDK/runtime NGX o supporto RTX Video non disponibili.
• D3D11VA decoder not found: il codec sorgente non ha decoder D3D11VA disponibile nella build FFmpeg scaricata.
• Errori MSVC/Windows SDK in Zig: verificare i percorsi in build.zig.

Licenza

Il codice di questa repository e' distribuito con licenza MIT. Vedere LICENSE.

Attenzione ai vendor locali:

• FFmpeg, se si usa la full build GPL di gyan.dev, e' soggetto a GPL v3.
• NVIDIA RTX Video SDK e' soggetto alla licenza NVIDIA inclusa nel pacchetto scaricato.

Le cartelle third_party/ffmpeg e third_party/rtx_video_sdk sono ignorate da Git per evitare di pubblicare binari pesanti e materiale soggetto a licenze vendor.