ffmpegUI

Interfaccia grafica Qt 6 / C++17 per ffmpeg: converti, taglia, estrai audio, crea GIF, estrai fotogrammi e ricomprimi sotto una dimensione massima. Non reimplementa nulla di ffmpeg: costruisce il comando, lo mostra, lo esegue e ne legge l'avanzamento.

Repo: https://github.com/4n-0n/ffmpegUI · Pagina: https://cybernet.fun/ffmpegui/ Download dei pacchetti: https://cybernet.fun/ffmpegui/#scarica

Progetto generato da un'AI. Il codice, i test e questo README sono scritti da un agente AI (Hermes Agent di Nous Research) su richiesta del proprietario del repository, e va gestito tramite AI: le modifiche si chiedono all'agente, che legge il codice, lo modifica, ricompila e riesegue i test. Non è pensato per essere mantenuto a mano pezzo per pezzo. Chi apre una issue o una pull request lo fa sapendo che la manutenzione è automatizzata.

Cosa sa fare

Scheda	Operazioni
Preconfigurate	ricette pronte e combinabili: tetto di dimensione (es. «sotto 2 GB»), crop a coordinate in pixel, base H.264 + AAC in MP4. Le prossime ricette si aggiungono qui
Video	contenitore (mp4/mkv/webm/mov/avi/ts), codec H.264/H.265/VP9/AV1/copia, CRF, preset, risoluzione, fps, audio (codec/bitrate/niente), taglio inizio+durata
Audio	MP3, M4A/AAC, WAV, FLAC, OGG, Opus; bitrate, canali, volume (-10…+6 dB, loudnorm), taglio
GIF	fps, larghezza, taglio, loop — palette generata al volo (palettegen/paletteuse)
Fotogramma	un frame a un istante oppure uno ogni N secondi (sequenza numerata)
Avanzate	remux senza ricodifica, filtri video/audio liberi, argomenti extra, sovrascrittura

In più:

• anteprima del comando sempre visibile e copiabile: tutto ciò che fa l'app si può rifare a mano in un terminale, quindi l'interfaccia non nasconde niente;
• ffprobe integrato: formato, durata, codec, risoluzione, fps, dimensione;
• miniatura estratta dal file all'apertura (anche per i file audio: solo icona);
• avanzamento reale con -progress pipe:1: percentuale, tempo, speed, fps;
• log completo di ffmpeg e annulla con terminate→kill;
• drag & drop del file nella finestra, output precompilato in base alla scheda;
• nessuna dipendenza oltre a Qt e a ffmpeg/ffprobe di sistema.

Come funziona il tetto di dimensione

Il budget si calcola dalla durata del file:

bitrate video = (dimensione_target × 8 × 0,90 − bitrate_audio × durata) / durata

e viene applicato come -crf 23 -maxrate … -bufsize …: la qualità resta guidata dal contenuto (i filmati semplici escono molto più piccoli del tetto) e il limite interviene solo dove serve. Il 10% di margine copre overhead del contenitore e i picchi del VBV; sotto i 120 kb/s di video il limite è dichiarato impossibile invece di produrre un file illeggibile; oltre 40 Mb/s il tetto «non morde» e l'interfaccia lo dice.

Compilare

Serve Qt 6.2+ (widgets), CMake, un compilatore C++17 e ffmpeg/ffprobe nel PATH.

sudo apt install qt6-base-dev qt6-qpa-plugins ffmpeg
cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
cmake --build build -j"$(nproc)"
./build/ffmpegui                      # oppure: ./build/ffmpegui video.mp4

Test — tre esecutabili, ~170 controlli, due conversioni vere end-to-end (transcodifica con scala e ricetta preconfigurata con crop, entrambe verificate con ffprobe):

ctest --test-dir build --output-on-failure

Installazione per l'utente (binario, voce di menu, icona):

cmake --install build --prefix "$HOME/.local"
kbuildsycoca6      # su KDE, per far comparire la voce nel menu

La voce di menu viene scritta con Exec= assoluto ($PREFIX/bin/ffmpegui): il PATH di plasmashell non include ~/.local/bin, quindi un Exec=ffmpegui farebbe comparire l'icona ma fallirebbe al clic con «Impossibile trovare il programma». Se un'installazione precedente lascia la voce rotta, svuota la cache:

rm ~/.cache/ksycoca6*; kbuildsycoca6 --noincremental
systemctl --user restart plasma-plasmashell

Pacchetti

I binari si scaricano da https://cybernet.fun/ffmpegui/#scarica (con sha256 e comandi pronti); la release v0.1.0 li riporta in copia:

File	Per	Installazione
ffmpegui_0.1.0-1_amd64.deb	Debian 12+, Ubuntu 22.04+	sudo apt install ./ffmpegui_0.1.0-1_amd64.deb
ffmpegui-0.1.0-1.x86_64.rpm	Fedora 41+ (x86_64)	sudo dnf install ./ffmpegui-0.1.0-1.x86_64.rpm
ffmpegui-0.1.0.flatpak	Flatpak, ogni distribuzione	flatpak install --user ./ffmpegui-0.1.0.flatpak

Come si costruiscono (gli script rigenerano tutto in dist/):

./scripts/build-deb.sh --docker     # ubuntu:22.04: Qt 6.2, glibc 2.35
./scripts/build-rpm.sh              # fedora:41 in container
./scripts/build-flatpak.sh          # org.kde.Platform 6.10

Il .deb è compilato contro Qt 6.2 e glibc 2.35, quindi vale da Debian 12 / Ubuntu 22.04 in su; dichiara ffmpeg come dipendenza e qt6-qpa-plugins come raccomandato (su Ubuntu il plugin di piattaforma è in un pacchetto a parte: senza, l'app si installa e muore all'avvio). L'RPM è costruito su Fedora 41 e richiede il file /usr/bin/ffmpeg, così va bene sia con ffmpeg-free sia con il pacchetto di RPM Fusion. Il Flatpak non bundlea né Qt né ffmpeg: il runtime org.kde.Platform 6.10 porta entrambi (ffmpeg 7.1), per questo il bundle pesa ~156 kB.

Struttura

src/job.{h,cpp}         JobSpec + buildArgs + ProgressParser (nucleo puro, testabile)
src/probe.{h,cpp}       ffprobe JSON → MediaInfo
src/runner.{h,cpp}      QProcess, -progress pipe:1, stderr → log, cancel
src/mainwindow.{h,cpp}  UI Qt Widgets (nessun .ui: tutto in codice)
tests/                  test_job (comandi), test_probe (ffprobe), test_window (offscreen + e2e)
assets/                 icona SVG + .qrc
packaging/              voce .desktop (+ script di install che la compila)
docs/                   screenshot
site/                   pagina + pacchetti pubblicati su cybernet.fun/ffmpegui/
packaging/              .desktop, man, metainfo AppStream, copyright, manifest flatpak
scripts/                build-deb.sh, build-rpm.sh, build-flatpak.sh

buildArgs() restituisce un QStringList: nessuna stringa di shell, nessun problema di quoting con nomi che contengono spazi. La riga nella scheda «Comando» è solo una resa per gli occhi.

Perché C++ e Qt (e le alternative)

• C++/Qt (scelta fatta): binario nativo da ~250 kB, nessun runtime da installare, QProcess + -progress pipe:1 sono esattamente l'API che serve.
• Python + PySide6: si scrive in metà tempo, ma servono 60–120 MB di dipendenze, l'avvio è più lento e il packaging (AppImage/PyInstaller) è la parte fragile.
• Rust + Slint/egui: binario piccolo e memoria sicura, ma l'ecosistema di widget maturi è più sottile e il costo di partenza più alto.
• Tauri/Electron (web UI): massima libertà grafica e sviluppo rapido, ma trascina un motore web (~90 MB con Electron) e la UI non è nativa.

Il punto a favore di ffmpegUI è che il "motore" è ffmpeg stesso: qualunque linguaggio va bene, quindi vince quello che produce l'eseguibile più leggero e affidabile.

Stato e prossimi passi

Versione 0.1.0, usata quotidianamente su Linux/KDE Plasma 6 (Wayland). In programma: altre ricette nella scheda Preconfigurate, coda di lavori, finestra di anteprima video, pacchetti .deb / AppImage / Flatpak.

Licenza

MIT — vedi LICENSE.

Come contribuire

Apri una issue descrivendo cosa deve fare l'interfaccia e con quale comando ffmpeg; l'implementazione (codice, test, screenshot) la fa l'agente AI che mantiene il repository. Le pull request sono benvenute ma verranno lette e integrate dallo stesso flusso automatizzato.