Titano: motore e interfaccia per time-lapse, senza dipendenze di terze parti

Applicazione desktop completa per creazione e ottimizzazione di time-lapse.
Il vincolo che ne definisce l'architettura è l'assenza totale di componenti
di terze parti: il progetto non ha alcun PackageReference e non invoca processi
esterni. Oltre alla libreria standard di .NET si usano solo API native di
Windows (WIC, Media Foundation, GDI+, DWM) richiamate via P/Invoke scritto a mano.

Sono in-house tutte le parti che di norma si delegherebbero a una libreria:
il parser binario EXIF/XMP, la misura di luminanza e la curva di deflicker,
il calcolo del campo vettoriale di movimento con il motion blur sintetico,
il multiplexer MP4 e ogni controllo dell'interfaccia.

Scelte algoritmiche che meritano una nota:
- il deflicker usa una regressione lineare locale pesata con seconda passata
  robusta, così le rampe reali di luce (alba, tramonto) sopravvivono mentre
  lo sfarfallio del diaframma viene rimosso; una media mobile semplice le
  appiattirebbe entrambe;
- la sfocatura mancante si compone in quadratura con quella già incisa nello
  scatto, perché sommarla linearmente renderebbe l'immagine troppo morbida;
- la luminanza si misura come media logaritmica troncata, invariante alla
  scala e insensibile a cieli bruciati e ombre chiuse.

L'elaborazione non produce file temporanei e mantiene un'occupazione di memoria
stazionaria: buffer poolati e canale a capacità limitata rendono i fotogrammi
vivi indipendenti dalla lunghezza della sequenza.

Verificato con "Titano.exe --selftest": 23 controlli su una sequenza sintetica
dalle proprietà note, incluse la struttura del contenitore prodotto e la sua
ri-decodifica con il lettore di sistema. Tutti superati.

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

Titano/Analysis/DeflickerEngine.cs

@@ -0,0 +1,241 @@
+namespace Titano.Analysis;
+
+/// <summary>Parametri del motore di deflicker, esposti nel pannello "Elaborazione immagini".</summary>
+public sealed class DeflickerSettings
+{
+    public bool Enabled { get; set; } = true;
+
+    /// <summary>Ampiezza della finestra mobile in fotogrammi (viene resa dispari internamente).</summary>
+    public int WindowFrames { get; set; } = 15;
+
+    /// <summary>Quota della correzione applicata: 1 = curva target piena, 0 = nessuna correzione.</summary>
+    public double Strength { get; set; } = 1.0;
+
+    /// <summary>Limite di sicurezza della correzione, in stop.</summary>
+    public double MaxCorrectionStops { get; set; } = 1.5;
+
+    /// <summary>Scarta i fotogrammi anomali (lampi, passaggi di persone) dal calcolo della curva.</summary>
+    public bool RejectOutliers { get; set; } = true;
+
+    /// <summary>Applica lo stesso smoothing ai singoli canali per stabilizzare il bilanciamento colore.</summary>
+    public bool StabilizeColor { get; set; }
+
+    /// <summary>Comprime dolcemente le alte luci quando il guadagno è maggiore di 1.</summary>
+    public bool ProtectHighlights { get; set; } = true;
+
+    /// <summary>Punto d'innesco della compressione, in luce lineare.</summary>
+    public double HighlightKnee { get; set; } = 0.75;
+
+    public DeflickerSettings Clone() => (DeflickerSettings)MemberwiseClone();
+}
+
+/// <summary>Risultato del calcolo della curva: valori per fotogramma, in log2.</summary>
+public sealed class DeflickerCurve
+{
+    public required double[] Measured { get; init; }
+    public required double[] Target { get; init; }
+    public required double[] GainStops { get; init; }
+
+    /// <summary>Guadagni per canale (R,G,B); pari a quello di luminanza se la stabilizzazione colore è spenta.</summary>
+    public required double[][] ChannelGain { get; init; }
+
+    public int Count => Measured.Length;
+
+    /// <summary>Deviazione standard delle differenze fra fotogrammi adiacenti, in stop: misura lo sfarfallio.</summary>
+    public static double FlickerIndex(IReadOnlyList<double> log2Series)
+    {
+        if (log2Series.Count < 3) return 0;
+        double mean = 0;
+        int n = log2Series.Count - 1;
+        var deltas = new double[n];
+        for (int i = 0; i < n; i++)
+        {
+            deltas[i] = log2Series[i + 1] - log2Series[i];
+            mean += deltas[i];
+        }
+        mean /= n;
+
+        double variance = 0;
+        for (int i = 0; i < n; i++)
+        {
+            double d = deltas[i] - mean;
+            variance += d * d;
+        }
+        return Math.Sqrt(variance / n);
+    }
+}
+
+/// <summary>
+/// Algoritmo proprietario di smoothing temporale dell'esposizione.
+///
+/// Per ogni fotogramma si esegue una regressione lineare locale pesata sulla finestra mobile:
+/// i pesi combinano una gaussiana sulla distanza temporale e, in seconda passata, un peso di
+/// robustezza di Tukey che neutralizza i fotogrammi anomali. Rispetto a una media mobile
+/// semplice, la componente lineare segue senza ritardo le rampe reali di luce (alba, tramonto)
+/// e rimuove solo la componente ad alta frequenza generata dalle micro-variazioni di diaframma.
+/// </summary>
+public static class DeflickerEngine
+{
+    private const double TukeyConstant = 4.685;
+
+    public static DeflickerCurve Compute(IReadOnlyList<LuminanceStats> stats, DeflickerSettings settings)
+    {
+        int n = stats.Count;
+        var measured = new double[n];
+        for (int i = 0; i < n; i++) measured[i] = stats[i].Log2Average;
+
+        var target = Smooth(measured, settings);
+        var gainStops = new double[n];
+        var channelGain = new double[n][];
+
+        double limit = Math.Max(0, settings.MaxCorrectionStops);
+        double strength = Math.Clamp(settings.Strength, 0, 1);
+
+        double[]? targetR = null, targetG = null, targetB = null;
+        if (settings.StabilizeColor && n > 0)
+        {
+            var r = new double[n];
+            var g = new double[n];
+            var b = new double[n];
+            for (int i = 0; i < n; i++)
+            {
+                r[i] = stats[i].Log2AverageR;
+                g[i] = stats[i].Log2AverageG;
+                b[i] = stats[i].Log2AverageB;
+            }
+            targetR = Smooth(r, settings);
+            targetG = Smooth(g, settings);
+            targetB = Smooth(b, settings);
+        }
+
+        for (int i = 0; i < n; i++)
+        {
+            double delta = settings.Enabled ? Math.Clamp((target[i] - measured[i]) * strength, -limit, limit) : 0;
+            gainStops[i] = delta;
+
+            if (settings.Enabled && targetR is not null && targetG is not null && targetB is not null)
+            {
+                // Il canale verde definisce il livello, gli altri due lo inseguono: si corregge
+                // la deriva cromatica senza spostare la luminanza complessiva.
+                double dr = Math.Clamp((targetR[i] - stats[i].Log2AverageR) * strength, -limit, limit);
+                double dg = Math.Clamp((targetG[i] - stats[i].Log2AverageG) * strength, -limit, limit);
+                double db = Math.Clamp((targetB[i] - stats[i].Log2AverageB) * strength, -limit, limit);
+                channelGain[i] =
+                [
+                    Math.Pow(2, delta + (dr - dg)),
+                    Math.Pow(2, delta),
+                    Math.Pow(2, delta + (db - dg)),
+                ];
+            }
+            else
+            {
+                double gain = Math.Pow(2, delta);
+                channelGain[i] = [gain, gain, gain];
+            }
+        }
+
+        return new DeflickerCurve
+        {
+            Measured = measured,
+            Target = target,
+            GainStops = gainStops,
+            ChannelGain = channelGain,
+        };
+    }
+
+    /// <summary>Regressione lineare locale pesata, con seconda passata robusta agli outlier.</summary>
+    public static double[] Smooth(double[] series, DeflickerSettings settings)
+    {
+        int n = series.Length;
+        var result = new double[n];
+        if (n == 0) return result;
+        if (n <= 2)
+        {
+            Array.Copy(series, result, n);
+            return result;
+        }
+
+        int radius = Math.Clamp((Math.Max(3, settings.WindowFrames) - 1) / 2, 1, Math.Max(1, n - 1));
+        double sigma = Math.Max(radius / 2.0, 0.5);
+
+        var robust = new double[n];
+        Array.Fill(robust, 1.0);
+
+        FitAll(series, result, radius, sigma, robust);
+
+        if (settings.RejectOutliers)
+        {
+            UpdateRobustWeights(series, result, robust);
+            FitAll(series, result, radius, sigma, robust);
+        }
+
+        return result;
+    }
+
+    private static void FitAll(double[] y, double[] output, int radius, double sigma, double[] robust)
+    {
+        int n = y.Length;
+        double twoSigmaSq = 2.0 * sigma * sigma;
+
+        for (int i = 0; i < n; i++)
+        {
+            int from = Math.Max(0, i - radius);
+            int to = Math.Min(n - 1, i + radius);
+
+            // Sistema normale della retta pesata y = a + b·t, con t = j - i.
+            double sw = 0, swt = 0, swt2 = 0, swy = 0, swty = 0;
+            for (int j = from; j <= to; j++)
+            {
+                double t = j - i;
+                double w = Math.Exp(-(t * t) / twoSigmaSq) * robust[j];
+                if (w <= 1e-9) continue;
+                sw += w;
+                swt += w * t;
+                swt2 += w * t * t;
+                swy += w * y[j];
+                swty += w * t * y[j];
+            }
+
+            if (sw <= 1e-9)
+            {
+                output[i] = y[i];
+                continue;
+            }
+
+            double det = sw * swt2 - swt * swt;
+            if (Math.Abs(det) < 1e-12)
+            {
+                output[i] = swy / sw;                       // finestra degenere: media pesata
+                continue;
+            }
+
+            double a = (swt2 * swy - swt * swty) / det;     // intercetta = valore stimato in t = 0
+            output[i] = a;
+        }
+    }
+
+    private static void UpdateRobustWeights(double[] y, double[] fit, double[] robust)
+    {
+        int n = y.Length;
+        var residuals = new double[n];
+        for (int i = 0; i < n; i++) residuals[i] = Math.Abs(y[i] - fit[i]);
+
+        var sorted = (double[])residuals.Clone();
+        Array.Sort(sorted);
+        double mad = sorted[n / 2];
+        double scale = 1.4826 * mad;
+
+        // Se la sequenza è già pulita non si scarta nulla: evita di amplificare il rumore numerico.
+        if (scale < 1e-4)
+        {
+            Array.Fill(robust, 1.0);
+            return;
+        }
+
+        for (int i = 0; i < n; i++)
+        {
+            double u = residuals[i] / (TukeyConstant * scale);
+            robust[i] = u >= 1.0 ? 0.0 : Math.Pow(1.0 - u * u, 2.0);
+        }
+    }
+}

Titano/Analysis/ExposureProcessor.cs

@@ -0,0 +1,112 @@
+using System.Numerics;
+using Titano.Imaging;
+
+namespace Titano.Analysis;
+
+/// <summary>
+/// Applicazione dei guadagni di esposizione sui canali colore.
+///
+/// L'operazione avviene in luce lineare (moltiplicazione pura, fisicamente corretta) e,
+/// se richiesto, con una compressione dolce delle alte luci: la parte di segnale che
+/// supererebbe il bianco viene ripiegata con una tangente iperbolica invece di essere
+/// troncata, evitando le classiche macchie piatte e le derive di tinta sui bordi bruciati.
+/// </summary>
+public static class ExposureProcessor
+{
+    /// <summary>
+    /// Moltiplica il buffer per i tre guadagni indicati, in-place.
+    /// Restituisce la frazione stimata di campioni saturati dopo la correzione.
+    /// </summary>
+    public static double Apply(ImageBuffer frame, ReadOnlySpan<double> channelGain,
+                               bool protectHighlights, double knee)
+    {
+        float gr = (float)channelGain[0];
+        float gg = (float)channelGain[1];
+        float gb = (float)channelGain[2];
+
+        bool identity = Math.Abs(gr - 1f) < 1e-5f && Math.Abs(gg - 1f) < 1e-5f && Math.Abs(gb - 1f) < 1e-5f;
+        bool rolloff = protectHighlights && Math.Max(gr, Math.Max(gg, gb)) > 1.0001f;
+
+        var data = frame.Data;
+        int count = frame.SampleCount;
+
+        if (!identity)
+        {
+            if (rolloff) ApplyWithRolloff(data, count, gr, gg, gb, (float)Math.Clamp(knee, 0.05, 0.98));
+            else ApplyLinear(data, count, gr, gg, gb);
+        }
+
+        return MeasureClipping(data, count);
+    }
+
+    private static void ApplyLinear(float[] data, int count, float gr, float gg, float gb)
+    {
+        int width = Vector<float>.Count;
+
+        if (width >= 4 && count >= width * 3)
+        {
+            // I guadagni si ripetono ogni 3 campioni: con vettori di larghezza non multipla di 3
+            // il pattern si richiude su 3 vettori consecutivi (lcm(3, width) / width == 3).
+            var phases = BuildGainPhases(gr, gg, gb, width, out int phaseCount);
+            int blocks = count / width;
+            int i = 0;
+
+            for (int block = 0; block < blocks; block++, i += width)
+            {
+                var v = new Vector<float>(data, i);
+                (v * phases[block % phaseCount]).CopyTo(data, i);
+            }
+
+            for (; i < count; i++) data[i] *= GainFor(i, gr, gg, gb);
+            return;
+        }
+
+        for (int i = 0; i < count; i++) data[i] *= GainFor(i, gr, gg, gb);
+    }
+
+    private static void ApplyWithRolloff(float[] data, int count, float gr, float gg, float gb, float knee)
+    {
+        float span = 1f - knee;
+        for (int i = 0; i < count; i++)
+        {
+            float v = data[i] * GainFor(i, gr, gg, gb);
+            data[i] = v <= knee ? v : knee + span * MathF.Tanh((v - knee) / span);
+        }
+    }
+
+    private static Vector<float>[] BuildGainPhases(float gr, float gg, float gb, int width, out int phaseCount)
+    {
+        phaseCount = width % 3 == 0 ? 1 : 3;
+        var phases = new Vector<float>[phaseCount];
+        var scratch = new float[width];
+
+        for (int phase = 0; phase < phaseCount; phase++)
+        {
+            for (int k = 0; k < width; k++)
+            {
+                scratch[k] = GainFor(phase * width + k, gr, gg, gb);
+            }
+            phases[phase] = new Vector<float>(scratch);
+        }
+        return phases;
+    }
+
+    private static float GainFor(int sampleIndex, float gr, float gg, float gb)
+        => (sampleIndex % 3) switch { 0 => gr, 1 => gg, _ => gb };
+
+    /// <summary>Stima del clipping su campionamento regolare: costo indipendente dalla risoluzione.</summary>
+    private static double MeasureClipping(float[] data, int count)
+    {
+        if (count == 0) return 0;
+        int step = Math.Max(3, (count / 3 / 200_000) * 3);
+        int clipped = 0, samples = 0;
+
+        for (int i = 0; i + 2 < count; i += step)
+        {
+            float luma = ColorSpace.Luminance(data[i], data[i + 1], data[i + 2]);
+            if (luma >= 0.995f) clipped++;
+            samples++;
+        }
+        return samples == 0 ? 0 : (double)clipped / samples;
+    }
+}

Titano/Analysis/LuminanceAnalyzer.cs

@@ -0,0 +1,144 @@
+using Titano.Imaging;
+
+namespace Titano.Analysis;
+
+/// <summary>Statistiche fotometriche di un fotogramma, calcolate in luce lineare.</summary>
+public readonly struct LuminanceStats
+{
+    /// <summary>Media logaritmica (base 2) della luminanza sui pixel non estremi.</summary>
+    public double Log2Average { get; init; }
+
+    /// <summary>Media geometrica in scala lineare: 2^<see cref="Log2Average"/>.</summary>
+    public double Linear => Math.Pow(2.0, Log2Average);
+
+    public double Log2AverageR { get; init; }
+    public double Log2AverageG { get; init; }
+    public double Log2AverageB { get; init; }
+
+    /// <summary>Percentili della distribuzione di luminanza, in scala lineare.</summary>
+    public double Percentile01 { get; init; }
+    public double Percentile50 { get; init; }
+    public double Percentile99 { get; init; }
+
+    /// <summary>Frazione di pixel già saturati nel fotogramma sorgente.</summary>
+    public double ClippedFraction { get; init; }
+
+    public double BlackFraction { get; init; }
+
+    public static LuminanceStats Empty => new() { Log2Average = -8 };
+}
+
+/// <summary>
+/// Misura la luminanza dei buffer in-house, senza dipendenze esterne.
+///
+/// La stima usa la media logaritmica (media geometrica) su un campionamento a griglia fissa,
+/// con esclusione delle code della distribuzione: è la metrica che segue la variazione di
+/// esposizione reale senza farsi trascinare da cieli bruciati o ombre chiuse.
+/// </summary>
+public static class LuminanceAnalyzer
+{
+    private const int Bins = 1024;
+    private const double LogMin = -16.0;      // 2^-16 ≈ nero assoluto
+    private const double LogMax = 2.0;        // headroom sopra il bianco
+    private const double Epsilon = 1.0 / 65536.0;
+
+    /// <summary>Numero massimo di pixel campionati per fotogramma: fissa il costo dell'analisi.</summary>
+    private const int TargetSamples = 262_144;
+
+    public static LuminanceStats Analyze(ImageBuffer frame, double trimLow = 0.02, double trimHigh = 0.02)
+    {
+        int step = ComputeStep(frame.PixelCount);
+        Span<int> histogram = stackalloc int[Bins];
+        histogram.Clear();
+
+        double sumR = 0, sumG = 0, sumB = 0;
+        int samples = 0, clipped = 0, black = 0;
+        var data = frame.Data;
+        int totalPixels = frame.PixelCount;
+
+        for (int p = 0; p < totalPixels; p += step)
+        {
+            int i = p * ImageBuffer.Channels;
+            float r = data[i], g = data[i + 1], b = data[i + 2];
+
+            double luma = ColorSpace.Luminance(r, g, b);
+            if (double.IsNaN(luma)) continue;
+
+            if (luma >= 0.995) clipped++;
+            if (luma <= 0.0008) black++;
+
+            sumR += Log2Safe(r + Epsilon);
+            sumG += Log2Safe(g + Epsilon);
+            sumB += Log2Safe(b + Epsilon);
+
+            double l = Log2Safe(luma + Epsilon);
+            int bin = (int)((l - LogMin) / (LogMax - LogMin) * (Bins - 1) + 0.5);
+            histogram[Math.Clamp(bin, 0, Bins - 1)]++;
+            samples++;
+        }
+
+        if (samples == 0) return LuminanceStats.Empty;
+
+        // Media troncata calcolata direttamente sull'istogramma: le code (cielo bruciato,
+        // ombre chiuse) non influenzano la stima dell'esposizione media.
+        int lowCut = (int)(samples * trimLow);
+        int highCut = (int)(samples * (1.0 - trimHigh));
+
+        double weighted = 0;
+        long counted = 0;
+        int running = 0;
+        double p01 = LogMin, p50 = LogMin, p99 = LogMin;
+        int q01 = (int)(samples * 0.01), q50 = samples / 2, q99 = (int)(samples * 0.99);
+        bool got01 = false, got50 = false, got99 = false;
+
+        for (int bin = 0; bin < Bins; bin++)
+        {
+            int count = histogram[bin];
+            if (count == 0) continue;
+            double value = LogMin + bin * (LogMax - LogMin) / (Bins - 1);
+
+            int before = running;
+            running += count;
+
+            if (!got01 && running >= q01) { p01 = value; got01 = true; }
+            if (!got50 && running >= q50) { p50 = value; got50 = true; }
+            if (!got99 && running >= q99) { p99 = value; got99 = true; }
+
+            int from = Math.Max(before, lowCut);
+            int to = Math.Min(running, highCut);
+            if (to > from)
+            {
+                weighted += value * (to - from);
+                counted += to - from;
+            }
+        }
+
+        if (counted == 0)
+        {
+            // Distribuzione degenere (immagine uniforme): ricadiamo sulla mediana.
+            weighted = p50;
+            counted = 1;
+        }
+
+        return new LuminanceStats
+        {
+            Log2Average = weighted / counted,
+            Log2AverageR = sumR / samples,
+            Log2AverageG = sumG / samples,
+            Log2AverageB = sumB / samples,
+            Percentile01 = Math.Pow(2.0, p01),
+            Percentile50 = Math.Pow(2.0, p50),
+            Percentile99 = Math.Pow(2.0, p99),
+            ClippedFraction = (double)clipped / samples,
+            BlackFraction = (double)black / samples,
+        };
+    }
+
+    /// <summary>Passo di campionamento a griglia: deterministico, quindi identico per ogni fotogramma.</summary>
+    private static int ComputeStep(int pixelCount)
+        => Math.Max(1, pixelCount / TargetSamples);
+
+    /// <summary>Logaritmo base 2 con saturazione al nero: evita -infinito sui pixel spenti.</summary>
+    private static double Log2Safe(double value)
+        => value <= 0 ? LogMin : Math.Max(LogMin, Math.Log2(value));
+}

Titano/Core/FrameRecord.cs

@@ -0,0 +1,65 @@
+using Titano.Metadata;
+
+namespace Titano.Core;
+
+/// <summary>
+/// Stato mutabile di un fotogramma lungo tutta la pipeline. Contiene solo scalari:
+/// i pixel non vivono mai qui, restano nei buffer poolati (impronta di memoria costante).
+/// </summary>
+public sealed class FrameRecord(int index, FrameMetadata metadata)
+{
+    public int Index { get; } = index;
+    public FrameMetadata Metadata { get; } = metadata;
+
+    public string FileName => Metadata.FileName;
+    public string FilePath => Metadata.FilePath;
+
+    /// <summary>Secondi trascorsi dal primo scatto della sequenza.</summary>
+    public double ElapsedSeconds { get; internal set; }
+
+    /// <summary>Intervallo verso lo scatto successivo, in secondi (l'ultimo eredita il precedente).</summary>
+    public double IntervalSeconds { get; internal set; }
+
+    /// <summary>True se l'intervallo devia in modo significativo dalla cadenza nominale.</summary>
+    public bool IsCadenceAnomaly { get; internal set; }
+
+    /// <summary>Shutter angle reale: 360 * tempo di posa / intervallo.</summary>
+    public double ShutterAngle { get; internal set; }
+
+    // ---- analisi luminanza -------------------------------------------------
+    /// <summary>Luminanza media geometrica misurata (log-average), in scala lineare 0..1.</summary>
+    public double MeasuredLuminance { get; internal set; }
+
+    /// <summary>Luminanza obiettivo dopo lo smoothing temporale.</summary>
+    public double TargetLuminance { get; internal set; }
+
+    /// <summary>Guadagno lineare applicato ai canali colore.</summary>
+    public double Gain { get; internal set; } = 1.0;
+
+    /// <summary>Correzione espressa in stop (log2 del guadagno), per la lettura in UI.</summary>
+    public double GainStops => Gain > 0 ? Math.Log2(Gain) : 0;
+
+    /// <summary>Percentuale di pixel oltre la soglia di clipping dopo la correzione.</summary>
+    public double ClippedFraction { get; internal set; }
+
+    public bool LuminanceAnalyzed { get; internal set; }
+
+    // ---- motion ------------------------------------------------------------
+    /// <summary>Modulo mediano del vettore di movimento verso il fotogramma successivo, in pixel.</summary>
+    public double MotionMagnitude { get; internal set; }
+
+    /// <summary>Direzione dominante del movimento, in gradi.</summary>
+    public double MotionDirection { get; internal set; }
+
+    /// <summary>Lunghezza della scia di motion blur sintetico effettivamente applicata, in pixel.</summary>
+    public double BlurLength { get; internal set; }
+
+    /// <summary>Durata del fotogramma nel video finale, in unità di timescale (playback adattivo).</summary>
+    public int OutputDurationUnits { get; internal set; }
+
+    public string CadenceText => IntervalSeconds <= 0
+        ? "—"
+        : IntervalSeconds < 1
+            ? $"{IntervalSeconds * 1000:0} ms"
+            : $"{IntervalSeconds:0.###} s";
+}

Titano/Core/TimelapseSequence.cs

@@ -0,0 +1,169 @@
+using Titano.Metadata;
+
+namespace Titano.Core;
+
+/// <summary>
+/// Sequenza ordinata di fotogrammi con la relativa analisi temporale: intervalli reali,
+/// cadenza nominale dell'intervallometro, pause e shutter angle per singolo scatto.
+/// </summary>
+public sealed class TimelapseSequence
+{
+    private readonly List<FrameRecord> _frames = [];
+
+    public IReadOnlyList<FrameRecord> Frames => _frames;
+    public int Count => _frames.Count;
+
+    /// <summary>Cadenza nominale (mediana degli intervalli), in secondi.</summary>
+    public double NominalInterval { get; private set; }
+
+    /// <summary>Numero di intervalli che deviano oltre la tolleranza dalla cadenza nominale.</summary>
+    public int CadenceAnomalies { get; private set; }
+
+    public TimeSpan TotalDuration { get; private set; }
+
+    /// <summary>True se almeno un fotogramma ha un timestamp con precisione al sotto-secondo.</summary>
+    public bool HasSubSecondPrecision { get; private set; }
+
+    /// <summary>Costruisce la sequenza ordinando per timestamp e, a parità, per nome file naturale.</summary>
+    public static TimelapseSequence Build(IEnumerable<FrameMetadata> metadata)
+    {
+        var ordered = metadata
+            .OrderBy(m => m.CaptureTime ?? DateTime.MaxValue)
+            .ThenBy(m => m.FileName, NaturalFileNameComparer.Instance)
+            .ToList();
+
+        var sequence = new TimelapseSequence();
+        for (int i = 0; i < ordered.Count; i++)
+        {
+            sequence._frames.Add(new FrameRecord(i, ordered[i]));
+        }
+        sequence.RecomputeTiming();
+        return sequence;
+    }
+
+    /// <summary>
+    /// Ricalcola intervalli reali, cadenza nominale e shutter angle.
+    /// Gli intervalli assenti (timestamp mancanti) ereditano la cadenza nominale.
+    /// </summary>
+    public void RecomputeTiming(double cadenceTolerance = 0.35)
+    {
+        if (_frames.Count == 0)
+        {
+            NominalInterval = 0;
+            TotalDuration = TimeSpan.Zero;
+            CadenceAnomalies = 0;
+            return;
+        }
+
+        HasSubSecondPrecision = _frames.Any(f => f.Metadata.CaptureSource == TimestampSource.ExifSubSecond);
+
+        DateTime? origin = _frames[0].Metadata.CaptureTime;
+        var raw = new double[_frames.Count];
+
+        for (int i = 0; i < _frames.Count; i++)
+        {
+            var current = _frames[i].Metadata.CaptureTime;
+            var next = i + 1 < _frames.Count ? _frames[i + 1].Metadata.CaptureTime : null;
+
+            _frames[i].ElapsedSeconds = origin is { } o && current is { } c ? (c - o).TotalSeconds : i;
+            raw[i] = current is { } a && next is { } b ? (b - a).TotalSeconds : double.NaN;
+        }
+
+        // Cadenza nominale = mediana degli intervalli validi: robusta a pause e scatti doppi.
+        var valid = raw.Where(v => !double.IsNaN(v) && v > 0).ToArray();
+        if (valid.Length > 0)
+        {
+            Array.Sort(valid);
+            NominalInterval = valid[valid.Length / 2];
+        }
+        else
+        {
+            NominalInterval = 1.0;
+        }
+        if (NominalInterval <= 0 || double.IsNaN(NominalInterval)) NominalInterval = 1.0;
+
+        CadenceAnomalies = 0;
+        for (int i = 0; i < _frames.Count; i++)
+        {
+            double interval = raw[i];
+            if (double.IsNaN(interval) || interval <= 0)
+            {
+                interval = i > 0 ? _frames[i - 1].IntervalSeconds : NominalInterval;
+            }
+            _frames[i].IntervalSeconds = interval;
+
+            bool anomaly = Math.Abs(interval - NominalInterval) > NominalInterval * cadenceTolerance;
+            _frames[i].IsCadenceAnomaly = anomaly && i < _frames.Count - 1;
+            if (_frames[i].IsCadenceAnomaly) CadenceAnomalies++;
+
+            _frames[i].ShutterAngle = ComputeShutterAngle(_frames[i].Metadata.ExposureSeconds, interval);
+        }
+
+        TotalDuration = _frames.Count > 1
+            ? TimeSpan.FromSeconds(Math.Max(0, _frames[^1].ElapsedSeconds))
+            : TimeSpan.Zero;
+    }
+
+    /// <summary>
+    /// Shutter angle cinematografico: la frazione dell'intervallo effettivamente esposta,
+    /// espressa in gradi su un giro completo dell'otturatore rotante.
+    /// </summary>
+    public static double ComputeShutterAngle(double? exposureSeconds, double intervalSeconds)
+    {
+        if (exposureSeconds is not { } e || e <= 0 || intervalSeconds <= 0) return 0;
+        return Math.Min(360.0, 360.0 * e / intervalSeconds);
+    }
+
+    /// <summary>Sotto-insieme contiguo di indici, usato dalle anteprime e dai render parziali.</summary>
+    public IEnumerable<FrameRecord> Range(int start, int count)
+    {
+        int from = Math.Clamp(start, 0, Math.Max(0, _frames.Count - 1));
+        int to = Math.Clamp(from + count, from, _frames.Count);
+        for (int i = from; i < to; i++) yield return _frames[i];
+    }
+}
+
+/// <summary>
+/// Ordinamento "naturale" dei nomi file: IMG_2.jpg precede IMG_10.jpg.
+/// Necessario perché molte sequenze condividono lo stesso timestamp al secondo.
+/// </summary>
+public sealed class NaturalFileNameComparer : IComparer<string>
+{
+    public static readonly NaturalFileNameComparer Instance = new();
+
+    public int Compare(string? x, string? y)
+    {
+        if (ReferenceEquals(x, y)) return 0;
+        if (x is null) return -1;
+        if (y is null) return 1;
+
+        int i = 0, j = 0;
+        while (i < x.Length && j < y.Length)
+        {
+            char cx = x[i], cy = y[j];
+            bool dx = cx is >= '0' and <= '9';
+            bool dy = cy is >= '0' and <= '9';
+
+            if (dx && dy)
+            {
+                int si = i, sj = j;
+                while (i < x.Length && x[i] is >= '0' and <= '9') i++;
+                while (j < y.Length && y[j] is >= '0' and <= '9') j++;
+
+                var nx = x.AsSpan(si, i - si).TrimStart('0');
+                var ny = y.AsSpan(sj, j - sj).TrimStart('0');
+                if (nx.Length != ny.Length) return nx.Length - ny.Length;
+                int cmp = nx.SequenceCompareTo(ny);
+                if (cmp != 0) return cmp;
+            }
+            else
+            {
+                int cmp = char.ToUpperInvariant(cx).CompareTo(char.ToUpperInvariant(cy));
+                if (cmp != 0) return cmp;
+                i++;
+                j++;
+            }
+        }
+        return (x.Length - i) - (y.Length - j);
+    }
+}

Titano/Diagnostics/ExifWriter.cs

@@ -0,0 +1,168 @@
+using System.Buffers.Binary;
+using System.Text;
+using Titano.Metadata;
+
+namespace Titano.Diagnostics;
+
+/// <summary>
+/// Generatore di blocchi Exif usato dalla diagnostica interna: costruisce un APP1 completo
+/// (header TIFF, IFD0, Exif IFD, area dati) e lo inserisce in un JPEG esistente.
+/// Serve a verificare il parser binario su dati di forma nota.
+/// </summary>
+internal static class ExifWriter
+{
+    private sealed record Entry(ushort Tag, TiffType Type, uint Count, byte[] Data);
+
+    public static byte[] BuildExifBlock(DateTime capture, int subSecond, double exposureSeconds,
+                                        double fNumber, int iso, int width, int height,
+                                        string make, string model)
+    {
+        var ifd0 = new List<Entry>
+        {
+            Ascii(TiffTags.Make, make),
+            Ascii(TiffTags.Model, model),
+            Short(TiffTags.Orientation, 1),
+        };
+
+        var exif = new List<Entry>
+        {
+            Rational(TiffTags.ExposureTime, exposureSeconds),
+            Rational(TiffTags.FNumber, fNumber),
+            Short(TiffTags.IsoSpeedRatings, (ushort)Math.Clamp(iso, 0, ushort.MaxValue)),
+            Ascii(TiffTags.DateTimeOriginal, capture.ToString("yyyy:MM:dd HH:mm:ss")),
+            Ascii(TiffTags.SubSecTimeOriginal, subSecond.ToString("D2")),
+            Ascii(TiffTags.OffsetTimeOriginal, "+02:00"),
+            Long(TiffTags.PixelXDimension, (uint)width),
+            Long(TiffTags.PixelYDimension, (uint)height),
+        };
+
+        // Le voci di ogni IFD devono essere ordinate per tag crescente.
+        ifd0.Sort((a, b) => a.Tag.CompareTo(b.Tag));
+        exif.Sort((a, b) => a.Tag.CompareTo(b.Tag));
+
+        const int headerSize = 8;
+        int ifd0Size = 2 + 12 * (ifd0.Count + 1) + 4;      // + puntatore all'Exif IFD
+        int exifSize = 2 + 12 * exif.Count + 4;
+        int ifd0Offset = headerSize;
+        int exifOffset = ifd0Offset + ifd0Size;
+        int dataOffset = exifOffset + exifSize;
+
+        var data = new MemoryStream();
+        var body = new MemoryStream();
+
+        // Header TIFF little-endian.
+        WriteUInt16(body, 0x4949);
+        WriteUInt16(body, 42);
+        WriteUInt32(body, (uint)ifd0Offset);
+
+        var pointerEntry = new Entry(TiffTags.ExifIfdPointer, TiffType.Long, 1, BitConverter.GetBytes((uint)exifOffset));
+        var ifd0WithPointer = new List<Entry>(ifd0) { pointerEntry };
+        ifd0WithPointer.Sort((a, b) => a.Tag.CompareTo(b.Tag));
+
+        WriteDirectory(body, ifd0WithPointer, data, dataOffset);
+        WriteUInt32(body, 0);                              // nessuna IFD successiva
+        WriteDirectory(body, exif, data, dataOffset);
+        WriteUInt32(body, 0);
+
+        body.Write(data.GetBuffer(), 0, (int)data.Length);
+        return body.ToArray();
+    }
+
+    /// <summary>Inserisce il segmento APP1 in un JPEG, subito dopo l'eventuale APP0/JFIF.</summary>
+    public static byte[] InsertIntoJpeg(byte[] jpeg, byte[] exifBlock)
+    {
+        int insertAt = 2;
+        if (jpeg.Length > 4 && jpeg[2] == 0xFF && jpeg[3] == 0xE0)
+        {
+            int app0Length = (jpeg[4] << 8) | jpeg[5];
+            insertAt = 4 + app0Length;
+        }
+
+        byte[] signature = "Exif\0\0"u8.ToArray();
+        int payload = signature.Length + exifBlock.Length;
+        int segmentLength = payload + 2;
+
+        var result = new byte[jpeg.Length + 4 + payload];
+        int position = 0;
+
+        Array.Copy(jpeg, 0, result, position, insertAt);
+        position += insertAt;
+
+        result[position++] = 0xFF;
+        result[position++] = 0xE1;
+        result[position++] = (byte)(segmentLength >> 8);
+        result[position++] = (byte)(segmentLength & 0xFF);
+        Array.Copy(signature, 0, result, position, signature.Length);
+        position += signature.Length;
+        Array.Copy(exifBlock, 0, result, position, exifBlock.Length);
+        position += exifBlock.Length;
+
+        Array.Copy(jpeg, insertAt, result, position, jpeg.Length - insertAt);
+        return result;
+    }
+
+    // ------------------------------------------------------------------ scrittura IFD
+
+    private static void WriteDirectory(Stream body, List<Entry> entries, MemoryStream data, int dataOffset)
+    {
+        WriteUInt16(body, (ushort)entries.Count);
+        Span<byte> inline = stackalloc byte[4];
+
+        foreach (var entry in entries)
+        {
+            WriteUInt16(body, entry.Tag);
+            WriteUInt16(body, (ushort)entry.Type);
+            WriteUInt32(body, entry.Count);
+
+            if (entry.Data.Length <= 4)
+            {
+                inline.Clear();
+                entry.Data.CopyTo(inline);
+                body.Write(inline);
+            }
+            else
+            {
+                WriteUInt32(body, (uint)(dataOffset + data.Length));
+                data.Write(entry.Data);
+                if ((data.Length & 1) != 0) data.WriteByte(0);   // le aree dati restano allineate
+            }
+        }
+    }
+
+    private static Entry Ascii(ushort tag, string value)
+    {
+        byte[] bytes = Encoding.ASCII.GetBytes(value + "\0");
+        return new Entry(tag, TiffType.Ascii, (uint)bytes.Length, bytes);
+    }
+
+    private static Entry Short(ushort tag, ushort value)
+        => new(tag, TiffType.Short, 1, BitConverter.GetBytes(value));
+
+    private static Entry Long(ushort tag, uint value)
+        => new(tag, TiffType.Long, 1, BitConverter.GetBytes(value));
+
+    private static Entry Rational(ushort tag, double value)
+    {
+        // Approssimazione con denominatore fisso: sufficiente e priva di ambiguità.
+        uint denominator = 1_000_000;
+        uint numerator = (uint)Math.Round(value * denominator);
+        var bytes = new byte[8];
+        BinaryPrimitives.WriteUInt32LittleEndian(bytes, numerator);
+        BinaryPrimitives.WriteUInt32LittleEndian(bytes.AsSpan(4), denominator);
+        return new Entry(tag, TiffType.Rational, 1, bytes);
+    }
+
+    private static void WriteUInt16(Stream stream, ushort value)
+    {
+        Span<byte> buffer = stackalloc byte[2];
+        BinaryPrimitives.WriteUInt16LittleEndian(buffer, value);
+        stream.Write(buffer);
+    }
+
+    private static void WriteUInt32(Stream stream, uint value)
+    {
+        Span<byte> buffer = stackalloc byte[4];
+        BinaryPrimitives.WriteUInt32LittleEndian(buffer, value);
+        stream.Write(buffer);
+    }
+}

Titano/Diagnostics/Mp4Inspector.cs

@@ -0,0 +1,133 @@
+using System.Buffers.Binary;
+using System.Text;
+
+namespace Titano.Diagnostics;
+
+/// <summary>
+/// Verificatore della struttura ISO-BMFF prodotta dal multiplexer: percorre l'albero dei box
+/// e ne estrae i valori che devono risultare coerenti (numero di campioni, dimensioni,
+/// presenza della configurazione del codec).
+/// </summary>
+internal static class Mp4Inspector
+{
+    public sealed record Report(
+        bool Valid,
+        string Summary,
+        int SampleCount,
+        int Width,
+        int Height,
+        uint Timescale,
+        long MediaDuration,
+        int CodecConfigBytes,
+        List<string> TopLevelBoxes);
+
+    private static readonly string[] Containers =
+        ["moov", "trak", "mdia", "minf", "stbl", "edts", "dinf", "avc1", "hvc1"];
+
+    public static Report Inspect(string path)
+    {
+        var boxes = new List<string>();
+        int sampleCount = 0, width = 0, height = 0, configBytes = 0;
+        uint timescale = 0;
+        long mediaDuration = 0;
+        var problems = new List<string>();
+
+        using var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
+        long length = stream.Length;
+
+        Walk(stream, 0, length, 0);
+
+        bool hasFtyp = boxes.Contains("ftyp");
+        bool hasMdat = boxes.Contains("mdat");
+        bool hasMoov = boxes.Contains("moov");
+
+        if (!hasFtyp) problems.Add("box ftyp assente");
+        if (!hasMdat) problems.Add("box mdat assente");
+        if (!hasMoov) problems.Add("box moov assente");
+        if (sampleCount == 0) problems.Add("tabella stsz vuota");
+        if (configBytes == 0) problems.Add("configurazione del codec assente");
+
+        string summary = problems.Count == 0
+            ? "struttura conforme"
+            : string.Join(", ", problems);
+
+        return new Report(problems.Count == 0, summary, sampleCount, width, height,
+                          timescale, mediaDuration, configBytes, boxes);
+
+        void Walk(FileStream file, long start, long end, int depth)
+        {
+            Span<byte> header = stackalloc byte[8];
+            long position = start;
+
+            while (position + 8 <= end && depth < 8)
+            {
+                file.Position = position;
+                if (file.Read(header) != 8) return;
+
+                long size = BinaryPrimitives.ReadUInt32BigEndian(header);
+                string type = Encoding.ASCII.GetString(header[4..]);
+                long payload = position + 8;
+
+                if (size == 1)
+                {
+                    if (file.Read(header) != 8) return;
+                    size = BinaryPrimitives.ReadInt64BigEndian(header);
+                    payload += 8;
+                }
+                else if (size == 0)
+                {
+                    size = end - position;
+                }
+
+                if (size < 8 || position + size > end) return;
+                if (depth == 0) boxes.Add(type);
+
+                switch (type)
+                {
+                    case "stsz":
+                        file.Position = payload + 8;                 // versione/flag + sample_size
+                        sampleCount = (int)ReadUInt32(file);
+                        break;
+                    case "mdhd":
+                        file.Position = payload + 12;                // versione/flag + due timestamp
+                        timescale = ReadUInt32(file);
+                        mediaDuration = ReadUInt32(file);
+                        break;
+                    case "avcC" or "hvcC":
+                        configBytes = (int)(size - (payload - position));
+                        break;
+                    case "avc1" or "hvc1":
+                        file.Position = payload + 24;
+                        width = ReadUInt16(file);
+                        height = ReadUInt16(file);
+                        Walk(file, payload + 78, position + size, depth + 1);
+                        break;
+                }
+
+                if (Containers.Contains(type) && type is not ("avc1" or "hvc1"))
+                {
+                    long childStart = type == "stsd" ? payload + 8 : payload;
+                    Walk(file, childStart, position + size, depth + 1);
+                }
+                else if (type == "stsd")
+                {
+                    Walk(file, payload + 8, position + size, depth + 1);
+                }
+
+                position += size;
+            }
+        }
+
+        static uint ReadUInt32(FileStream file)
+        {
+            Span<byte> buffer = stackalloc byte[4];
+            return file.Read(buffer) == 4 ? BinaryPrimitives.ReadUInt32BigEndian(buffer) : 0;
+        }
+
+        static ushort ReadUInt16(FileStream file)
+        {
+            Span<byte> buffer = stackalloc byte[2];
+            return file.Read(buffer) == 2 ? BinaryPrimitives.ReadUInt16BigEndian(buffer) : (ushort)0;
+        }
+    }
+}

Titano/Diagnostics/Mp4Playback.cs

@@ -0,0 +1,177 @@
+using System.Runtime.InteropServices;
+using Titano.Video;
+
+namespace Titano.Diagnostics;
+
+[ComImport, Guid("70ae66f2-c809-4e4f-8915-bdcb406b7993"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFSourceReader
+{
+    [PreserveSig] int GetStreamSelection(uint streamIndex, [MarshalAs(UnmanagedType.Bool)] out bool selected);
+    [PreserveSig] int SetStreamSelection(uint streamIndex, [MarshalAs(UnmanagedType.Bool)] bool selected);
+    [PreserveSig] int GetNativeMediaType(uint streamIndex, uint typeIndex, out IMFMediaType type);
+    [PreserveSig] int GetCurrentMediaType(uint streamIndex, out IMFMediaType type);
+    [PreserveSig] int SetCurrentMediaType(uint streamIndex, IntPtr reserved, IMFMediaType type);
+    [PreserveSig] int SetCurrentPosition(ref Guid timeFormat, ref PropVariant position);
+    [PreserveSig] int ReadSample(uint streamIndex, uint controlFlags, out uint actualStreamIndex,
+                                 out uint streamFlags, out long timestamp, out IMFSample? sample);
+    [PreserveSig] int Flush(uint streamIndex);
+    [PreserveSig] int GetServiceForStream(uint streamIndex, ref Guid service, ref Guid riid, out IntPtr instance);
+    [PreserveSig] int GetPresentationAttribute(uint streamIndex, ref Guid attribute, IntPtr value);
+}
+
+/// <summary>
+/// Rilegge un MP4 prodotto dal multiplexer usando il lettore di sistema: è la prova che il
+/// contenitore non è soltanto ben formato sulla carta, ma effettivamente riproducibile.
+/// </summary>
+internal static class Mp4Playback
+{
+    private const uint FirstVideoStream = 0xFFFFFFFC;
+    private const uint AllStreams = 0xFFFFFFFE;
+    private const uint EndOfStream = 0x00000002;
+
+    private static Guid VideoFormatRgb32 = new("00000016-0000-0010-8000-00aa00389b71");
+    private static Guid EnableVideoProcessing = new("fb394f3d-ccf1-42ee-bbb3-f9b845d5681d");
+
+    [DllImport("mfreadwrite.dll", ExactSpelling = true)]
+    private static extern int MFCreateSourceReaderFromURL([MarshalAs(UnmanagedType.LPWStr)] string url,
+                                                          IMFAttributes? attributes, out IMFSourceReader reader);
+
+    [DllImport("mfplat.dll", ExactSpelling = true)]
+    private static extern int MFCreateAttributes(out IMFAttributes attributes, uint initialSize);
+
+    public sealed record Playback(int FrameCount, int Width, int Height, List<double> MeanLuma, string? Error);
+
+    public static Playback Read(string path, int maxFrames = 4096)
+    {
+        MediaFoundationRuntime.Startup();
+
+        IMFAttributes? attributes = null;
+        IMFSourceReader? reader = null;
+
+        try
+        {
+            if (MFCreateAttributes(out attributes, 1) >= 0)
+            {
+                var key = EnableVideoProcessing;
+                attributes.SetUINT32(ref key, 1);
+            }
+
+            int hr = MFCreateSourceReaderFromURL(path, attributes, out reader);
+            if (hr < 0) return new Playback(0, 0, 0, [], $"apertura non riuscita (HRESULT 0x{hr:X8})");
+
+            reader.SetStreamSelection(AllStreams, false);
+            reader.SetStreamSelection(FirstVideoStream, true);
+
+            int width = 0, height = 0;
+            if (reader.GetNativeMediaType(FirstVideoStream, 0, out IMFMediaType native) >= 0)
+            {
+                try
+                {
+                    var sizeKey = MediaFoundation.MtFrameSize;
+                    if (native.GetUINT64(ref sizeKey, out ulong packed) >= 0)
+                    {
+                        width = (int)(packed >> 32);
+                        height = (int)(packed & 0xFFFFFFFF);
+                    }
+                }
+                finally
+                {
+                    Marshal.ReleaseComObject(native);
+                }
+            }
+
+            // Si richiede RGB a 8 bit: il lettore inserisce da sé il convertitore di formato.
+            if (MediaFoundation.MFCreateMediaType(out IMFMediaType target) >= 0)
+            {
+                try
+                {
+                    var majorKey = MediaFoundation.MtMajorType;
+                    var majorValue = MediaFoundation.MajorTypeVideo;
+                    target.SetGUID(ref majorKey, ref majorValue);
+                    var subKey = MediaFoundation.MtSubtype;
+                    target.SetGUID(ref subKey, ref VideoFormatRgb32);
+                    reader.SetCurrentMediaType(FirstVideoStream, IntPtr.Zero, target);
+                }
+                finally
+                {
+                    Marshal.ReleaseComObject(target);
+                }
+            }
+
+            var luma = new List<double>();
+            int frames = 0;
+
+            while (frames < maxFrames)
+            {
+                hr = reader.ReadSample(FirstVideoStream, 0, out _, out uint flags, out _, out IMFSample? sample);
+                if (hr < 0) return new Playback(frames, width, height, luma, $"lettura interrotta (HRESULT 0x{hr:X8})");
+
+                if (sample is not null)
+                {
+                    try
+                    {
+                        luma.Add(MeasureMeanLuma(sample, width, height));
+                        frames++;
+                    }
+                    finally
+                    {
+                        Marshal.ReleaseComObject(sample);
+                    }
+                }
+
+                if ((flags & EndOfStream) != 0) break;
+            }
+
+            return new Playback(frames, width, height, luma, null);
+        }
+        catch (Exception ex)
+        {
+            return new Playback(0, 0, 0, [], ex.Message);
+        }
+        finally
+        {
+            if (reader is not null) Marshal.ReleaseComObject(reader);
+            if (attributes is not null) Marshal.ReleaseComObject(attributes);
+        }
+    }
+
+    private static unsafe double MeasureMeanLuma(IMFSample sample, int width, int height)
+    {
+        sample.ConvertToContiguousBuffer(out IMFMediaBuffer buffer);
+        try
+        {
+            buffer.Lock(out IntPtr pointer, out _, out uint length);
+            try
+            {
+                if (length == 0 || width <= 0 || height <= 0) return 0;
+
+                int stride = (int)(length / Math.Max(1, height));
+                if (stride < width * 4) return 0;
+
+                byte* data = (byte*)pointer;
+                double sum = 0;
+                int count = 0;
+
+                for (int y = 0; y < height; y += 4)
+                {
+                    byte* row = data + (long)y * stride;
+                    for (int x = 0; x < width; x += 4)
+                    {
+                        byte* pixel = row + x * 4;      // BGRX
+                        sum += 0.2126 * pixel[2] + 0.7152 * pixel[1] + 0.0722 * pixel[0];
+                        count++;
+                    }
+                }
+                return count == 0 ? 0 : sum / count / 255.0;
+            }
+            finally
+            {
+                buffer.Unlock();
+            }
+        }
+        finally
+        {
+            Marshal.ReleaseComObject(buffer);
+        }
+    }
+}

Titano/Diagnostics/SelfTest.cs

@@ -0,0 +1,268 @@
+using System.Globalization;
+using System.Text;
+using Titano.Analysis;
+using Titano.Imaging;
+using Titano.Metadata;
+using Titano.Motion;
+using Titano.Pipeline;
+using Titano.Video;
+
+namespace Titano.Diagnostics;
+
+/// <summary>
+/// Verifica end-to-end del motore su una sequenza sintetica dalle proprietà note:
+/// parser Exif, analisi di cadenza, deflicker, optical flow, motion blur, encoder e
+/// multiplexer vengono esercitati nell'ordine in cui lavorano in produzione.
+/// </summary>
+public static class SelfTest
+{
+    public static int Run(string workingDirectory, TextWriter output)
+    {
+        var checks = new List<(string Name, bool Passed, string Detail)>();
+        var definition = new SyntheticSequence.Definition();
+
+        output.WriteLine("Titano — verifica del motore");
+        output.WriteLine(new string('-', 74));
+
+        string sequenceDirectory = Path.Combine(workingDirectory, "sequenza");
+        output.WriteLine($"Generazione di {definition.FrameCount} fotogrammi sintetici in {sequenceDirectory}");
+        var paths = SyntheticSequence.Write(sequenceDirectory, definition);
+
+        // ---------------------------------------------------------------- 1. metadati
+        var metadata = paths.Select(MetadataReader.Read).ToList();
+
+        int withSubSecond = metadata.Count(m => m.CaptureSource == TimestampSource.ExifSubSecond);
+        Add(checks, "Parser Exif — timestamp con frazione di secondo",
+            withSubSecond == metadata.Count, $"{withSubSecond}/{metadata.Count}");
+
+        bool exposureOk = metadata.All(m => m.ExposureSeconds is { } e && Math.Abs(e - definition.ExposureSeconds) < 1e-6);
+        Add(checks, "Parser Exif — tempo di posa", exposureOk,
+            Format(metadata[0].ExposureSeconds) + " s");
+
+        bool apertureOk = metadata.All(m => m.FNumber is { } f && Math.Abs(f - 8.0) < 1e-6);
+        bool isoOk = metadata.All(m => m.Iso == 200);
+        Add(checks, "Parser Exif — apertura e ISO", apertureOk && isoOk,
+            $"f/{Format(metadata[0].FNumber)}, ISO {metadata[0].Iso}");
+
+        bool offsetOk = metadata.All(m => m.UtcOffset == TimeSpan.FromHours(2));
+        Add(checks, "Parser Exif — fuso orario", offsetOk, metadata[0].UtcOffset?.ToString() ?? "assente");
+
+        bool sizeOk = metadata.All(m => m.PixelWidth == definition.Width && m.PixelHeight == definition.Height);
+        Add(checks, "Parser Exif — dimensioni dichiarate", sizeOk,
+            $"{metadata[0].PixelWidth}×{metadata[0].PixelHeight}");
+
+        // ---------------------------------------------------------------- 2. cadenza
+        var project = new TitanoProject();
+        project.Sequence = Core.TimelapseSequence.Build(metadata);
+        project.Sequence.RecomputeTiming(project.General.CadenceTolerance);
+
+        double expectedInterval = definition.IntervalSeconds + 0.37;
+        bool cadenceOk = Math.Abs(project.Sequence.NominalInterval - expectedInterval) < 0.05;
+        Add(checks, "Cadenza nominale rilevata", cadenceOk,
+            $"{project.Sequence.NominalInterval:0.###} s (attesa {expectedInterval:0.###} s)");
+
+        bool pauseOk = project.Sequence.CadenceAnomalies >= definition.PauseFrames;
+        Add(checks, "Pause dell'intervallometro individuate", pauseOk,
+            $"{project.Sequence.CadenceAnomalies} intervalli anomali");
+
+        double expectedAngle = 360.0 * definition.ExposureSeconds / expectedInterval;
+        double measuredAngle = project.Sequence.Frames[0].ShutterAngle;
+        bool angleOk = Math.Abs(measuredAngle - expectedAngle) < 0.2;
+        Add(checks, "Shutter angle reale", angleOk,
+            $"{measuredAngle:0.00}° (atteso {expectedAngle:0.00}°)");
+
+        // ---------------------------------------------------------------- 3. deflicker
+        project.Export.OutputPath = Path.Combine(workingDirectory, "titano-selftest.mp4");
+        project.Export.FrameRate = 24;
+        project.Export.BitrateMbps = 20;
+        project.General.DecodeParallelism = 4;
+
+        var pipeline = new RenderPipeline(project);
+        pipeline.AnalyzeAsync(null, CancellationToken.None).GetAwaiter().GetResult();
+
+        var curve = project.Curve!;
+        double flickerBefore = DeflickerCurve.FlickerIndex(curve.Measured);
+        var corrected = new double[curve.Count];
+        for (int i = 0; i < curve.Count; i++) corrected[i] = curve.Measured[i] + curve.GainStops[i];
+        double flickerAfter = DeflickerCurve.FlickerIndex(corrected);
+
+        Add(checks, "Sfarfallio misurato prima della correzione", flickerBefore > 0.04,
+            $"{flickerBefore:0.0000} stop RMS");
+        Add(checks, "Sfarfallio residuo dopo la correzione", flickerAfter < flickerBefore * 0.35,
+            $"{flickerAfter:0.0000} stop RMS ({100 * (1 - flickerAfter / flickerBefore):0.#}% di riduzione)");
+
+        // La rampa di luce deve sopravvivere: è un cambio reale, non sfarfallio.
+        double rampBefore = curve.Measured[^1] - curve.Measured[0];
+        double rampAfter = corrected[^1] - corrected[0];
+        bool rampOk = Math.Abs(rampAfter - rampBefore) < 0.25 && Math.Abs(rampAfter) > 0.4;
+        Add(checks, "Rampa di luce preservata", rampOk,
+            $"{rampBefore:0.00} stop → {rampAfter:0.00} stop");
+
+        // ---------------------------------------------------------------- 4. optical flow
+        var pool = new FrameBufferPool(6);
+        using var frameA = ImageDecoder.Decode(paths[10], definition.Width, definition.Height, 1, pool);
+        using var frameB = ImageDecoder.Decode(paths[11], definition.Width, definition.Height, 1, pool);
+
+        var flowEngine = new OpticalFlowEngine(project.Flow);
+        var field = flowEngine.Compute(frameA, frameB);
+
+        double expectedMagnitude = Math.Sqrt(definition.ShiftX * definition.ShiftX +
+                                             definition.ShiftY * definition.ShiftY);
+        double measuredMagnitude = field.MedianMagnitude();
+        bool flowOk = Math.Abs(measuredMagnitude - expectedMagnitude) < expectedMagnitude * 0.25;
+        Add(checks, "Campo vettoriale — modulo del movimento", flowOk,
+            $"{measuredMagnitude:0.00} px (atteso {expectedMagnitude:0.00} px)");
+
+        // Il generatore avanza le coordinate di campionamento della tessitura, quindi il
+        // contenuto visibile scorre nel verso opposto: il flusso atteso è l'opposto dello shift.
+        double expectedDirection = Math.Atan2(-definition.ShiftY, -definition.ShiftX) * 180 / Math.PI;
+        double measuredDirection = field.DominantDirection();
+        double directionError = Math.Abs(NormalizeAngle(measuredDirection - expectedDirection));
+        Add(checks, "Campo vettoriale — direzione dominante", directionError < 12,
+            $"{measuredDirection:0.0}° (atteso {expectedDirection:0.0}°)");
+
+        // ---------------------------------------------------------------- 5. motion blur
+        double missing = MotionBlurRenderer.MissingBlurFactor(measuredAngle, 180.0, 1.0);
+        using var blurred = pool.Rent(definition.Width, definition.Height);
+        double blurLength = MotionBlurRenderer.Render(frameA, blurred, field, missing, project.MotionBlur);
+
+        bool blurOk = blurLength > 1.5 && blurLength < 8.0;
+        Add(checks, "Motion blur sintetico — lunghezza della scia", blurOk,
+            $"{blurLength:0.00} px con fattore mancante {missing:0.000}");
+
+        double detailBefore = MeasureDetail(frameA);
+        double detailAfter = MeasureDetail(blurred);
+        Add(checks, "Motion blur sintetico — dettaglio ridotto lungo il moto",
+            detailAfter < detailBefore * 0.85,
+            $"{detailBefore:0.0000} → {detailAfter:0.0000} " +
+            $"({100 * (1 - detailAfter / detailBefore):0.#}% di attenuazione)");
+
+        // ---------------------------------------------------------------- 6. encoder + muxer
+        RenderResult? result = null;
+        string encodeDetail;
+        try
+        {
+            result = pipeline.RenderAsync(null, CancellationToken.None).GetAwaiter().GetResult();
+            encodeDetail = $"{result.EncodedFrames} fotogrammi, {result.OutputBytes / 1024} KiB, " +
+                           $"{result.Elapsed.TotalSeconds:0.0} s, {result.EncoderName}" +
+                           (result.HardwareAccelerated ? " (hardware)" : " (software)");
+        }
+        catch (Exception ex)
+        {
+            encodeDetail = ex.Message;
+        }
+
+        Add(checks, "Codifica video tramite encoder di sistema",
+            result is { EncodedFrames: > 0 }, encodeDetail);
+
+        if (result is not null && File.Exists(result.OutputPath))
+        {
+            var report = Mp4Inspector.Inspect(result.OutputPath);
+            Add(checks, "Contenitore MP4 — struttura dei box", report.Valid,
+                $"{report.Summary}; box radice: {string.Join(", ", report.TopLevelBoxes)}");
+            Add(checks, "Contenitore MP4 — numero di campioni",
+                report.SampleCount == result.EncodedFrames,
+                $"{report.SampleCount} campioni per {result.EncodedFrames} fotogrammi codificati");
+            Add(checks, "Contenitore MP4 — risoluzione dichiarata",
+                report.Width == definition.Width && report.Height == definition.Height,
+                $"{report.Width}×{report.Height}");
+
+            double declaredSeconds = report.Timescale > 0 ? report.MediaDuration / (double)report.Timescale : 0;
+            double expectedSeconds = result.EncodedFrames / project.Export.FrameRate;
+            Add(checks, "Contenitore MP4 — durata dichiarata",
+                Math.Abs(declaredSeconds - expectedSeconds) < 0.2,
+                $"{declaredSeconds:0.00} s (attesa {expectedSeconds:0.00} s)");
+
+            // Riproduzione effettiva con il lettore di sistema: prova che il contenitore
+            // scritto in-house è leggibile da un decoder indipendente.
+            var playback = Mp4Playback.Read(result.OutputPath);
+            Add(checks, "Riproduzione con il lettore di sistema",
+                playback.Error is null && playback.FrameCount == result.EncodedFrames,
+                playback.Error ?? $"{playback.FrameCount} fotogrammi decodificati a {playback.Width}×{playback.Height}");
+
+            if (playback.MeanLuma.Count > 4)
+            {
+                // La luminanza riletta dal file deve essere già stabilizzata: il deflicker
+                // sopravvive a codifica e contenitore.
+                var log2 = playback.MeanLuma.Select(v => Math.Log2(Math.Max(v, 1e-4))).ToList();
+                double residual = DeflickerCurve.FlickerIndex(log2);
+                Add(checks, "Sfarfallio residuo nel video finale", residual < flickerBefore * 0.5,
+                    $"{residual:0.0000} stop RMS contro {flickerBefore:0.0000} in origine");
+            }
+        }
+
+        // ---------------------------------------------------------------- 7. impronta di memoria
+        long expectedBytes = (long)definition.Width * definition.Height * 3 * sizeof(float);
+        bool memoryOk = result is null || result.PeakPixelMemoryBytes < expectedBytes * 24;
+        Add(checks, "Impronta di memoria del pool",
+            memoryOk,
+            result is null ? "non misurata" :
+            $"{result.PeakPixelMemoryBytes / (1024 * 1024.0):0.0} MiB " +
+            $"({result.PeakPixelMemoryBytes / (double)expectedBytes:0.0} fotogrammi)");
+
+        // ---------------------------------------------------------------- esito
+        output.WriteLine();
+        foreach (var (name, passed, detail) in checks)
+        {
+            output.WriteLine($"  [{(passed ? "OK  " : "FALLITO")}] {name}");
+            output.WriteLine($"           {detail}");
+        }
+
+        int failed = checks.Count(c => !c.Passed);
+        output.WriteLine();
+        output.WriteLine(new string('-', 74));
+        output.WriteLine(failed == 0
+            ? $"Tutte le {checks.Count} verifiche superate."
+            : $"{failed} verifiche fallite su {checks.Count}.");
+
+        return failed == 0 ? 0 : 1;
+    }
+
+    private static void Add(List<(string, bool, string)> checks, string name, bool passed, string detail)
+        => checks.Add((name, passed, detail));
+
+    private static string Format(double? value)
+        => value?.ToString("0.######", CultureInfo.InvariantCulture) ?? "—";
+
+    private static double NormalizeAngle(double degrees)
+    {
+        while (degrees > 180) degrees -= 360;
+        while (degrees < -180) degrees += 360;
+        return degrees;
+    }
+
+    /// <summary>
+    /// Dettaglio fine orizzontale: differenza fra pixel adiacenti sul canale verde.
+    /// Si usa la differenza a distanza 1 e non quella centrata, perché quest'ultima ha uno
+    /// zero esatto alla frequenza di Nyquist, proprio dove la sfocatura agisce di più.
+    /// </summary>
+    private static double MeasureDetail(ImageBuffer frame)
+    {
+        double sum = 0;
+        int count = 0;
+        var data = frame.Data;
+
+        for (int y = 4; y < frame.Height - 4; y += 3)
+        {
+            int rowBase = y * frame.Width * ImageBuffer.Channels;
+            for (int x = 4; x < frame.Width - 4; x += 3)
+            {
+                int i = rowBase + x * ImageBuffer.Channels;
+                sum += Math.Abs(data[i + ImageBuffer.Channels + 1] - data[i + 1]);
+                count++;
+            }
+        }
+        return count == 0 ? 0 : sum / count;
+    }
+
+    /// <summary>Riepilogo testuale usato anche dal pannello diagnostica dell'interfaccia.</summary>
+    public static string DescribeEnvironment()
+    {
+        var builder = new StringBuilder();
+        builder.AppendLine($"Sistema: {Environment.OSVersion.VersionString} ({(Environment.Is64BitProcess ? "x64" : "x86")})");
+        builder.AppendLine($"Processori logici: {Environment.ProcessorCount}");
+        builder.AppendLine($"Runtime: {Environment.Version}");
+        builder.AppendLine($"Vettori SIMD: {System.Numerics.Vector<float>.Count} float per registro");
+        return builder.ToString();
+    }
+}

Titano/Diagnostics/SyntheticSequence.cs

@@ -0,0 +1,159 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace Titano.Diagnostics;
+
+/// <summary>
+/// Generatore di sequenze sintetiche per la diagnostica: produce JPEG con Exif completo,
+/// una traslazione nota del contenuto (verifica dell'optical flow), uno sfarfallio noto
+/// sovrapposto a una rampa di luce (verifica del deflicker) e una pausa dell'intervallometro
+/// (verifica dell'analisi di cadenza).
+/// </summary>
+internal static class SyntheticSequence
+{
+    public sealed record Definition(
+        int FrameCount = 48,
+        int Width = 640,
+        int Height = 360,
+        double IntervalSeconds = 2.0,
+        double ExposureSeconds = 0.02,
+        double FlickerStops = 0.12,
+        double RampStops = -0.9,
+        int PauseAtFrame = 20,
+        int PauseFrames = 4,
+        double PauseMultiplier = 3.0,
+        int ShiftX = 6,
+        int ShiftY = 2);
+
+    /// <summary>Scrive la sequenza nella cartella indicata e restituisce i percorsi generati.</summary>
+    public static List<string> Write(string directory, Definition definition)
+    {
+        Directory.CreateDirectory(directory);
+        var paths = new List<string>(definition.FrameCount);
+
+        var origin = new DateTime(2026, 6, 1, 18, 30, 0, DateTimeKind.Unspecified);
+        double elapsed = 0;
+
+        for (int i = 0; i < definition.FrameCount; i++)
+        {
+            double exposureScale = Math.Pow(2.0, Ramp(definition, i) + Flicker(definition, i));
+            byte[] jpeg = RenderJpeg(definition, i, exposureScale);
+
+            var timestamp = origin.AddSeconds(elapsed);
+            int subSecond = (int)Math.Round((elapsed - Math.Floor(elapsed)) * 100) % 100;
+
+            byte[] exif = ExifWriter.BuildExifBlock(timestamp, subSecond, definition.ExposureSeconds,
+                                                    8.0, 200, definition.Width, definition.Height,
+                                                    "TITANO", "TITANO Synthetic");
+
+            string path = Path.Combine(directory, $"TITANO_{i:D4}.jpg");
+            File.WriteAllBytes(path, ExifWriter.InsertIntoJpeg(jpeg, exif));
+            paths.Add(path);
+
+            bool inPause = i >= definition.PauseAtFrame && i < definition.PauseAtFrame + definition.PauseFrames;
+            elapsed += definition.IntervalSeconds * (inPause ? definition.PauseMultiplier : 1.0) + 0.37;
+        }
+
+        return paths;
+    }
+
+    public static double Ramp(Definition definition, int index)
+        => definition.RampStops * index / Math.Max(1, definition.FrameCount - 1);
+
+    /// <summary>Sfarfallio deterministico ma non periodico rispetto alla finestra di smoothing.</summary>
+    public static double Flicker(Definition definition, int index)
+    {
+        int pattern = (index * 7 + (index * index) % 5) % 7;
+        return definition.FlickerStops * ((pattern - 3) / 3.0);
+    }
+
+    private static byte[] RenderJpeg(Definition definition, int index, double exposureScale)
+    {
+        int width = definition.Width;
+        int height = definition.Height;
+        double offsetX = index * definition.ShiftX;
+        double offsetY = index * definition.ShiftY;
+
+        using var bitmap = new Bitmap(width, height, PixelFormat.Format24bppRgb);
+        var rect = new Rectangle(0, 0, width, height);
+        var locked = bitmap.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);
+
+        try
+        {
+            unsafe
+            {
+                byte* basePtr = (byte*)locked.Scan0;
+                for (int y = 0; y < height; y++)
+                {
+                    byte* row = basePtr + (long)y * locked.Stride;
+                    for (int x = 0; x < width; x++)
+                    {
+                        double sx = x + offsetX;
+                        double sy = y + offsetY;
+
+                        // Rumore di valore su tre ottave: tessitura ovunque e a banda limitata,
+                        // condizioni ideali per uno schema differenziale di optical flow.
+                        // L'ottava più fine serve a rendere misurabile l'effetto del motion blur.
+                        double texture = 0.50 * ValueNoise(sx / 24.0, sy / 24.0, 11)
+                                       + 0.30 * ValueNoise(sx / 7.0, sy / 7.0, 37)
+                                       + 0.20 * ValueNoise(sx / 3.0, sy / 3.0, 53);
+
+                        double value = Math.Clamp((0.18 + 0.62 * texture) * exposureScale, 0.0, 1.0);
+                        byte gray = (byte)Math.Clamp((int)(Math.Pow(value, 1.0 / 2.2) * 255.0 + 0.5), 0, 255);
+
+                        byte* pixel = row + x * 3;
+                        pixel[0] = (byte)(gray * 0.94);   // B
+                        pixel[1] = gray;                  // G
+                        pixel[2] = (byte)Math.Min(255, gray * 1.04);  // R
+                    }
+                }
+            }
+        }
+        finally
+        {
+            bitmap.UnlockBits(locked);
+        }
+
+        using var stream = new MemoryStream();
+        var codec = ImageCodecInfo.GetImageEncoders().First(c => c.FormatID == ImageFormat.Jpeg.Guid);
+        using var parameters = new EncoderParameters(1);
+        using var quality = new EncoderParameter(Encoder.Quality, 92L);
+        parameters.Param[0] = quality;
+        bitmap.Save(stream, codec, parameters);
+        return stream.ToArray();
+    }
+
+    /// <summary>Rumore di valore bilineare su reticolo intero, deterministico.</summary>
+    private static double ValueNoise(double x, double y, int seed)
+    {
+        int x0 = (int)Math.Floor(x);
+        int y0 = (int)Math.Floor(y);
+        double fx = x - x0;
+        double fy = y - y0;
+
+        // Interpolazione con curva di Hermite: derivata continua, niente discontinuità di gradiente.
+        double sx = fx * fx * (3 - 2 * fx);
+        double sy = fy * fy * (3 - 2 * fy);
+
+        double a = Hash(x0, y0, seed);
+        double b = Hash(x0 + 1, y0, seed);
+        double c = Hash(x0, y0 + 1, seed);
+        double d = Hash(x0 + 1, y0 + 1, seed);
+
+        double top = a + (b - a) * sx;
+        double bottom = c + (d - c) * sx;
+        return top + (bottom - top) * sy;
+    }
+
+    private static double Hash(int x, int y, int seed)
+    {
+        unchecked
+        {
+            uint h = (uint)(x * 73856093) ^ (uint)(y * 19349663) ^ (uint)(seed * 83492791);
+            h ^= h >> 13;
+            h *= 0x85EBCA6B;
+            h ^= h >> 16;
+            return (h & 0xFFFFFF) / (double)0xFFFFFF;
+        }
+    }
+}

Titano/Imaging/ColorSpace.cs

@@ -0,0 +1,88 @@
+using System.Runtime.CompilerServices;
+
+namespace Titano.Imaging;
+
+/// <summary>
+/// Conversioni colore implementate in-house: curva sRGB ↔ luce lineare e pesi di luminanza.
+/// Tutta l'elaborazione (deflicker, blur, interpolazione) avviene in luce lineare, l'unico
+/// spazio in cui somme e medie pesate corrispondono al comportamento fisico della luce.
+/// </summary>
+public static class ColorSpace
+{
+    /// <summary>LUT sRGB→lineare a 8 bit.</summary>
+    private static readonly float[] SrgbToLinear8 = BuildLut(256);
+
+    /// <summary>LUT sRGB→lineare a 16 bit, campionata a 4096 punti con interpolazione lineare.</summary>
+    private static readonly float[] SrgbToLinear16 = BuildLut(4096);
+
+    /// <summary>LUT inversa lineare→sRGB a 12 bit, per la scrittura verso l'encoder.</summary>
+    private const int InverseLutSize = 4096;
+    private static readonly float[] LinearToSrgbLut = BuildInverseLut();
+
+    // Coefficienti di luminanza Rec.709 (spazio di lavoro sRGB/Rec.709 lineare).
+    public const float LumaR = 0.2126f;
+    public const float LumaG = 0.7152f;
+    public const float LumaB = 0.0722f;
+
+    private static float[] BuildLut(int size)
+    {
+        var lut = new float[size];
+        for (int i = 0; i < size; i++) lut[i] = SrgbToLinearExact(i / (float)(size - 1));
+        return lut;
+    }
+
+    private static float[] BuildInverseLut()
+    {
+        var lut = new float[InverseLutSize + 1];
+        for (int i = 0; i <= InverseLutSize; i++) lut[i] = LinearToSrgbExact(i / (float)InverseLutSize);
+        return lut;
+    }
+
+    public static float SrgbToLinearExact(float v)
+    {
+        if (v <= 0f) return 0f;
+        if (v >= 1f) return 1f;
+        return v <= 0.04045f ? v / 12.92f : MathF.Pow((v + 0.055f) / 1.055f, 2.4f);
+    }
+
+    public static float LinearToSrgbExact(float v)
+    {
+        if (v <= 0f) return 0f;
+        if (v >= 1f) return 1f;
+        return v <= 0.0031308f ? v * 12.92f : 1.055f * MathF.Pow(v, 1f / 2.4f) - 0.055f;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float FromByte(byte v) => SrgbToLinear8[v];
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float FromUInt16(ushort v)
+    {
+        // Interpolazione fra i due campioni adiacenti della LUT: errore < 1e-5.
+        int scaled = v * (SrgbToLinear16.Length - 1);
+        int index = scaled / 65535;
+        int rem = scaled - index * 65535;
+        if (index >= SrgbToLinear16.Length - 1) return SrgbToLinear16[^1];
+        float a = SrgbToLinear16[index], b = SrgbToLinear16[index + 1];
+        return a + (b - a) * (rem / 65535f);
+    }
+
+    /// <summary>Lineare → sRGB con LUT interpolata; valori fuori range vengono saturati.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float ToSrgb(float linear)
+    {
+        if (linear <= 0f) return 0f;
+        if (linear >= 1f) return 1f;
+        float pos = linear * InverseLutSize;
+        int i = (int)pos;
+        float t = pos - i;
+        return LinearToSrgbLut[i] + (LinearToSrgbLut[i + 1] - LinearToSrgbLut[i]) * t;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static byte ToSrgbByte(float linear)
+        => (byte)Math.Clamp((int)(ToSrgb(linear) * 255f + 0.5f), 0, 255);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float Luminance(float r, float g, float b) => LumaR * r + LumaG * g + LumaB * b;
+}

Titano/Imaging/ImageBuffer.cs

@@ -0,0 +1,116 @@
+using System.Collections.Concurrent;
+
+namespace Titano.Imaging;
+
+/// <summary>
+/// Fotogramma in memoria: RGB impacchettato, float32, luce lineare (gamma rimossa).
+/// L'array proviene sempre da un <see cref="FrameBufferPool"/>: nessuna allocazione
+/// per fotogramma dopo il riscaldamento, quindi impronta di memoria stazionaria.
+/// </summary>
+public sealed class ImageBuffer : IDisposable
+{
+    public const int Channels = 3;
+
+    public int Width { get; private set; }
+    public int Height { get; private set; }
+    public float[] Data { get; private set; }
+
+    internal FrameBufferPool? Owner;
+    private int _disposed;
+
+    public int PixelCount => Width * Height;
+    public int SampleCount => Width * Height * Channels;
+
+    internal ImageBuffer(int width, int height, float[] data, FrameBufferPool? owner)
+    {
+        Width = width;
+        Height = height;
+        Data = data;
+        Owner = owner;
+    }
+
+    /// <summary>Indice del primo campione (canale R) del pixel indicato.</summary>
+    public int Offset(int x, int y) => (y * Width + x) * Channels;
+
+    public void CopyFrom(ImageBuffer other)
+    {
+        if (other.Width != Width || other.Height != Height)
+            throw new ArgumentException("Dimensioni non compatibili.", nameof(other));
+        Array.Copy(other.Data, Data, SampleCount);
+    }
+
+    public ImageBuffer CloneFromPool(FrameBufferPool pool)
+    {
+        var copy = pool.Rent(Width, Height);
+        Array.Copy(Data, copy.Data, SampleCount);
+        return copy;
+    }
+
+    /// <summary>Restituisce il buffer al pool. Idempotente.</summary>
+    public void Dispose()
+    {
+        if (Interlocked.Exchange(ref _disposed, 1) != 0) return;
+        var owner = Owner;
+        Owner = null;
+        owner?.Return(Data, Width, Height);
+        Data = [];
+        Width = Height = 0;
+    }
+}
+
+/// <summary>
+/// Pool di array float per fotogrammi di dimensione omogenea. Gli array sono trattenuti
+/// per lunghezza esatta e in numero limitato: l'occupazione totale è funzione della
+/// profondità della pipeline, non del numero di fotogrammi della sequenza.
+/// </summary>
+public sealed class FrameBufferPool(int maxRetained = 8)
+{
+    private readonly ConcurrentDictionary<int, ConcurrentBag<float[]>> _bins = new();
+    private readonly int _maxRetained = Math.Max(2, maxRetained);
+    private int _retained;
+    private long _allocatedBytes;
+
+    /// <summary>Numero di array attualmente trattenuti dal pool.</summary>
+    public int Retained => Volatile.Read(ref _retained);
+
+    /// <summary>
+    /// Byte di memoria pixel effettivamente allocati dall'avvio. Poiché gli array vengono
+    /// riutilizzati, questo valore si stabilizza dopo i primi fotogrammi e rappresenta
+    /// l'impronta stazionaria della pipeline.
+    /// </summary>
+    public long AllocatedBytes => Interlocked.Read(ref _allocatedBytes);
+
+    public ImageBuffer Rent(int width, int height)
+    {
+        if (width <= 0 || height <= 0) throw new ArgumentOutOfRangeException(nameof(width));
+        int length = checked(width * height * ImageBuffer.Channels);
+
+        if (_bins.TryGetValue(length, out var bag) && bag.TryTake(out var array))
+        {
+            Interlocked.Decrement(ref _retained);
+            return new ImageBuffer(width, height, array, this);
+        }
+
+        var fresh = GC.AllocateUninitializedArray<float>(length);
+        Interlocked.Add(ref _allocatedBytes, (long)length * sizeof(float));
+        return new ImageBuffer(width, height, fresh, this);
+    }
+
+    internal void Return(float[] array, int width, int height)
+    {
+        if (array.Length == 0) return;
+        if (Volatile.Read(ref _retained) >= _maxRetained) return;   // eccedenza lasciata al GC
+
+        var bag = _bins.GetOrAdd(array.Length, static _ => []);
+        bag.Add(array);
+        Interlocked.Increment(ref _retained);
+    }
+
+    /// <summary>Svuota il pool: usato al cambio di risoluzione di lavoro.</summary>
+    public void Clear()
+    {
+        _bins.Clear();
+        Interlocked.Exchange(ref _retained, 0);
+        Interlocked.Exchange(ref _allocatedBytes, 0);
+    }
+}

Titano/Imaging/ImageDecoder.cs

@@ -0,0 +1,234 @@
+using System.Buffers;
+using System.Runtime.InteropServices;
+
+namespace Titano.Imaging;
+
+/// <summary>
+/// Decodifica un file immagine direttamente in un <see cref="ImageBuffer"/> in luce lineare,
+/// scalandolo alla risoluzione di lavoro e applicando l'orientamento Exif.
+///
+/// La catena WIC è pull-based: il ridimensionamento avviene a bande mentre i pixel vengono
+/// prelevati, quindi il fotogramma a piena risoluzione non viene mai materializzato per intero
+/// e non tocca mai il disco.
+/// </summary>
+public static class ImageDecoder
+{
+    /// <summary>Dimensioni dell'immagine così come verrà mostrata (orientamento già applicato).</summary>
+    public static (int Width, int Height) ProbeDisplaySize(string path, int orientation)
+    {
+        IWICBitmapDecoder? decoder = null;
+        IWICBitmapFrameDecode? frame = null;
+        try
+        {
+            Wic.Factory.CreateDecoderFromFilename(path, IntPtr.Zero, Wic.GenericRead,
+                                                  Wic.MetadataCacheOnDemand, out decoder);
+            decoder.GetFrame(0, out frame);
+            frame.GetSize(out uint w, out uint h);
+            return SwapsAxes(orientation) ? ((int)h, (int)w) : ((int)w, (int)h);
+        }
+        finally
+        {
+            Wic.Release(frame);
+            Wic.Release(decoder);
+        }
+    }
+
+    /// <summary>
+    /// Decodifica il file producendo un buffer di esattamente <paramref name="targetWidth"/> ×
+    /// <paramref name="targetHeight"/> pixel (misure già nell'orientamento finale).
+    /// </summary>
+    public static ImageBuffer Decode(string path, int targetWidth, int targetHeight,
+                                     int orientation, FrameBufferPool pool)
+    {
+        if (targetWidth <= 0 || targetHeight <= 0) throw new ArgumentOutOfRangeException(nameof(targetWidth));
+
+        bool swap = SwapsAxes(orientation);
+        uint decodeWidth = (uint)(swap ? targetHeight : targetWidth);
+        uint decodeHeight = (uint)(swap ? targetWidth : targetHeight);
+
+        IWICBitmapDecoder? decoder = null;
+        IWICBitmapFrameDecode? frame = null;
+        IWICFormatConverter? converter = null;
+        IWICBitmapScaler? scaler = null;
+
+        try
+        {
+            Wic.Factory.CreateDecoderFromFilename(path, IntPtr.Zero, Wic.GenericRead,
+                                                  Wic.MetadataCacheOnDemand, out decoder);
+            decoder.GetFrame(0, out frame);
+            frame.GetSize(out uint sourceWidth, out uint sourceHeight);
+            if (sourceWidth == 0 || sourceHeight == 0)
+                throw new InvalidDataException("Il decoder di sistema ha riportato dimensioni nulle.");
+
+            bool wantDeep = PrefersHighBitDepth(path);
+            Guid destinationFormat = wantDeep ? Wic.PixelFormat48bppRGB : Wic.PixelFormat32bppBGRA;
+
+            IWICBitmapSource source = CreateChain(frame, ref destinationFormat, decodeWidth, decodeHeight,
+                                                  sourceWidth, sourceHeight, ref converter, ref scaler);
+
+            int bytesPerPixel = destinationFormat == Wic.PixelFormat48bppRGB ? 6 : 4;
+            int stride = checked((int)decodeWidth * bytesPerPixel);
+            long total = (long)stride * decodeHeight;
+            if (total > int.MaxValue) throw new InvalidDataException("Fotogramma troppo grande per il buffer di trasferimento.");
+
+            byte[] scratch = ArrayPool<byte>.Shared.Rent((int)total);
+            try
+            {
+                var handle = GCHandle.Alloc(scratch, GCHandleType.Pinned);
+                try
+                {
+                    source.CopyPixels(IntPtr.Zero, (uint)stride, (uint)total, handle.AddrOfPinnedObject());
+                }
+                finally
+                {
+                    handle.Free();
+                }
+
+                var buffer = pool.Rent(targetWidth, targetHeight);
+                try
+                {
+                    if (bytesPerPixel == 6)
+                        Convert48(scratch, stride, (int)decodeWidth, (int)decodeHeight, buffer, orientation);
+                    else
+                        Convert32(scratch, stride, (int)decodeWidth, (int)decodeHeight, buffer, orientation);
+                }
+                catch
+                {
+                    buffer.Dispose();
+                    throw;
+                }
+                return buffer;
+            }
+            finally
+            {
+                ArrayPool<byte>.Shared.Return(scratch);
+            }
+        }
+        finally
+        {
+            Wic.Release(scaler);
+            Wic.Release(converter);
+            Wic.Release(frame);
+            Wic.Release(decoder);
+        }
+    }
+
+    /// <summary>
+    /// Costruisce la catena WIC: conversione al formato di lavoro e, se necessario, scalatura.
+    /// In caso di sorgenti che il codec non sa convertire a 16 bit si ripiega su 8 bit.
+    /// </summary>
+    private static IWICBitmapSource CreateChain(IWICBitmapFrameDecode frame, ref Guid destinationFormat,
+                                                uint decodeWidth, uint decodeHeight,
+                                                uint sourceWidth, uint sourceHeight,
+                                                ref IWICFormatConverter? converter, ref IWICBitmapScaler? scaler)
+    {
+        IWICBitmapSource current = (IWICBitmapSource)frame;
+
+        try
+        {
+            Wic.Factory.CreateFormatConverter(out converter);
+            converter.Initialize(current, ref destinationFormat, Wic.DitherTypeNone,
+                                 IntPtr.Zero, 0.0, Wic.PaletteTypeCustom);
+        }
+        catch (COMException) when (destinationFormat == Wic.PixelFormat48bppRGB)
+        {
+            Wic.Release(converter);
+            converter = null;
+            destinationFormat = Wic.PixelFormat32bppBGRA;
+            Wic.Factory.CreateFormatConverter(out converter);
+            converter.Initialize(current, ref destinationFormat, Wic.DitherTypeNone,
+                                 IntPtr.Zero, 0.0, Wic.PaletteTypeCustom);
+        }
+
+        current = (IWICBitmapSource)converter!;
+
+        if (decodeWidth != sourceWidth || decodeHeight != sourceHeight)
+        {
+            Wic.Factory.CreateBitmapScaler(out scaler);
+            scaler.Initialize(current, decodeWidth, decodeHeight, Wic.InterpolationFant);
+            current = (IWICBitmapSource)scaler;
+        }
+
+        return current;
+    }
+
+    private static bool PrefersHighBitDepth(string path)
+    {
+        string ext = Path.GetExtension(path);
+        return !(ext.Equals(".jpg", StringComparison.OrdinalIgnoreCase)
+                 || ext.Equals(".jpeg", StringComparison.OrdinalIgnoreCase)
+                 || ext.Equals(".jpe", StringComparison.OrdinalIgnoreCase)
+                 || ext.Equals(".jfif", StringComparison.OrdinalIgnoreCase));
+    }
+
+    public static bool SwapsAxes(int orientation) => orientation is 5 or 6 or 7 or 8;
+
+    // ------------------------------------------------------------------ conversione + orientamento
+
+    private static unsafe void Convert32(byte[] scratch, int stride, int width, int height,
+                                         ImageBuffer destination, int orientation)
+    {
+        fixed (byte* basePtr = scratch)
+        fixed (float* destBase = destination.Data)
+        {
+            byte* src = basePtr;
+            float* dst = destBase;
+            int destWidth = destination.Width;
+
+            for (int y = 0; y < height; y++)
+            {
+                byte* row = src + (long)y * stride;
+                for (int x = 0; x < width; x++)
+                {
+                    byte* px = row + x * 4;                       // BGRA
+                    int index = MapIndex(x, y, width, height, destWidth, orientation);
+                    dst[index] = ColorSpace.FromByte(px[2]);
+                    dst[index + 1] = ColorSpace.FromByte(px[1]);
+                    dst[index + 2] = ColorSpace.FromByte(px[0]);
+                }
+            }
+        }
+    }
+
+    private static unsafe void Convert48(byte[] scratch, int stride, int width, int height,
+                                         ImageBuffer destination, int orientation)
+    {
+        fixed (byte* basePtr = scratch)
+        fixed (float* destBase = destination.Data)
+        {
+            float* dst = destBase;
+            int destWidth = destination.Width;
+
+            for (int y = 0; y < height; y++)
+            {
+                ushort* row = (ushort*)(basePtr + (long)y * stride);
+                for (int x = 0; x < width; x++)
+                {
+                    ushort* px = row + x * 3;                     // RGB 16 bit
+                    int index = MapIndex(x, y, width, height, destWidth, orientation);
+                    dst[index] = ColorSpace.FromUInt16(px[0]);
+                    dst[index + 1] = ColorSpace.FromUInt16(px[1]);
+                    dst[index + 2] = ColorSpace.FromUInt16(px[2]);
+                }
+            }
+        }
+    }
+
+    /// <summary>Applica la trasformazione Exif (valori 1..8) restituendo l'offset di destinazione.</summary>
+    private static int MapIndex(int x, int y, int width, int height, int destWidth, int orientation)
+    {
+        int dx, dy;
+        switch (orientation)
+        {
+            case 2: dx = width - 1 - x; dy = y; break;
+            case 3: dx = width - 1 - x; dy = height - 1 - y; break;
+            case 4: dx = x; dy = height - 1 - y; break;
+            case 5: dx = y; dy = x; break;
+            case 6: dx = height - 1 - y; dy = x; break;
+            case 7: dx = height - 1 - y; dy = width - 1 - x; break;
+            case 8: dx = y; dy = width - 1 - x; break;
+            default: dx = x; dy = y; break;
+        }
+        return (dy * destWidth + dx) * ImageBuffer.Channels;
+    }
+}

Titano/Imaging/WicInterop.cs

@@ -0,0 +1,164 @@
+using System.Runtime.InteropServices;
+
+namespace Titano.Imaging;
+
+// ---------------------------------------------------------------------------------------
+// Binding manuale verso Windows Imaging Component (windowscodecs.dll), componente di
+// sistema. Nessun wrapper di terze parti: le interfacce COM sono dichiarate qui con
+// l'ordine di vtable esatto e vengono usate solo le voci necessarie alla pipeline.
+// ---------------------------------------------------------------------------------------
+
+[ComImport, Guid("00000120-a8f2-4877-ba0a-fd2b6645fb94"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IWICBitmapSource
+{
+    void GetSize(out uint width, out uint height);
+    void GetPixelFormat(out Guid format);
+    void GetResolution(out double dpiX, out double dpiY);
+    void CopyPalette(IntPtr palette);
+    void CopyPixels(IntPtr rect, uint stride, uint bufferSize, IntPtr buffer);
+}
+
+[ComImport, Guid("3B16811B-6A43-4ec9-A813-3D930C13B940"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IWICBitmapFrameDecode
+{
+    // --- IWICBitmapSource
+    void GetSize(out uint width, out uint height);
+    void GetPixelFormat(out Guid format);
+    void GetResolution(out double dpiX, out double dpiY);
+    void CopyPalette(IntPtr palette);
+    void CopyPixels(IntPtr rect, uint stride, uint bufferSize, IntPtr buffer);
+    // --- IWICBitmapFrameDecode
+    void GetMetadataQueryReader(out IntPtr reader);
+    void GetColorContexts(uint count, IntPtr contexts, out uint actual);
+    void GetThumbnail(out IWICBitmapSource thumbnail);
+}
+
+[ComImport, Guid("9EDDE9E7-8DEE-47ea-99DF-E6FAF2ED44BF"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IWICBitmapDecoder
+{
+    void QueryCapability(IntPtr stream, out uint capability);
+    void Initialize(IntPtr stream, int cacheOptions);
+    void GetContainerFormat(out Guid format);
+    void GetDecoderInfo(out IntPtr info);
+    void CopyPalette(IntPtr palette);
+    void GetMetadataQueryReader(out IntPtr reader);
+    void GetPreview(out IWICBitmapSource preview);
+    void GetColorContexts(uint count, IntPtr contexts, out uint actual);
+    void GetThumbnail(out IWICBitmapSource thumbnail);
+    void GetFrameCount(out uint count);
+    void GetFrame(uint index, out IWICBitmapFrameDecode frame);
+}
+
+[ComImport, Guid("00000301-a8f2-4877-ba0a-fd2b6645fb94"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IWICFormatConverter
+{
+    // --- IWICBitmapSource
+    void GetSize(out uint width, out uint height);
+    void GetPixelFormat(out Guid format);
+    void GetResolution(out double dpiX, out double dpiY);
+    void CopyPalette(IntPtr palette);
+    void CopyPixels(IntPtr rect, uint stride, uint bufferSize, IntPtr buffer);
+    // --- IWICFormatConverter
+    void Initialize(IWICBitmapSource source, ref Guid destinationFormat, int dither,
+                    IntPtr palette, double alphaThreshold, int paletteTranslate);
+    void CanConvert(ref Guid source, ref Guid destination, [MarshalAs(UnmanagedType.Bool)] out bool canConvert);
+}
+
+[ComImport, Guid("00000302-a8f2-4877-ba0a-fd2b6645fb94"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IWICBitmapScaler
+{
+    // --- IWICBitmapSource
+    void GetSize(out uint width, out uint height);
+    void GetPixelFormat(out Guid format);
+    void GetResolution(out double dpiX, out double dpiY);
+    void CopyPalette(IntPtr palette);
+    void CopyPixels(IntPtr rect, uint stride, uint bufferSize, IntPtr buffer);
+    // --- IWICBitmapScaler
+    void Initialize(IWICBitmapSource source, uint width, uint height, int interpolationMode);
+}
+
+[ComImport, Guid("EC5EC8A9-C395-4314-9C77-54D7A935FF70"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IWICImagingFactory
+{
+    void CreateDecoderFromFilename([MarshalAs(UnmanagedType.LPWStr)] string filename, IntPtr vendor,
+                                   uint desiredAccess, int metadataOptions, out IWICBitmapDecoder decoder);
+    void CreateDecoderFromStream(IntPtr stream, IntPtr vendor, int metadataOptions, out IntPtr decoder);
+    void CreateDecoderFromFileHandle(UIntPtr file, IntPtr vendor, int metadataOptions, out IntPtr decoder);
+    void CreateComponentInfo(ref Guid component, out IntPtr info);
+    void CreateDecoder(ref Guid containerFormat, IntPtr vendor, out IntPtr decoder);
+    void CreateEncoder(ref Guid containerFormat, IntPtr vendor, out IntPtr encoder);
+    void CreatePalette(out IntPtr palette);
+    void CreateFormatConverter(out IWICFormatConverter converter);
+    void CreateBitmapScaler(out IWICBitmapScaler scaler);
+    // Le voci successive della vtable non sono usate e volutamente non dichiarate.
+}
+
+internal static class Wic
+{
+    public static readonly Guid ClsidImagingFactory = new("cacaf262-9370-4615-a13b-9f5539da4c0a");
+    public static readonly Guid IidImagingFactory = new("ec5ec8a9-c395-4314-9c77-54d7a935ff70");
+
+    public static readonly Guid PixelFormat32bppBGRA = new("6fddc324-4e03-4bfe-b185-3d77768dc90f");
+    public static readonly Guid PixelFormat48bppRGB = new("6fddc324-4e03-4bfe-b185-3d77768dc915");
+
+    public const uint GenericRead = 0x80000000;
+    public const int MetadataCacheOnDemand = 0;
+    public const int DitherTypeNone = 0;
+    public const int PaletteTypeCustom = 0;
+    public const int InterpolationFant = 3;
+
+    private const uint ClsCtxInprocServer = 1;
+    private const uint CoInitMultithreaded = 0;
+
+    [ThreadStatic] private static IWICImagingFactory? _threadFactory;
+    [ThreadStatic] private static bool _comReady;
+
+    [DllImport("ole32.dll")]
+    private static extern int CoCreateInstance(ref Guid clsid, IntPtr outer, uint context, ref Guid iid, out IntPtr instance);
+
+    [DllImport("ole32.dll")]
+    private static extern int CoInitializeEx(IntPtr reserved, uint flags);
+
+    /// <summary>
+    /// Factory WIC per thread: gli oggetti COM restano confinati al thread che li crea,
+    /// così i worker di decodifica lavorano davvero in parallelo senza marshalling.
+    /// </summary>
+    public static IWICImagingFactory Factory
+    {
+        get
+        {
+            if (_threadFactory is not null) return _threadFactory;
+
+            if (!_comReady)
+            {
+                // S_OK, S_FALSE e RPC_E_CHANGED_MODE sono tutti esiti accettabili.
+                CoInitializeEx(IntPtr.Zero, CoInitMultithreaded);
+                _comReady = true;
+            }
+
+            var clsid = ClsidImagingFactory;
+            var iid = IidImagingFactory;
+            int hr = CoCreateInstance(ref clsid, IntPtr.Zero, ClsCtxInprocServer, ref iid, out IntPtr raw);
+            if (hr < 0 || raw == IntPtr.Zero)
+                throw new InvalidOperationException($"Impossibile creare la factory WIC (HRESULT 0x{hr:X8}).");
+
+            try
+            {
+                _threadFactory = (IWICImagingFactory)Marshal.GetObjectForIUnknown(raw);
+            }
+            finally
+            {
+                Marshal.Release(raw);
+            }
+            return _threadFactory!;
+        }
+    }
+
+    public static void Release(object? comObject)
+    {
+        if (comObject is not null && Marshal.IsComObject(comObject))
+        {
+            try { Marshal.ReleaseComObject(comObject); } catch (ArgumentException) { /* già rilasciato */ }
+        }
+    }
+}

Titano/Metadata/FrameMetadata.cs

@@ -0,0 +1,138 @@
+using System.Globalization;
+
+namespace Titano.Metadata;
+
+/// <summary>Origine del timestamp di scatto, usata per segnalare in UI la qualità del dato.</summary>
+public enum TimestampSource
+{
+    None = 0,
+    Exif,
+    ExifSubSecond,
+    Xmp,
+    FileSystem,
+}
+
+/// <summary>
+/// Metadati di un singolo fotogramma della sequenza, estratti dal parser binario in-house.
+/// Immutabile per costruzione: la pipeline la tratta come dato condivisibile fra thread.
+/// </summary>
+public sealed class FrameMetadata
+{
+    public required string FilePath { get; init; }
+    public required string FileName { get; init; }
+    public long FileSize { get; init; }
+
+    /// <summary>Istante di scatto, comprensivo di frazione di secondo quando disponibile.</summary>
+    public DateTime? CaptureTime { get; init; }
+    public TimestampSource CaptureSource { get; init; }
+    public TimeSpan? UtcOffset { get; init; }
+
+    public double? ExposureSeconds { get; init; }
+    public double? FNumber { get; init; }
+    public int? Iso { get; init; }
+    public double? FocalLength { get; init; }
+    public double? ExposureBias { get; init; }
+
+    public int PixelWidth { get; init; }
+    public int PixelHeight { get; init; }
+    public int Orientation { get; init; } = 1;
+
+    public string? Camera { get; init; }
+    public string? Lens { get; init; }
+
+    /// <summary>Errori non fatali incontrati durante il parsing (file troncato, IFD corrotta...).</summary>
+    public string? Warning { get; init; }
+
+    public string ExposureText => ExposureSeconds is not { } e
+        ? "—"
+        : e >= 1
+            ? string.Format(CultureInfo.CurrentCulture, "{0:0.#}s", e)
+            : string.Format(CultureInfo.CurrentCulture, "1/{0:0.#}", 1.0 / Math.Max(e, 1e-9));
+
+    public string ApertureText => FNumber is { } f ? "f/" + f.ToString("0.#", CultureInfo.CurrentCulture) : "—";
+    public string IsoText => Iso is { } i ? i.ToString(CultureInfo.CurrentCulture) : "—";
+
+    /// <summary>Costruisce l'istante completo a partire dai campi Exif grezzi.</summary>
+    internal static DateTime? CombineDateTime(string? exifDateTime, string? subSec, out TimestampSource source)
+    {
+        source = TimestampSource.None;
+        if (string.IsNullOrWhiteSpace(exifDateTime)) return null;
+
+        // Formato canonico Exif: "YYYY:MM:DD HH:MM:SS" (alcuni firmware usano '-' o '/').
+        Span<int> parts = stackalloc int[6];
+        int found = 0;
+        int value = 0;
+        bool inNumber = false;
+        foreach (char c in exifDateTime)
+        {
+            if (c is >= '0' and <= '9')
+            {
+                value = value * 10 + (c - '0');
+                inNumber = true;
+                if (value > 999999) return null;
+            }
+            else if (inNumber)
+            {
+                if (found < 6) parts[found++] = value;
+                value = 0;
+                inNumber = false;
+                if (found == 6) break;
+            }
+        }
+        if (inNumber && found < 6) parts[found++] = value;
+        if (found < 6) return null;
+
+        int year = parts[0], month = parts[1], day = parts[2], hour = parts[3], minute = parts[4], second = parts[5];
+        if (year < 1900 || year > 3000 || month is < 1 or > 12 || day is < 1 or > 31) return null;
+        if (hour > 23 || minute > 59 || second > 60) return null;
+        if (second == 60) second = 59;  // leap second difensivo
+        if (day > DateTime.DaysInMonth(year, month)) return null;
+
+        var stamp = new DateTime(year, month, day, hour, minute, second, DateTimeKind.Unspecified);
+        source = TimestampSource.Exif;
+
+        // SubSecTime è una stringa di cifre decimali: "37" -> 0.37 s, "004" -> 0.004 s.
+        if (!string.IsNullOrWhiteSpace(subSec))
+        {
+            double fraction = 0, scale = 0.1;
+            int digits = 0;
+            foreach (char c in subSec.Trim())
+            {
+                if (c is < '0' or > '9') break;
+                fraction += (c - '0') * scale;
+                scale *= 0.1;
+                if (++digits >= 7) break;
+            }
+            if (digits > 0 && fraction > 0)
+            {
+                stamp = stamp.AddTicks((long)Math.Round(fraction * TimeSpan.TicksPerSecond));
+                source = TimestampSource.ExifSubSecond;
+            }
+            else if (digits > 0)
+            {
+                source = TimestampSource.ExifSubSecond;   // frazione presente ma nulla: precisione comunque nota
+            }
+        }
+
+        return stamp;
+    }
+
+    /// <summary>Interpreta un offset fuso orario Exif nella forma "+02:00".</summary>
+    internal static TimeSpan? ParseUtcOffset(string? text)
+    {
+        if (string.IsNullOrWhiteSpace(text)) return null;
+        text = text.Trim();
+        if (text.Length < 3) return null;
+        int sign = text[0] == '-' ? -1 : text[0] == '+' ? 1 : 0;
+        if (sign == 0) return null;
+
+        int colon = text.IndexOf(':');
+        string hh = colon > 0 ? text[1..colon] : text[1..Math.Min(3, text.Length)];
+        string mm = colon > 0 && colon + 1 < text.Length ? text[(colon + 1)..] : "0";
+
+        if (!int.TryParse(hh, NumberStyles.Integer, CultureInfo.InvariantCulture, out int h)) return null;
+        if (!int.TryParse(mm, NumberStyles.Integer, CultureInfo.InvariantCulture, out int m)) m = 0;
+        if (h > 14 || m > 59) return null;
+        return new TimeSpan(sign * h, sign * m, 0);
+    }
+}

Titano/Metadata/MetadataReader.cs

@@ -0,0 +1,388 @@
+using System.Text;
+
+namespace Titano.Metadata;
+
+/// <summary>
+/// Ingestion: apre il file, riconosce il contenitore (JPEG, TIFF/RAW, PNG, HEIF/AVIF, WebP),
+/// individua i blocchi Exif e XMP e li decodifica con i parser binari in-house.
+/// Nessuna libreria esterna, nessun processo figlio.
+/// </summary>
+public static class MetadataReader
+{
+    /// <summary>Quantità massima di header letta per i contenitori TIFF/RAW (le IFD stanno all'inizio).</summary>
+    private const int TiffHeaderBudget = 4 * 1024 * 1024;
+
+    private static readonly byte[] ExifSignature = "Exif\0\0"u8.ToArray();
+    private static readonly byte[] XmpSignature = "http://ns.adobe.com/xap/1.0/\0"u8.ToArray();
+
+    public static readonly string[] SupportedExtensions =
+    [
+        ".jpg", ".jpeg", ".jpe", ".jfif",
+        ".tif", ".tiff",
+        ".png",
+        ".heic", ".heif", ".avif",
+        ".webp",
+        ".dng", ".cr2", ".cr3", ".nef", ".nrw", ".arw", ".srf", ".sr2",
+        ".orf", ".rw2", ".raf", ".pef", ".raw", ".3fr", ".iiq",
+    ];
+
+    public static bool IsSupported(string path)
+        => SupportedExtensions.Contains(Path.GetExtension(path), StringComparer.OrdinalIgnoreCase);
+
+    public static FrameMetadata Read(string path)
+    {
+        var info = new FileInfo(path);
+        string? warning = null;
+
+        DateTime? capture = null;
+        var source = TimestampSource.None;
+        TimeSpan? utcOffset = null;
+        double? exposure = null, fnumber = null, focal = null, bias = null;
+        int? iso = null;
+        int width = 0, height = 0, orientation = 1;
+        string? camera = null, lens = null;
+
+        try
+        {
+            using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite,
+                                              64 * 1024, FileOptions.SequentialScan);
+
+            var container = DetectContainer(stream, out byte[] head);
+            TiffBlock? tiff = null;
+            string? xmpPacket = null;
+
+            switch (container)
+            {
+                case ContainerKind.Jpeg:
+                    ScanJpeg(stream, ref tiff, ref xmpPacket, ref width, ref height, ref warning);
+                    break;
+
+                case ContainerKind.Tiff:
+                {
+                    int budget = (int)Math.Min(info.Length, TiffHeaderBudget);
+                    byte[] buffer = ReadAt(stream, 0, budget);
+                    tiff = TiffBlock.Parse(buffer, 0, buffer.Length);
+                    xmpPacket = FindXmpInBuffer(buffer);
+                    if (tiff is null) warning = "Header TIFF non interpretabile.";
+                    break;
+                }
+
+                case ContainerKind.Png:
+                    ScanPng(stream, ref tiff, ref xmpPacket, ref width, ref height);
+                    break;
+
+                default:
+                {
+                    // Contenitori ISO-BMFF (HEIC/AVIF), WebP e formati proprietari: individuiamo
+                    // il blocco Exif/XMP per scansione diretta dell'header.
+                    int budget = (int)Math.Min(info.Length, TiffHeaderBudget);
+                    byte[] buffer = ReadAt(stream, 0, budget);
+                    tiff = FindTiffInBuffer(buffer);
+                    xmpPacket = FindXmpInBuffer(buffer);
+                    if (tiff is null && xmpPacket is null)
+                        warning = "Nessun blocco Exif/XMP riconosciuto nell'header.";
+                    break;
+                }
+            }
+
+            if (tiff is not null)
+            {
+                string? dt = tiff.GetString(TiffTags.DateTimeOriginal)
+                             ?? tiff.GetString(TiffTags.DateTimeDigitized)
+                             ?? tiff.GetString(TiffTags.DateTime);
+                string? sub = tiff.GetString(TiffTags.SubSecTimeOriginal)
+                              ?? tiff.GetString(TiffTags.SubSecTimeDigitized)
+                              ?? tiff.GetString(TiffTags.SubSecTime);
+                capture = FrameMetadata.CombineDateTime(dt, sub, out source);
+
+                utcOffset = FrameMetadata.ParseUtcOffset(
+                    tiff.GetString(TiffTags.OffsetTimeOriginal) ?? tiff.GetString(TiffTags.OffsetTime));
+
+                if (tiff.TryGetDouble(TiffTags.ExposureTime, out double e) && e > 0) exposure = e;
+                else if (tiff.TryGetDouble(TiffTags.ShutterSpeedValue, out double apexTv))
+                    exposure = Math.Pow(2.0, -apexTv);          // APEX: Tv = -log2(t)
+
+                if (tiff.TryGetDouble(TiffTags.FNumber, out double f) && f > 0) fnumber = f;
+                else if (tiff.TryGetDouble(TiffTags.ApertureValue, out double apexAv))
+                    fnumber = Math.Pow(2.0, apexAv / 2.0);      // APEX: Av = 2*log2(N)
+
+                if (tiff.TryGetFirstUInt32(out uint isoValue, TiffTags.IsoSpeedRatings,
+                        TiffTags.RecommendedExposureIndex, TiffTags.IsoSpeed))
+                    iso = (int)Math.Min(isoValue, int.MaxValue);
+
+                if (tiff.TryGetDouble(TiffTags.FocalLength, out double fl) && fl > 0) focal = fl;
+                if (tiff.TryGetDouble(TiffTags.ExposureBiasValue, out double eb)) bias = eb;
+
+                if (tiff.TryGetUInt32(TiffTags.Orientation, out uint o) && o is >= 1 and <= 8) orientation = (int)o;
+
+                if (width == 0 && tiff.TryGetUInt32(TiffTags.PixelXDimension, out uint pw)) width = (int)pw;
+                if (height == 0 && tiff.TryGetUInt32(TiffTags.PixelYDimension, out uint ph)) height = (int)ph;
+                if (width == 0 && tiff.TryGetUInt32(TiffTags.ImageWidth, out uint iw)) width = (int)iw;
+                if (height == 0 && tiff.TryGetUInt32(TiffTags.ImageLength, out uint ih)) height = (int)ih;
+
+                string? make = tiff.GetString(TiffTags.Make);
+                string? model = tiff.GetString(TiffTags.Model);
+                camera = ComposeCamera(make, model);
+                lens = tiff.GetString(TiffTags.LensModel);
+
+                // Alcuni contenitori riportano l'XMP dentro il tag TIFF 0x02BC.
+                if (xmpPacket is null && tiff.TryFind(TiffTags.XmpPacket, out var xmpEntry))
+                {
+                    byte[] raw = tiff.View.ToArray(xmpEntry.ValuePosition, Math.Min(xmpEntry.ByteLength, 1 << 20));
+                    if (raw.Length > 0) xmpPacket = XmpScanner.ExtractPacket(Encoding.UTF8.GetString(raw));
+                }
+            }
+
+            // XMP come sorgente complementare: riempie solo i campi ancora ignoti.
+            if (xmpPacket is not null)
+            {
+                var x = XmpScanner.Scan(xmpPacket);
+                if (capture is null && x.CaptureTime is { } xc)
+                {
+                    capture = xc;
+                    source = TimestampSource.Xmp;
+                }
+                utcOffset ??= x.UtcOffset;
+                exposure ??= x.ExposureSeconds;
+                fnumber ??= x.FNumber;
+                iso ??= x.Iso;
+            }
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            warning = "Lettura non riuscita: " + ex.Message;
+        }
+        catch (Exception ex)
+        {
+            warning = "Metadati non interpretabili: " + ex.Message;
+        }
+
+        if (capture is null)
+        {
+            // Ultima risorsa: la data di modifica del file, marcata come tale in UI.
+            capture = info.Exists ? info.LastWriteTime : null;
+            if (capture is not null) source = TimestampSource.FileSystem;
+        }
+
+        return new FrameMetadata
+        {
+            FilePath = path,
+            FileName = Path.GetFileName(path),
+            FileSize = info.Exists ? info.Length : 0,
+            CaptureTime = capture,
+            CaptureSource = source,
+            UtcOffset = utcOffset,
+            ExposureSeconds = exposure,
+            FNumber = fnumber,
+            Iso = iso,
+            FocalLength = focal,
+            ExposureBias = bias,
+            PixelWidth = width,
+            PixelHeight = height,
+            Orientation = orientation,
+            Camera = camera,
+            Lens = lens,
+            Warning = warning,
+        };
+    }
+
+    private static string? ComposeCamera(string? make, string? model)
+    {
+        make = make?.Trim();
+        model = model?.Trim();
+        if (string.IsNullOrEmpty(model)) return string.IsNullOrEmpty(make) ? null : make;
+        if (string.IsNullOrEmpty(make)) return model;
+        // Molti modelli ripetono già il produttore ("NIKON D850" con make "NIKON CORPORATION").
+        string firstWord = make.Split(' ')[0];
+        return model.StartsWith(firstWord, StringComparison.OrdinalIgnoreCase) ? model : make + " " + model;
+    }
+
+    // ------------------------------------------------------------------ contenitori
+
+    private enum ContainerKind { Unknown, Jpeg, Tiff, Png }
+
+    private static ContainerKind DetectContainer(FileStream stream, out byte[] head)
+    {
+        head = ReadAt(stream, 0, 16);
+        if (head.Length >= 3 && head[0] == 0xFF && head[1] == 0xD8 && head[2] == 0xFF) return ContainerKind.Jpeg;
+        if (head.Length >= 4 && ((head[0] == 0x49 && head[1] == 0x49) || (head[0] == 0x4D && head[1] == 0x4D)))
+            return ContainerKind.Tiff;
+        if (head.Length >= 8 && head[0] == 0x89 && head[1] == 0x50 && head[2] == 0x4E && head[3] == 0x47)
+            return ContainerKind.Png;
+        return ContainerKind.Unknown;
+    }
+
+    /// <summary>
+    /// Percorre i marker JPEG senza decodificare l'immagine: legge solo gli header di segmento
+    /// e i payload APP1 (Exif/XMP), estraendo le dimensioni dal segmento SOF.
+    /// </summary>
+    private static void ScanJpeg(FileStream stream, ref TiffBlock? tiff, ref string? xmp,
+                                 ref int width, ref int height, ref string? warning)
+    {
+        stream.Position = 2;
+        Span<byte> header = stackalloc byte[4];
+        long length = stream.Length;
+        int guard = 0;
+
+        while (stream.Position < length && guard++ < 4096)
+        {
+            int b = stream.ReadByte();
+            if (b < 0) break;
+            if (b != 0xFF) continue;                     // risincronizzazione sul prossimo marker
+
+            int marker;
+            do { marker = stream.ReadByte(); } while (marker == 0xFF);
+            if (marker < 0) break;
+
+            // Marker senza payload.
+            if (marker is 0x01 or 0xD8 or 0xD9 || (marker >= 0xD0 && marker <= 0xD7)) continue;
+            if (marker == 0xDA) break;                   // inizio dati compressi: oltre non serve
+
+            if (stream.Read(header[..2]) != 2) break;
+            int segLength = (header[0] << 8) | header[1];
+            if (segLength < 2) break;
+            int payload = segLength - 2;
+            long payloadStart = stream.Position;
+
+            if (marker == 0xE1 && payload > 6)
+            {
+                byte[] data = ReadExactly(stream, Math.Min(payload, 16 * 1024 * 1024));
+                if (data.Length >= ExifSignature.Length && Matches(data, ExifSignature))
+                {
+                    tiff ??= TiffBlock.Parse(data, ExifSignature.Length, data.Length - ExifSignature.Length);
+                    if (tiff is null) warning = "Blocco Exif presente ma non interpretabile.";
+                }
+                else if (data.Length >= XmpSignature.Length && Matches(data, XmpSignature))
+                {
+                    xmp ??= XmpScanner.ExtractPacket(Encoding.UTF8.GetString(data, XmpSignature.Length,
+                                                                            data.Length - XmpSignature.Length));
+                }
+            }
+            else if (marker >= 0xC0 && marker <= 0xCF && marker != 0xC4 && marker != 0xC8 && marker != 0xCC)
+            {
+                // SOFn: precision(1) height(2) width(2)
+                byte[] sof = ReadExactly(stream, Math.Min(payload, 9));
+                if (sof.Length >= 5)
+                {
+                    height = (sof[1] << 8) | sof[2];
+                    width = (sof[3] << 8) | sof[4];
+                }
+            }
+
+            stream.Position = payloadStart + payload;
+        }
+    }
+
+    private static void ScanPng(FileStream stream, ref TiffBlock? tiff, ref string? xmp, ref int width, ref int height)
+    {
+        stream.Position = 8;
+        Span<byte> header = stackalloc byte[8];
+        int guard = 0;
+
+        while (stream.Position + 8 <= stream.Length && guard++ < 1024)
+        {
+            if (stream.Read(header) != 8) break;
+            uint len = ((uint)header[0] << 24) | ((uint)header[1] << 16) | ((uint)header[2] << 8) | header[3];
+            string type = Encoding.ASCII.GetString(header[4..].ToArray());
+            long dataStart = stream.Position;
+            if (len > 64 * 1024 * 1024) break;
+
+            switch (type)
+            {
+                case "IHDR" when len >= 8:
+                {
+                    byte[] ihdr = ReadExactly(stream, 8);
+                    if (ihdr.Length == 8)
+                    {
+                        width = (ihdr[0] << 24) | (ihdr[1] << 16) | (ihdr[2] << 8) | ihdr[3];
+                        height = (ihdr[4] << 24) | (ihdr[5] << 16) | (ihdr[6] << 8) | ihdr[7];
+                    }
+                    break;
+                }
+                case "eXIf":
+                {
+                    byte[] data = ReadExactly(stream, (int)len);
+                    tiff ??= TiffBlock.Parse(data, 0, data.Length);
+                    break;
+                }
+                case "iTXt" or "tEXt" or "zTXt":
+                {
+                    byte[] data = ReadExactly(stream, (int)Math.Min(len, 4 * 1024 * 1024));
+                    xmp ??= XmpScanner.ExtractPacket(Encoding.UTF8.GetString(data));
+                    break;
+                }
+                case "IDAT" or "IEND":
+                    return;                             // i metadati utili precedono i dati pixel
+            }
+
+            stream.Position = dataStart + len + 4;      // + CRC
+        }
+    }
+
+    // ------------------------------------------------------------------ fallback per scansione
+
+    private static TiffBlock? FindTiffInBuffer(byte[] buffer)
+    {
+        var view = new ByteView(buffer, 0, buffer.Length, false);
+        int idx = view.IndexOf(ExifSignature);
+        if (idx >= 0)
+        {
+            var block = TiffBlock.Parse(buffer, idx + ExifSignature.Length, buffer.Length - idx - ExifSignature.Length);
+            if (block is not null) return block;
+        }
+        // Alcuni contenitori scrivono l'header TIFF senza prefisso "Exif\0\0".
+        foreach (var marker in (ReadOnlySpan<byte[]>)[[0x49, 0x49, 0x2A, 0x00], [0x4D, 0x4D, 0x00, 0x2A]])
+        {
+            int at = view.IndexOf(marker);
+            if (at < 0) continue;
+            var block = TiffBlock.Parse(buffer, at, buffer.Length - at);
+            if (block is not null && (block.Exif.Count > 0 || block.Ifd0.Count > 3)) return block;
+        }
+        return null;
+    }
+
+    private static string? FindXmpInBuffer(byte[] buffer)
+    {
+        var view = new ByteView(buffer, 0, buffer.Length, false);
+        int idx = view.IndexOf("<x:xmpmeta"u8);
+        if (idx < 0) idx = view.IndexOf("<?xpacket"u8);
+        if (idx < 0) return null;
+        int take = Math.Min(buffer.Length - idx, 512 * 1024);
+        return XmpScanner.ExtractPacket(Encoding.UTF8.GetString(buffer, idx, take));
+    }
+
+    // ------------------------------------------------------------------ utilità di I/O
+
+    private static bool Matches(byte[] data, byte[] signature)
+    {
+        if (data.Length < signature.Length) return false;
+        for (int i = 0; i < signature.Length; i++)
+        {
+            if (data[i] != signature[i]) return false;
+        }
+        return true;
+    }
+
+    private static byte[] ReadAt(FileStream stream, long offset, int count)
+    {
+        if (count <= 0) return [];
+        stream.Position = offset;
+        return ReadExactly(stream, count);
+    }
+
+    private static byte[] ReadExactly(FileStream stream, int count)
+    {
+        if (count <= 0) return [];
+        var buffer = new byte[count];
+        int read = 0;
+        while (read < count)
+        {
+            int n = stream.Read(buffer, read, count - read);
+            if (n <= 0) break;
+            read += n;
+        }
+        if (read == count) return buffer;
+        Array.Resize(ref buffer, read);
+        return buffer;
+    }
+}

Titano/Metadata/TiffDirectory.cs

@@ -0,0 +1,304 @@
+namespace Titano.Metadata;
+
+/// <summary>
+/// Parser in-house di un blocco TIFF (header + catena di IFD), condiviso da JPEG/APP1,
+/// file TIFF nativi, DNG e dai principali formati RAW derivati da TIFF (CR2, NEF, ARW, ORF...).
+/// </summary>
+internal sealed class TiffBlock
+{
+    public ByteView View { get; }
+    public Dictionary<ushort, TiffEntry> Ifd0 { get; } = [];
+    public Dictionary<ushort, TiffEntry> Exif { get; } = [];
+    public Dictionary<ushort, TiffEntry> Gps { get; } = [];
+    public List<Dictionary<ushort, TiffEntry>> SubIfds { get; } = [];
+
+    private TiffBlock(ByteView view) => View = view;
+
+    /// <summary>Riconosce l'header TIFF ("II*\0" oppure "MM\0*") e percorre le directory.</summary>
+    public static TiffBlock? Parse(byte[] data, int origin, int length)
+    {
+        var probe = new ByteView(data, origin, length, false);
+        if (!probe.TryGetUInt16(0, out ushort order)) return null;
+
+        bool bigEndian;
+        if (order == 0x4949) bigEndian = false;         // "II" - Intel
+        else if (order == 0x4D4D) bigEndian = true;     // "MM" - Motorola
+        else return null;
+
+        var view = probe.WithEndianness(bigEndian);
+        if (!view.TryGetUInt16(2, out ushort magic)) return null;
+        // 42 = TIFF classico. 0x4F52/0x5352 compaiono in alcuni RAW Olympus, li accettiamo.
+        if (magic != 42 && magic != 0x4F52 && magic != 0x5352) return null;
+        if (!view.TryGetUInt32(4, out uint firstIfd)) return null;
+
+        var block = new TiffBlock(view);
+        block.ReadChain(firstIfd);
+        return block;
+    }
+
+    private void ReadChain(uint offset)
+    {
+        var visited = new HashSet<uint>();
+        int guard = 0;
+        uint next = offset;
+
+        while (next != 0 && visited.Add(next) && guard++ < 32)
+        {
+            var dir = ReadDirectory(next, out uint following);
+            if (dir is null) break;
+
+            if (Ifd0.Count == 0) MergeInto(Ifd0, dir);
+            else SubIfds.Add(dir);
+
+            // Puntatori alle sub-directory standard.
+            if (dir.TryGetValue(TiffTags.ExifIfdPointer, out var exifPtr) && TryReadPointer(exifPtr, out uint eo))
+            {
+                var d = ReadDirectory(eo, out _);
+                if (d is not null) MergeInto(Exif, d);
+            }
+            if (dir.TryGetValue(TiffTags.GpsIfdPointer, out var gpsPtr) && TryReadPointer(gpsPtr, out uint go))
+            {
+                var d = ReadDirectory(go, out _);
+                if (d is not null) MergeInto(Gps, d);
+            }
+            // SubIFDs (DNG / RAW): possono contenere le dimensioni dell'immagine full-res.
+            if (dir.TryGetValue(TiffTags.SubIfds, out var subs))
+            {
+                int count = (int)Math.Min(subs.Count, 8);
+                for (int i = 0; i < count; i++)
+                {
+                    if (!View.TryGetUInt32(subs.ValuePosition + i * 4, out uint so)) break;
+                    var d = ReadDirectory(so, out _);
+                    if (d is not null) SubIfds.Add(d);
+                }
+            }
+
+            next = following;
+        }
+    }
+
+    private static void MergeInto(Dictionary<ushort, TiffEntry> target, Dictionary<ushort, TiffEntry> source)
+    {
+        foreach (var kv in source) target.TryAdd(kv.Key, kv.Value);
+    }
+
+    private bool TryReadPointer(in TiffEntry entry, out uint offset)
+    {
+        offset = 0;
+        if (entry.Count < 1) return false;
+        return View.TryGetUInt32(entry.ValuePosition, out offset);
+    }
+
+    private Dictionary<ushort, TiffEntry>? ReadDirectory(uint offset, out uint nextIfd)
+    {
+        nextIfd = 0;
+        if (!View.TryGetUInt16(offset, out ushort count) || count == 0 || count > 4096) return null;
+
+        var dir = new Dictionary<ushort, TiffEntry>(count);
+        long p = offset + 2L;
+
+        for (int i = 0; i < count; i++, p += 12)
+        {
+            if (!View.TryGetUInt16(p, out ushort tag)) break;
+            if (!View.TryGetUInt16(p + 2, out ushort rawType)) break;
+            if (!View.TryGetUInt32(p + 4, out uint n)) break;
+
+            var type = (TiffType)rawType;
+            int unit = TiffEntry.SizeOf(type);
+            if (unit == 0) continue;                    // tipo sconosciuto: voce ignorata
+            if (n > int.MaxValue / Math.Max(unit, 1)) continue;
+
+            long bytes = (long)unit * n;
+            long valuePos;
+            if (bytes <= 4)
+            {
+                valuePos = p + 8;                       // valore inline nei 4 byte della voce
+            }
+            else
+            {
+                if (!View.TryGetUInt32(p + 8, out uint far)) continue;
+                valuePos = far;
+            }
+            if (!View.InRange(valuePos, bytes)) continue;
+
+            dir[tag] = new TiffEntry(tag, type, n, valuePos);
+        }
+
+        View.TryGetUInt32(p, out nextIfd);
+        return dir;
+    }
+
+    // ---------------------------------------------------------------- accesso ai valori
+
+    public bool TryFind(ushort tag, out TiffEntry entry)
+    {
+        if (Exif.TryGetValue(tag, out entry)) return true;
+        if (Ifd0.TryGetValue(tag, out entry)) return true;
+        foreach (var sub in SubIfds)
+        {
+            if (sub.TryGetValue(tag, out entry)) return true;
+        }
+        entry = default;
+        return false;
+    }
+
+    public string? GetString(ushort tag)
+    {
+        if (!TryFind(tag, out var e)) return null;
+        if (e.Type is TiffType.Ascii or TiffType.Byte or TiffType.Undefined)
+            return View.GetAscii(e.ValuePosition, e.ByteLength);
+        // Alcuni firmware scrivono valori numerici dove ci si aspetta testo.
+        return TryGetDouble(tag, out double d) ? d.ToString(System.Globalization.CultureInfo.InvariantCulture) : null;
+    }
+
+    public bool TryGetUInt32(ushort tag, out uint value)
+    {
+        value = 0;
+        if (!TryFind(tag, out var e) || e.Count < 1) return false;
+        return TryReadScalarUInt(e, 0, out value);
+    }
+
+    private bool TryReadScalarUInt(in TiffEntry e, int index, out uint value)
+    {
+        value = 0;
+        long pos = e.ValuePosition + (long)index * TiffEntry.SizeOf(e.Type);
+        switch (e.Type)
+        {
+            case TiffType.Byte or TiffType.SByte or TiffType.Undefined:
+                if (!View.TryGetByte(pos, out byte b)) return false;
+                value = b; return true;
+            case TiffType.Short or TiffType.SShort:
+                if (!View.TryGetUInt16(pos, out ushort s)) return false;
+                value = s; return true;
+            case TiffType.Long or TiffType.SLong or TiffType.Ifd:
+                return View.TryGetUInt32(pos, out value);
+            default:
+                if (!TryReadIndexedDouble(e, index, out double d)) return false;
+                value = d is >= 0 and <= uint.MaxValue ? (uint)d : 0;
+                return true;
+        }
+    }
+
+    public bool TryGetDouble(ushort tag, out double value)
+    {
+        value = 0;
+        if (!TryFind(tag, out var e) || e.Count < 1) return false;
+        return TryReadIndexedDouble(e, 0, out value);
+    }
+
+    private bool TryReadIndexedDouble(in TiffEntry e, int index, out double value)
+    {
+        value = 0;
+        long pos = e.ValuePosition + (long)index * TiffEntry.SizeOf(e.Type);
+        switch (e.Type)
+        {
+            case TiffType.Rational:
+            {
+                if (!View.TryGetUInt32(pos, out uint num) || !View.TryGetUInt32(pos + 4, out uint den)) return false;
+                if (den == 0) { value = num == 0 ? 0 : double.PositiveInfinity; return num == 0; }
+                value = (double)num / den;
+                return true;
+            }
+            case TiffType.SRational:
+            {
+                if (!View.TryGetInt32(pos, out int num) || !View.TryGetInt32(pos + 4, out int den)) return false;
+                if (den == 0) return false;
+                value = (double)num / den;
+                return true;
+            }
+            case TiffType.Float:
+            {
+                if (!View.TryGetSingle(pos, out float f)) return false;
+                value = f; return true;
+            }
+            case TiffType.Double:
+                return View.TryGetDouble(pos, out value);
+            case TiffType.SShort:
+            {
+                if (!View.TryGetUInt16(pos, out ushort us)) return false;
+                value = (short)us; return true;
+            }
+            case TiffType.SLong:
+            {
+                if (!View.TryGetInt32(pos, out int i)) return false;
+                value = i; return true;
+            }
+            default:
+            {
+                if (!TryReadScalarUIntRaw(e.Type, pos, out uint u)) return false;
+                value = u; return true;
+            }
+        }
+    }
+
+    private bool TryReadScalarUIntRaw(TiffType type, long pos, out uint value)
+    {
+        value = 0;
+        switch (type)
+        {
+            case TiffType.Byte or TiffType.SByte or TiffType.Undefined:
+                if (!View.TryGetByte(pos, out byte b)) return false;
+                value = b; return true;
+            case TiffType.Short:
+                if (!View.TryGetUInt16(pos, out ushort s)) return false;
+                value = s; return true;
+            case TiffType.Long or TiffType.Ifd:
+                return View.TryGetUInt32(pos, out value);
+            default:
+                return false;
+        }
+    }
+
+    /// <summary>Primo valore non nullo di una lista di tag (utile per ISO, presente in più varianti).</summary>
+    public bool TryGetFirstUInt32(out uint value, params ushort[] tags)
+    {
+        foreach (ushort t in tags)
+        {
+            if (TryGetUInt32(t, out value) && value != 0) return true;
+        }
+        value = 0;
+        return false;
+    }
+}
+
+/// <summary>Numerazione dei tag TIFF/Exif effettivamente utilizzati dal motore.</summary>
+internal static class TiffTags
+{
+    public const ushort ImageWidth = 0x0100;
+    public const ushort ImageLength = 0x0101;
+    public const ushort Make = 0x010F;
+    public const ushort Model = 0x0110;
+    public const ushort Orientation = 0x0112;
+    public const ushort SubIfds = 0x014A;
+    public const ushort DateTime = 0x0132;
+    public const ushort XmpPacket = 0x02BC;
+
+    public const ushort ExposureTime = 0x829A;
+    public const ushort FNumber = 0x829D;
+    public const ushort ExifIfdPointer = 0x8769;
+    public const ushort IsoSpeedRatings = 0x8827;
+    public const ushort SensitivityType = 0x8830;
+    public const ushort RecommendedExposureIndex = 0x8832;
+    public const ushort IsoSpeed = 0x8833;
+    public const ushort GpsIfdPointer = 0x8825;
+
+    public const ushort DateTimeOriginal = 0x9003;
+    public const ushort DateTimeDigitized = 0x9004;
+    public const ushort OffsetTime = 0x9010;
+    public const ushort OffsetTimeOriginal = 0x9011;
+    public const ushort OffsetTimeDigitized = 0x9012;
+    public const ushort ShutterSpeedValue = 0x9201;
+    public const ushort ApertureValue = 0x9202;
+    public const ushort ExposureBiasValue = 0x9204;
+    public const ushort MeteringMode = 0x9207;
+    public const ushort FocalLength = 0x920A;
+    public const ushort SubSecTime = 0x9290;
+    public const ushort SubSecTimeOriginal = 0x9291;
+    public const ushort SubSecTimeDigitized = 0x9292;
+
+    public const ushort PixelXDimension = 0xA002;
+    public const ushort PixelYDimension = 0xA003;
+    public const ushort ExposureMode = 0xA402;
+    public const ushort WhiteBalance = 0xA403;
+    public const ushort LensModel = 0xA434;
+}

Titano/Metadata/TiffPrimitives.cs

@@ -0,0 +1,165 @@
+namespace Titano.Metadata;
+
+/// <summary>Tipi di dato definiti dalla specifica TIFF 6.0 / Exif 2.32.</summary>
+internal enum TiffType : ushort
+{
+    Unknown = 0,
+    Byte = 1,
+    Ascii = 2,
+    Short = 3,
+    Long = 4,
+    Rational = 5,
+    SByte = 6,
+    Undefined = 7,
+    SShort = 8,
+    SLong = 9,
+    SRational = 10,
+    Float = 11,
+    Double = 12,
+    Ifd = 13,
+}
+
+/// <summary>Voce di una IFD: 12 byte nel file, con il valore inline se occupa ≤ 4 byte.</summary>
+internal readonly struct TiffEntry
+{
+    public readonly ushort Tag;
+    public readonly TiffType Type;
+    public readonly uint Count;
+
+    /// <summary>Offset assoluto (rispetto all'inizio del blocco TIFF) dove risiede il valore.</summary>
+    public readonly long ValuePosition;
+
+    public TiffEntry(ushort tag, TiffType type, uint count, long valuePosition)
+    {
+        Tag = tag;
+        Type = type;
+        Count = count;
+        ValuePosition = valuePosition;
+    }
+
+    public static int SizeOf(TiffType type) => type switch
+    {
+        TiffType.Byte or TiffType.Ascii or TiffType.SByte or TiffType.Undefined => 1,
+        TiffType.Short or TiffType.SShort => 2,
+        TiffType.Long or TiffType.SLong or TiffType.Float or TiffType.Ifd => 4,
+        TiffType.Rational or TiffType.SRational or TiffType.Double => 8,
+        _ => 0,
+    };
+
+    public long ByteLength => (long)SizeOf(Type) * Count;
+}
+
+/// <summary>
+/// Lettore binario endian-aware su uno <see cref="ReadOnlySpan{T}"/> logico (buffer immutabile).
+/// Tutti gli accessi sono limitati: un file malformato produce valori assenti, mai eccezioni.
+/// </summary>
+internal readonly struct ByteView
+{
+    private readonly byte[] _data;
+    private readonly int _origin;
+    private readonly int _length;
+    public readonly bool BigEndian;
+
+    public ByteView(byte[] data, int origin, int length, bool bigEndian)
+    {
+        _data = data;
+        _origin = Math.Clamp(origin, 0, data.Length);
+        _length = Math.Clamp(length, 0, data.Length - _origin);
+        BigEndian = bigEndian;
+    }
+
+    public ByteView WithEndianness(bool bigEndian) => new(_data, _origin, _length, bigEndian);
+
+    public int Length => _length;
+
+    public bool InRange(long offset, long count)
+        => offset >= 0 && count >= 0 && offset + count <= _length;
+
+    public bool TryGetByte(long offset, out byte value)
+    {
+        if (!InRange(offset, 1)) { value = 0; return false; }
+        value = _data[_origin + (int)offset];
+        return true;
+    }
+
+    public bool TryGetUInt16(long offset, out ushort value)
+    {
+        value = 0;
+        if (!InRange(offset, 2)) return false;
+        int p = _origin + (int)offset;
+        value = BigEndian
+            ? (ushort)((_data[p] << 8) | _data[p + 1])
+            : (ushort)((_data[p + 1] << 8) | _data[p]);
+        return true;
+    }
+
+    public bool TryGetUInt32(long offset, out uint value)
+    {
+        value = 0;
+        if (!InRange(offset, 4)) return false;
+        int p = _origin + (int)offset;
+        value = BigEndian
+            ? ((uint)_data[p] << 24) | ((uint)_data[p + 1] << 16) | ((uint)_data[p + 2] << 8) | _data[p + 3]
+            : ((uint)_data[p + 3] << 24) | ((uint)_data[p + 2] << 16) | ((uint)_data[p + 1] << 8) | _data[p];
+        return true;
+    }
+
+    public bool TryGetInt32(long offset, out int value)
+    {
+        bool ok = TryGetUInt32(offset, out uint raw);
+        value = unchecked((int)raw);
+        return ok;
+    }
+
+    public bool TryGetSingle(long offset, out float value)
+    {
+        value = 0f;
+        if (!TryGetUInt32(offset, out uint raw)) return false;
+        value = BitConverter.UInt32BitsToSingle(raw);
+        return true;
+    }
+
+    public bool TryGetDouble(long offset, out double value)
+    {
+        value = 0d;
+        if (!InRange(offset, 8)) return false;
+        TryGetUInt32(offset, out uint a);
+        TryGetUInt32(offset + 4, out uint b);
+        ulong raw = BigEndian ? ((ulong)a << 32) | b : ((ulong)b << 32) | a;
+        value = BitConverter.UInt64BitsToDouble(raw);
+        return true;
+    }
+
+    public string? GetAscii(long offset, long count)
+    {
+        if (!InRange(offset, count) || count <= 0) return null;
+        int p = _origin + (int)offset;
+        int n = (int)count;
+        // Le stringhe Exif sono NUL-terminate; alcuni firmware riempiono di spazi.
+        int end = n;
+        for (int i = 0; i < n; i++)
+        {
+            if (_data[p + i] == 0) { end = i; break; }
+        }
+        while (end > 0 && (_data[p + end - 1] == ' ' || _data[p + end - 1] == '\t')) end--;
+        if (end <= 0) return null;
+        return System.Text.Encoding.Latin1.GetString(_data, p, end);
+    }
+
+    /// <summary>Ricerca di un pattern di byte; -1 se assente. Usata per i fallback di scansione.</summary>
+    public int IndexOf(ReadOnlySpan<byte> pattern, int startAt = 0)
+    {
+        if (pattern.Length == 0 || pattern.Length > _length) return -1;
+        var haystack = new ReadOnlySpan<byte>(_data, _origin, _length);
+        int idx = haystack[Math.Clamp(startAt, 0, _length)..].IndexOf(pattern);
+        return idx < 0 ? -1 : idx + Math.Clamp(startAt, 0, _length);
+    }
+
+    public byte[] ToArray(long offset, long count)
+    {
+        if (!InRange(offset, count) || count <= 0) return [];
+        var result = new byte[count];
+        Array.Copy(_data, _origin + (int)offset, result, 0, (int)count);
+        return result;
+    }
+}

Titano/Metadata/XmpScanner.cs

@@ -0,0 +1,149 @@
+using System.Globalization;
+
+namespace Titano.Metadata;
+
+/// <summary>
+/// Estrattore XMP minimale scritto in-house: non costruisce un albero XML, esegue una
+/// scansione lineare del packet cercando le proprietà utili sia in forma attributo
+/// (<c>xmp:CreateDate="..."</c>) sia in forma elemento (<c>&lt;xmp:CreateDate&gt;...&lt;/&gt;</c>).
+/// </summary>
+internal static class XmpScanner
+{
+    public readonly record struct XmpFields(
+        DateTime? CaptureTime,
+        TimeSpan? UtcOffset,
+        double? ExposureSeconds,
+        double? FNumber,
+        int? Iso);
+
+    private static readonly string[] DateProps = ["exif:DateTimeOriginal", "photoshop:DateCreated", "xmp:CreateDate"];
+
+    public static XmpFields Scan(string packet)
+    {
+        DateTime? time = null;
+        TimeSpan? offset = null;
+
+        foreach (string prop in DateProps)
+        {
+            string? raw = ReadProperty(packet, prop);
+            if (raw is null) continue;
+            if (TryParseIso8601(raw, out var local, out var off))
+            {
+                time = local;
+                offset = off;
+                break;
+            }
+        }
+
+        double? exposure = ReadRational(packet, "exif:ExposureTime");
+        double? fnumber = ReadRational(packet, "exif:FNumber");
+        if (fnumber is null && ReadRational(packet, "exif:ApertureValue") is { } apex)
+            fnumber = Math.Round(Math.Pow(2.0, apex / 2.0), 2);
+
+        int? iso = null;
+        // ISOSpeedRatings è tipicamente una rdf:Seq: prendiamo il primo <rdf:li>.
+        string? isoBlock = ReadProperty(packet, "exif:ISOSpeedRatings") ?? ReadProperty(packet, "exif:PhotographicSensitivity");
+        if (isoBlock is not null)
+        {
+            string digits = ExtractFirstNumber(isoBlock);
+            if (int.TryParse(digits, NumberStyles.Integer, CultureInfo.InvariantCulture, out int v) && v > 0) iso = v;
+        }
+
+        return new XmpFields(time, offset, exposure, fnumber, iso);
+    }
+
+    /// <summary>Individua un packet XMP dentro un buffer generico di testo/binario.</summary>
+    public static string? ExtractPacket(string text)
+    {
+        int start = text.IndexOf("<x:xmpmeta", StringComparison.Ordinal);
+        if (start < 0) start = text.IndexOf("<rdf:RDF", StringComparison.Ordinal);
+        if (start < 0) return null;
+        int end = text.IndexOf("</x:xmpmeta>", start, StringComparison.Ordinal);
+        if (end < 0) end = text.IndexOf("</rdf:RDF>", start, StringComparison.Ordinal);
+        if (end < 0) return text[start..];
+        return text[start..Math.Min(text.Length, end + 12)];
+    }
+
+    private static string? ReadProperty(string packet, string name)
+    {
+        // Forma attributo: name="value"
+        int idx = 0;
+        while ((idx = packet.IndexOf(name, idx, StringComparison.Ordinal)) >= 0)
+        {
+            int after = idx + name.Length;
+            if (after >= packet.Length) break;
+
+            char c = packet[after];
+            if (c == '=')
+            {
+                int q = packet.IndexOfAny(['"', '\''], after);
+                if (q < 0) break;
+                char quote = packet[q];
+                int close = packet.IndexOf(quote, q + 1);
+                if (close < 0) break;
+                return packet[(q + 1)..close];
+            }
+            if (c is '>' or ' ' or '\r' or '\n' or '\t' or '/')
+            {
+                int gt = packet.IndexOf('>', after);
+                if (gt < 0) break;
+                if (packet[gt - 1] == '/') { idx = after; continue; }   // elemento vuoto
+                int closeTag = packet.IndexOf("</" + name, gt, StringComparison.Ordinal);
+                if (closeTag < 0) break;
+                return packet[(gt + 1)..closeTag].Trim();
+            }
+            idx = after;
+        }
+        return null;
+    }
+
+    private static double? ReadRational(string packet, string name)
+    {
+        string? raw = ReadProperty(packet, name);
+        if (string.IsNullOrWhiteSpace(raw)) return null;
+        raw = raw.Trim();
+
+        int slash = raw.IndexOf('/');
+        if (slash > 0)
+        {
+            if (double.TryParse(raw[..slash], NumberStyles.Float, CultureInfo.InvariantCulture, out double n) &&
+                double.TryParse(raw[(slash + 1)..], NumberStyles.Float, CultureInfo.InvariantCulture, out double d) &&
+                d != 0)
+                return n / d;
+            return null;
+        }
+        return double.TryParse(raw, NumberStyles.Float, CultureInfo.InvariantCulture, out double v) ? v : null;
+    }
+
+    private static string ExtractFirstNumber(string text)
+    {
+        int i = 0;
+        while (i < text.Length && (text[i] < '0' || text[i] > '9')) i++;
+        int start = i;
+        while (i < text.Length && text[i] is >= '0' and <= '9') i++;
+        return start < i ? text[start..i] : string.Empty;
+    }
+
+    /// <summary>Parsing ISO-8601 ("2024-06-01T18:32:11.250+02:00") senza dipendere dal formattatore di sistema.</summary>
+    internal static bool TryParseIso8601(string text, out DateTime local, out TimeSpan? offset)
+    {
+        local = default;
+        offset = null;
+        text = text.Trim();
+        if (text.Length < 10) return false;
+
+        if (!DateTimeOffset.TryParse(text, CultureInfo.InvariantCulture,
+                DateTimeStyles.AssumeLocal | DateTimeStyles.AllowWhiteSpaces, out var dto))
+        {
+            // Fallback per date parziali "YYYY-MM-DD".
+            if (!DateTime.TryParseExact(text[..10], "yyyy-MM-dd", CultureInfo.InvariantCulture,
+                    DateTimeStyles.None, out local)) return false;
+            return true;
+        }
+
+        bool hasOffset = text.EndsWith('Z') || text.LastIndexOfAny(['+', '-']) > 10;
+        if (hasOffset) offset = dto.Offset;
+        local = DateTime.SpecifyKind(dto.DateTime, DateTimeKind.Unspecified);
+        return true;
+    }
+}

Titano/Modifiche.txt

@@ -0,0 +1,72 @@
+TITANO - registro delle modifiche
+=================================
+
+2026-08-13  Prima versione completa dell'applicazione.
+
+  Sviluppo da zero di Titano, applicazione desktop per time-lapse professionali,
+  con il vincolo di non usare alcuna libreria o strumento di terze parti.
+  Il progetto non contiene nessun PackageReference: oltre alla libreria standard
+  di .NET si usano solo API native di Windows richiamate via P/Invoke scritto a mano.
+
+  MODULI REALIZZATI
+
+  1. Ingestion e parsing metadati (Metadata/)
+     - Parser binario TIFF/Exif proprietario: header, catena di IFD, tutti i tipi
+       di dato della specifica, sotto-directory Exif e GPS.
+     - Riconoscimento dei contenitori: JPEG (percorso dei marker senza decodifica),
+       TIFF e RAW derivati, PNG (percorso dei chunk), HEIF/AVIF/WebP per scansione.
+     - Scanner XMP proprietario come sorgente complementare.
+     - Timestamp con frazione di secondo (SubSecTimeOriginal) e fuso orario;
+       tempo di posa, apertura e ISO anche nelle varianti APEX.
+     - Calcolo degli intervalli reali, cadenza nominale mediana e segnalazione
+       delle pause dell'intervallometro.
+
+  2. Deflicker e smoothing dell'esposizione (Analysis/)
+     - Misura della luminanza come media logaritmica troncata su istogramma,
+       calcolata in luce lineare su campionamento a griglia fissa.
+     - Curva target da regressione lineare locale pesata su finestra mobile, con
+       seconda passata robusta (peso di Tukey) che scarta i fotogrammi anomali.
+       Le rampe reali di luce restano intatte, lo sfarfallio viene rimosso.
+     - Applicazione dei guadagni con compressione dolce delle alte luci e
+       stabilizzazione opzionale del bilanciamento colore.
+
+  3. Motion blur sintetico e interpolazione (Motion/)
+     - Optical flow proprietario: piramide gaussiana e schema differenziale
+       iterativo su griglia rada, con filtro mediano fra i livelli.
+     - Shutter angle reale per fotogramma; sfocatura mancante composta in
+       quadratura e resa con filtro di ricostruzione direzionale.
+     - Interpolazione temporale con warping bidirezionale per uniformare la
+       cadenza e gestire in modo adattivo la durata dei fotogrammi.
+
+  4. Streaming ed encoding video (Video/)
+     - Multiplexer MP4 (ISO-BMFF) scritto da zero: ftyp, mdat in streaming con
+       dimensione a 64 bit, moov completo con stts a durate variabili, stss,
+       stsz, co64, avcC/hvcC costruiti dai parameter set del bitstream.
+     - Encoder pilotato direttamente come Media Foundation Transform, con
+       percorso asincrono per le trasformazioni hardware (Intel/AMD/NVIDIA)
+       e ripiego automatico su quelle software.
+     - Conversione RGB lineare a NV12 BT.709 scritta in-house.
+
+  5. Interfaccia (UI/)
+     - Tema scuro con ogni controllo disegnato a mano in GDI+: pulsanti,
+       interruttori, cursori, schede, barra di avanzamento.
+     - Grafico vettoriale della curva di esposizione: luminanza misurata
+       sovrapposta alla curva target, area di correzione, corsia dei guadagni,
+       fasce delle anomalie di cadenza, zoom, spostamento e tooltip.
+     - Tabella dei fotogrammi a rendering virtuale.
+     - Pannello di configurazione in tre sezioni: Generale, Elaborazione
+       immagini, Esportazione video.
+     - Anteprima elaborata dallo stesso motore usato in esportazione.
+
+  ARCHITETTURA
+     - Nessun file temporaneo: i dati passano fra le fasi solo in memoria, l'unica
+       scrittura su disco è il flusso compresso finale.
+     - Impronta di memoria costante: buffer poolati e canale a capacità limitata,
+       l'occupazione non dipende dal numero di fotogrammi della sequenza.
+     - Thread di calcolo separati dal thread dell'interfaccia.
+
+  VERIFICA
+     Comando "Titano.exe --selftest": genera una sequenza sintetica dalle
+     proprietà note e la fa attraversare l'intera pipeline confrontando 23
+     grandezze con i valori attesi. Tutte superate, compresa la ri-decodifica
+     del file prodotto con il lettore di sistema.

Titano/Motion/FrameInterpolator.cs

@@ -0,0 +1,48 @@
+using Titano.Imaging;
+
+namespace Titano.Motion;
+
+/// <summary>
+/// Interpolazione temporale fra due fotogrammi guidata dal campo vettoriale.
+///
+/// Si usa il warping all'indietro bidirezionale: l'istante t viene ricostruito prelevando da
+/// A lungo −t·v e da B lungo +(1−t)·v, poi i due contributi vengono miscelati con pesi
+/// complementari. Il warping all'indietro non lascia buchi (a differenza di quello in avanti)
+/// e la miscelazione incrociata attenua gli errori del campo nelle zone di occlusione.
+/// </summary>
+public static class FrameInterpolator
+{
+    /// <summary>Genera il fotogramma all'istante <paramref name="t"/> ∈ [0,1] fra A e B.</summary>
+    public static void Interpolate(ImageBuffer a, ImageBuffer b, MotionField flowAtoB,
+                                   float t, ImageBuffer destination)
+    {
+        if (t <= 0f) { destination.CopyFrom(a); return; }
+        if (t >= 1f) { destination.CopyFrom(b); return; }
+
+        int width = a.Width;
+        int height = a.Height;
+        var srcA = a.Data;
+        var srcB = b.Data;
+        var dst = destination.Data;
+        float wa = 1f - t;
+
+        Parallel.For(0, height, y =>
+        {
+            int rowBase = y * width * ImageBuffer.Channels;
+            for (int x = 0; x < width; x++)
+            {
+                int index = rowBase + x * ImageBuffer.Channels;
+                flowAtoB.Sample(x, y, out float vx, out float vy);
+
+                MotionBlurRenderer.SampleBilinear(srcA, width, height, x - vx * t, y - vy * t,
+                                                  out float ar, out float ag, out float ab);
+                MotionBlurRenderer.SampleBilinear(srcB, width, height, x + vx * wa, y + vy * wa,
+                                                  out float br, out float bg, out float bb);
+
+                dst[index] = ar * wa + br * t;
+                dst[index + 1] = ag * wa + bg * t;
+                dst[index + 2] = ab * wa + bb * t;
+            }
+        });
+    }
+}

Titano/Motion/GrayPyramid.cs

@@ -0,0 +1,145 @@
+using System.Runtime.CompilerServices;
+using Titano.Imaging;
+
+namespace Titano.Motion;
+
+/// <summary>Piano di luminanza percettiva a precisione singola, con campionamento bilineare.</summary>
+public sealed class GrayImage(int width, int height)
+{
+    public int Width { get; } = width;
+    public int Height { get; } = height;
+    public float[] Data { get; } = new float[width * height];
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float At(int x, int y)
+    {
+        x = x < 0 ? 0 : x >= Width ? Width - 1 : x;
+        y = y < 0 ? 0 : y >= Height ? Height - 1 : y;
+        return Data[y * Width + x];
+    }
+
+    /// <summary>Campionamento bilineare con estensione dei bordi.</summary>
+    public float Sample(float x, float y)
+    {
+        int x0 = (int)MathF.Floor(x);
+        int y0 = (int)MathF.Floor(y);
+        float fx = x - x0;
+        float fy = y - y0;
+
+        float a = At(x0, y0);
+        float b = At(x0 + 1, y0);
+        float c = At(x0, y0 + 1);
+        float d = At(x0 + 1, y0 + 1);
+
+        float top = a + (b - a) * fx;
+        float bottom = c + (d - c) * fx;
+        return top + (bottom - top) * fy;
+    }
+}
+
+/// <summary>
+/// Piramide gaussiana costruita in-house.
+///
+/// Il livello 0 è la luminanza dell'immagine ridotta alla risoluzione di analisi: il campo di
+/// movimento non richiede la piena risoluzione e lavorare in scala ridotta rende il costo
+/// dell'optical flow indipendente dalla dimensione dei file sorgente.
+/// La luminanza viene ricodificata in gamma percettiva, perché in luce lineare i gradienti
+/// delle zone scure sarebbero numericamente trascurabili rispetto alle alte luci.
+/// </summary>
+public sealed class GrayPyramid
+{
+    public GrayImage[] Levels { get; }
+
+    /// <summary>Rapporto fra la risoluzione di analisi (livello 0) e quella dell'immagine originale.</summary>
+    public float AnalysisScale { get; }
+
+    private GrayPyramid(GrayImage[] levels, float analysisScale)
+    {
+        Levels = levels;
+        AnalysisScale = analysisScale;
+    }
+
+    public int LevelCount => Levels.Length;
+
+    public static GrayPyramid Build(ImageBuffer frame, int maxAnalysisWidth, int requestedLevels)
+    {
+        float scale = Math.Min(1f, maxAnalysisWidth / (float)frame.Width);
+        int w = Math.Max(16, (int)MathF.Round(frame.Width * scale));
+        int h = Math.Max(16, (int)MathF.Round(frame.Height * scale));
+        scale = w / (float)frame.Width;
+
+        var level0 = new GrayImage(w, h);
+        Downsample(frame, level0);
+
+        int levels = Math.Clamp(requestedLevels, 1, 6);
+        while (levels > 1 && (w >> (levels - 1)) < 24) levels--;
+
+        var all = new GrayImage[levels];
+        all[0] = level0;
+        for (int i = 1; i < levels; i++) all[i] = HalveWithBlur(all[i - 1]);
+
+        return new GrayPyramid(all, scale);
+    }
+
+    /// <summary>Riduzione da RGB lineare a luminanza percettiva con media d'area (box filter).</summary>
+    private static void Downsample(ImageBuffer source, GrayImage destination)
+    {
+        int sw = source.Width, sh = source.Height;
+        int dw = destination.Width, dh = destination.Height;
+        var src = source.Data;
+        var dst = destination.Data;
+
+        float xRatio = sw / (float)dw;
+        float yRatio = sh / (float)dh;
+
+        Parallel.For(0, dh, dy =>
+        {
+            int y0 = (int)(dy * yRatio);
+            int y1 = Math.Max(y0 + 1, Math.Min(sh, (int)((dy + 1) * yRatio)));
+
+            for (int dx = 0; dx < dw; dx++)
+            {
+                int x0 = (int)(dx * xRatio);
+                int x1 = Math.Max(x0 + 1, Math.Min(sw, (int)((dx + 1) * xRatio)));
+
+                float sum = 0;
+                int count = 0;
+                for (int y = y0; y < y1; y++)
+                {
+                    int rowBase = y * sw * ImageBuffer.Channels;
+                    for (int x = x0; x < x1; x++)
+                    {
+                        int i = rowBase + x * ImageBuffer.Channels;
+                        sum += ColorSpace.Luminance(src[i], src[i + 1], src[i + 2]);
+                        count++;
+                    }
+                }
+                dst[dy * dw + dx] = ColorSpace.ToSrgb(count > 0 ? sum / count : 0f);
+            }
+        });
+    }
+
+    /// <summary>Dimezzamento con kernel binomiale 1-2-1 separabile.</summary>
+    private static GrayImage HalveWithBlur(GrayImage source)
+    {
+        int w = Math.Max(1, source.Width / 2);
+        int h = Math.Max(1, source.Height / 2);
+        var result = new GrayImage(w, h);
+        var dst = result.Data;
+
+        for (int y = 0; y < h; y++)
+        {
+            int sy = y * 2;
+            for (int x = 0; x < w; x++)
+            {
+                int sx = x * 2;
+                float sum =
+                      source.At(sx - 1, sy - 1) + 2 * source.At(sx, sy - 1) + source.At(sx + 1, sy - 1)
+                    + 2 * source.At(sx - 1, sy) + 4 * source.At(sx, sy) + 2 * source.At(sx + 1, sy)
+                    + source.At(sx - 1, sy + 1) + 2 * source.At(sx, sy + 1) + source.At(sx + 1, sy + 1);
+                dst[y * w + x] = sum / 16f;
+            }
+        }
+        return result;
+    }
+}

Titano/Motion/MotionBlurRenderer.cs

@@ -0,0 +1,194 @@
+using System.Runtime.CompilerServices;
+using Titano.Imaging;
+
+namespace Titano.Motion;
+
+/// <summary>Parametri del motion blur sintetico, esposti nel pannello "Elaborazione immagini".</summary>
+public sealed class MotionBlurSettings
+{
+    public bool Enabled { get; set; } = true;
+
+    /// <summary>Shutter angle desiderato: 180° è la convenzione cinematografica.</summary>
+    public double TargetShutterAngle { get; set; } = 180.0;
+
+    /// <summary>Quota della sfocatura mancante effettivamente sintetizzata.</summary>
+    public double Strength { get; set; } = 1.0;
+
+    /// <summary>Limite superiore della scia, in pixel: protegge dalle stime di movimento errate.</summary>
+    public double MaxBlurPixels { get; set; } = 48.0;
+
+    /// <summary>Numero massimo di campioni per pixel lungo la scia.</summary>
+    public int MaxSamples { get; set; } = 25;
+
+    public MotionBlurSettings Clone() => (MotionBlurSettings)MemberwiseClone();
+}
+
+/// <summary>
+/// Motion blur direzionale sintetico lungo il campo vettoriale.
+///
+/// Il fattore di sfocatura mancante deriva dalla composizione delle varianze: la scia
+/// realmente incisa nel fotogramma (proporzionale allo shutter angle di scatto) e quella
+/// sintetica si sommano in quadratura, quindi per raggiungere l'apertura obiettivo serve
+/// una scia lunga √(target² − reale²) volte lo spostamento. Sommare linearmente
+/// produrrebbe un'immagine sistematicamente troppo morbida.
+///
+/// Il filtro di ricostruzione è di tipo "gather": ogni campione contribuisce al pixel
+/// centrale solo se la propria scia lo raggiunge davvero, così lo sfondo fermo non viene
+/// trascinato dentro i soggetti in movimento.
+/// </summary>
+public static class MotionBlurRenderer
+{
+    /// <summary>
+    /// Frazione di spostamento da sintetizzare per portare <paramref name="actualAngle"/>
+    /// al valore <paramref name="targetAngle"/>. Zero se il fotogramma è già abbastanza mosso.
+    /// </summary>
+    public static double MissingBlurFactor(double actualAngle, double targetAngle, double strength)
+    {
+        double target = Math.Clamp(targetAngle, 0, 360) / 360.0;
+        double actual = Math.Clamp(actualAngle, 0, 360) / 360.0;
+        if (target <= actual) return 0;
+        return Math.Sqrt(target * target - actual * actual) * Math.Clamp(strength, 0, 1);
+    }
+
+    /// <summary>
+    /// Applica la sfocatura da <paramref name="source"/> a <paramref name="destination"/>.
+    /// Restituisce la lunghezza media della scia effettivamente resa, in pixel.
+    /// </summary>
+    public static double Render(ImageBuffer source, ImageBuffer destination, MotionField field,
+                                double missingFactor, MotionBlurSettings settings)
+    {
+        if (missingFactor <= 1e-4)
+        {
+            destination.CopyFrom(source);
+            return 0;
+        }
+
+        int width = source.Width;
+        int height = source.Height;
+        float factor = (float)missingFactor;
+        float maxBlur = (float)Math.Max(1.0, settings.MaxBlurPixels);
+        int maxSamples = Math.Clamp(settings.MaxSamples, 3, 129);
+
+        var src = source.Data;
+        var dst = destination.Data;
+        double lengthSum = 0;
+        object sumLock = new();
+
+        Parallel.For(0, height, () => 0.0, (y, _, localSum) =>
+        {
+            int rowBase = y * width * ImageBuffer.Channels;
+
+            for (int x = 0; x < width; x++)
+            {
+                int index = rowBase + x * ImageBuffer.Channels;
+                field.Sample(x, y, out float vx, out float vy);
+
+                float magnitude = MathF.Sqrt(vx * vx + vy * vy);
+                float length = Math.Min(magnitude * factor, maxBlur);
+                localSum += length;
+
+                if (length < 0.5f || magnitude < 1e-4f)
+                {
+                    dst[index] = src[index];
+                    dst[index + 1] = src[index + 1];
+                    dst[index + 2] = src[index + 2];
+                    continue;
+                }
+
+                float dirX = vx / magnitude;
+                float dirY = vy / magnitude;
+                float half = length * 0.5f;
+
+                int taps = Math.Min(maxSamples, Math.Max(3, (int)MathF.Ceiling(length) | 1));
+                int side = taps / 2;
+                float step = half / side;
+
+                // Il pixel centrale è sempre presente: garantisce continuità con le zone ferme.
+                float accR = src[index], accG = src[index + 1], accB = src[index + 2];
+                float weightSum = 1f;
+
+                for (int k = 1; k <= side; k++)
+                {
+                    float offset = k * step;
+
+                    weightSum += Accumulate(src, field, width, height, x, y,
+                                            dirX, dirY, offset, factor, maxBlur, ref accR, ref accG, ref accB);
+                    weightSum += Accumulate(src, field, width, height, x, y,
+                                            dirX, dirY, -offset, factor, maxBlur, ref accR, ref accG, ref accB);
+                }
+
+                float inv = 1f / weightSum;
+                dst[index] = accR * inv;
+                dst[index + 1] = accG * inv;
+                dst[index + 2] = accB * inv;
+            }
+
+            return localSum;
+        },
+        localSum =>
+        {
+            lock (sumLock) lengthSum += localSum;
+        });
+
+        return lengthSum / Math.Max(1, (long)width * height);
+    }
+
+    /// <summary>
+    /// Aggiunge il contributo del campione spostato di <paramref name="offset"/> lungo la scia.
+    /// Il peso vale 1 solo se il movimento proprio del campione arriva a coprire il pixel centrale.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float Accumulate(float[] src, MotionField field, int width, int height,
+                                    int x, int y, float dirX, float dirY, float offset,
+                                    float factor, float maxBlur,
+                                    ref float accR, ref float accG, ref float accB)
+    {
+        float sx = x + dirX * offset;
+        float sy = y + dirY * offset;
+        if (sx < 0 || sy < 0 || sx > width - 1 || sy > height - 1) return 0f;
+
+        field.Sample(sx, sy, out float tvx, out float tvy);
+        float projection = MathF.Abs(tvx * dirX + tvy * dirY) * factor * 0.5f;
+        projection = MathF.Min(projection, maxBlur * 0.5f);
+
+        // Transizione morbida su un pixel: evita i gradini sui bordi della scia.
+        float weight = projection - MathF.Abs(offset) + 1f;
+        if (weight <= 0f) return 0f;
+        if (weight > 1f) weight = 1f;
+
+        SampleBilinear(src, width, height, sx, sy, out float r, out float g, out float b);
+        accR += r * weight;
+        accG += g * weight;
+        accB += b * weight;
+        return weight;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static void SampleBilinear(float[] data, int width, int height, float x, float y,
+                                        out float r, out float g, out float b)
+    {
+        if (x < 0) x = 0; else if (x > width - 1) x = width - 1;
+        if (y < 0) y = 0; else if (y > height - 1) y = height - 1;
+
+        int x0 = (int)x;
+        int y0 = (int)y;
+        int x1 = x0 + 1 < width ? x0 + 1 : x0;
+        int y1 = y0 + 1 < height ? y0 + 1 : y0;
+        float fx = x - x0;
+        float fy = y - y0;
+
+        int i00 = (y0 * width + x0) * ImageBuffer.Channels;
+        int i10 = (y0 * width + x1) * ImageBuffer.Channels;
+        int i01 = (y1 * width + x0) * ImageBuffer.Channels;
+        int i11 = (y1 * width + x1) * ImageBuffer.Channels;
+
+        float w00 = (1 - fx) * (1 - fy);
+        float w10 = fx * (1 - fy);
+        float w01 = (1 - fx) * fy;
+        float w11 = fx * fy;
+
+        r = data[i00] * w00 + data[i10] * w10 + data[i01] * w01 + data[i11] * w11;
+        g = data[i00 + 1] * w00 + data[i10 + 1] * w10 + data[i01 + 1] * w01 + data[i11 + 1] * w11;
+        b = data[i00 + 2] * w00 + data[i10 + 2] * w10 + data[i01 + 2] * w01 + data[i11 + 2] * w11;
+    }
+}

Titano/Motion/MotionField.cs

@@ -0,0 +1,103 @@
+using System.Runtime.CompilerServices;
+
+namespace Titano.Motion;
+
+/// <summary>
+/// Campo vettoriale di movimento memorizzato su griglia rada: un nodo ogni
+/// <see cref="CellSize"/> pixel dell'immagine a piena risoluzione. I vettori sono espressi
+/// in pixel di spostamento fra il fotogramma corrente e il successivo.
+///
+/// La griglia rada mantiene l'occupazione trascurabile (per un 4K con celle da 16 px sono
+/// ~260 KB) e la lettura bilineare restituisce comunque un campo continuo per-pixel.
+/// </summary>
+public sealed class MotionField
+{
+    public int GridWidth { get; }
+    public int GridHeight { get; }
+
+    /// <summary>Passo della griglia in pixel dell'immagine a piena risoluzione (può non essere intero).</summary>
+    public float CellSize { get; }
+
+    public int ImageWidth { get; }
+    public int ImageHeight { get; }
+
+    public float[] Vx { get; }
+    public float[] Vy { get; }
+
+    public MotionField(int imageWidth, int imageHeight, float cellSize)
+        : this(imageWidth, imageHeight, cellSize,
+               Math.Max(2, (int)Math.Ceiling(imageWidth / Math.Max(1f, cellSize)) + 1),
+               Math.Max(2, (int)Math.Ceiling(imageHeight / Math.Max(1f, cellSize)) + 1))
+    {
+    }
+
+    internal MotionField(int imageWidth, int imageHeight, float cellSize, int gridWidth, int gridHeight)
+    {
+        ImageWidth = imageWidth;
+        ImageHeight = imageHeight;
+        CellSize = Math.Max(1f, cellSize);
+        GridWidth = Math.Max(2, gridWidth);
+        GridHeight = Math.Max(2, gridHeight);
+        Vx = new float[GridWidth * GridHeight];
+        Vy = new float[GridWidth * GridHeight];
+    }
+
+    public int NodeCount => GridWidth * GridHeight;
+
+    /// <summary>Campionamento bilineare del campo in coordinate immagine.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Sample(float x, float y, out float vx, out float vy)
+    {
+        float gx = x / CellSize;
+        float gy = y / CellSize;
+
+        int x0 = (int)gx;
+        int y0 = (int)gy;
+        float fx = gx - x0;
+        float fy = gy - y0;
+
+        if (x0 < 0) { x0 = 0; fx = 0; }
+        if (y0 < 0) { y0 = 0; fy = 0; }
+        if (x0 >= GridWidth - 1) { x0 = GridWidth - 2; fx = 1; }
+        if (y0 >= GridHeight - 1) { y0 = GridHeight - 2; fy = 1; }
+
+        int i00 = y0 * GridWidth + x0;
+        int i10 = i00 + 1;
+        int i01 = i00 + GridWidth;
+        int i11 = i01 + 1;
+
+        float w00 = (1 - fx) * (1 - fy);
+        float w10 = fx * (1 - fy);
+        float w01 = (1 - fx) * fy;
+        float w11 = fx * fy;
+
+        vx = Vx[i00] * w00 + Vx[i10] * w10 + Vx[i01] * w01 + Vx[i11] * w11;
+        vy = Vy[i00] * w00 + Vy[i10] * w10 + Vy[i01] * w01 + Vy[i11] * w11;
+    }
+
+    /// <summary>Modulo mediano dei vettori: stima robusta dell'entità del movimento.</summary>
+    public double MedianMagnitude()
+    {
+        int n = NodeCount;
+        if (n == 0) return 0;
+        var magnitudes = new float[n];
+        for (int i = 0; i < n; i++) magnitudes[i] = MathF.Sqrt(Vx[i] * Vx[i] + Vy[i] * Vy[i]);
+        Array.Sort(magnitudes);
+        return magnitudes[n / 2];
+    }
+
+    /// <summary>Direzione dominante del campo, in gradi, pesata sul modulo dei vettori.</summary>
+    public double DominantDirection()
+    {
+        double sx = 0, sy = 0;
+        for (int i = 0; i < Vx.Length; i++)
+        {
+            float m = MathF.Sqrt(Vx[i] * Vx[i] + Vy[i] * Vy[i]);
+            sx += Vx[i] * m;
+            sy += Vy[i] * m;
+        }
+        if (Math.Abs(sx) < 1e-6 && Math.Abs(sy) < 1e-6) return 0;
+        double deg = Math.Atan2(sy, sx) * 180.0 / Math.PI;
+        return deg < 0 ? deg + 360 : deg;
+    }
+}

Titano/Motion/OpticalFlowEngine.cs

@@ -0,0 +1,194 @@
+using Titano.Imaging;
+
+namespace Titano.Motion;
+
+/// <summary>Parametri del calcolo del campo vettoriale.</summary>
+public sealed class OpticalFlowSettings
+{
+    /// <summary>Larghezza massima a cui viene condotta l'analisi del movimento.</summary>
+    public int AnalysisWidth { get; set; } = 960;
+
+    /// <summary>Passo della griglia di nodi, in pixel della risoluzione di analisi.</summary>
+    public int CellSize { get; set; } = 8;
+
+    /// <summary>Livelli della piramide: determina lo spostamento massimo inseguibile.</summary>
+    public int PyramidLevels { get; set; } = 4;
+
+    /// <summary>Semi-lato della finestra di correlazione.</summary>
+    public int WindowRadius { get; set; } = 6;
+
+    /// <summary>Iterazioni di raffinamento per livello.</summary>
+    public int Iterations { get; set; } = 5;
+
+    /// <summary>Regolarizzazione del sistema normale: stabilizza le zone senza tessitura.</summary>
+    public double Regularization { get; set; } = 1e-4;
+
+    public OpticalFlowSettings Clone() => (OpticalFlowSettings)MemberwiseClone();
+}
+
+/// <summary>
+/// Calcolo del campo di movimento fra due fotogrammi adiacenti, implementato interamente
+/// in-house con uno schema differenziale piramidale (famiglia Lucas–Kanade).
+///
+/// Su ogni nodo della griglia si risolve iterativamente il sistema normale 2×2
+/// costruito dai gradienti spaziali del primo fotogramma e dalla differenza temporale
+/// rispetto al secondo, ricampionato secondo la stima corrente. La piramide permette di
+/// inseguire spostamenti ampi (nuvole, stelle, folla) partendo dai livelli grossolani;
+/// un filtro mediano fra un livello e l'altro elimina i vettori spuri delle zone piatte.
+/// </summary>
+public sealed class OpticalFlowEngine(OpticalFlowSettings settings)
+{
+    private readonly OpticalFlowSettings _settings = settings;
+
+    /// <summary>
+    /// Calcola il campo dal fotogramma <paramref name="current"/> verso <paramref name="next"/>.
+    /// I vettori restituiti sono espressi in pixel dell'immagine a piena risoluzione.
+    /// </summary>
+    public MotionField Compute(ImageBuffer current, ImageBuffer next)
+    {
+        var a = GrayPyramid.Build(current, _settings.AnalysisWidth, _settings.PyramidLevels);
+        var b = GrayPyramid.Build(next, _settings.AnalysisWidth, _settings.PyramidLevels);
+        return Compute(a, b, current.Width, current.Height);
+    }
+
+    public MotionField Compute(GrayPyramid a, GrayPyramid b, int fullWidth, int fullHeight)
+    {
+        int levels = Math.Min(a.LevelCount, b.LevelCount);
+        int cell = Math.Max(2, _settings.CellSize);
+
+        var baseLevel = a.Levels[0];
+        int gw = Math.Max(2, baseLevel.Width / cell + 1);
+        int gh = Math.Max(2, baseLevel.Height / cell + 1);
+
+        var vx = new float[gw * gh];
+        var vy = new float[gw * gh];
+
+        for (int level = levels - 1; level >= 0; level--)
+        {
+            float levelScale = 1f / (1 << level);
+            RefineLevel(a.Levels[level], b.Levels[level], vx, vy, gw, gh, cell * levelScale);
+            MedianFilter(vx, vy, gw, gh);
+
+            if (level > 0)
+            {
+                // Passando a un livello di risoluzione doppia raddoppia anche lo spostamento.
+                for (int i = 0; i < vx.Length; i++) { vx[i] *= 2f; vy[i] *= 2f; }
+            }
+        }
+
+        // Conversione dalle unità della risoluzione di analisi a quelle dell'immagine piena.
+        float toFull = a.AnalysisScale > 0 ? 1f / a.AnalysisScale : 1f;
+        var field = new MotionField(fullWidth, fullHeight, cell * toFull, gw, gh);
+        for (int i = 0; i < vx.Length; i++)
+        {
+            field.Vx[i] = vx[i] * toFull;
+            field.Vy[i] = vy[i] * toFull;
+        }
+        return field;
+    }
+
+    /// <summary>Raffina la stima corrente su un livello della piramide.</summary>
+    private void RefineLevel(GrayImage a, GrayImage b, float[] vx, float[] vy,
+                             int gridWidth, int gridHeight, float nodeSpacing)
+    {
+        int radius = Math.Max(2, _settings.WindowRadius);
+        int iterations = Math.Max(1, _settings.Iterations);
+        double lambda = Math.Max(0, _settings.Regularization);
+        float maxStep = Math.Max(4f, radius * 1.5f);
+
+        Parallel.For(0, gridHeight, gy =>
+        {
+            float py = gy * nodeSpacing;
+
+            for (int gx = 0; gx < gridWidth; gx++)
+            {
+                float px = gx * nodeSpacing;
+                int node = gy * gridWidth + gx;
+                float u = vx[node];
+                float v = vy[node];
+
+                for (int iter = 0; iter < iterations; iter++)
+                {
+                    double sxx = lambda, sxy = 0, syy = lambda, sxt = 0, syt = 0;
+
+                    for (int wy = -radius; wy <= radius; wy++)
+                    {
+                        float sy = py + wy;
+                        for (int wx = -radius; wx <= radius; wx++)
+                        {
+                            float sx = px + wx;
+
+                            // Gradiente spaziale del primo fotogramma (differenze centrali).
+                            float ix = (a.Sample(sx + 1, sy) - a.Sample(sx - 1, sy)) * 0.5f;
+                            float iy = (a.Sample(sx, sy + 1) - a.Sample(sx, sy - 1)) * 0.5f;
+                            // Differenza temporale con il secondo fotogramma ricampionato.
+                            float it = b.Sample(sx + u, sy + v) - a.Sample(sx, sy);
+
+                            sxx += ix * ix;
+                            sxy += ix * iy;
+                            syy += iy * iy;
+                            sxt += ix * it;
+                            syt += iy * it;
+                        }
+                    }
+
+                    double det = sxx * syy - sxy * sxy;
+                    if (Math.Abs(det) < 1e-12) break;
+
+                    // Soluzione del sistema normale: d = -A⁻¹·b
+                    double du = -(syy * sxt - sxy * syt) / det;
+                    double dv = -(sxx * syt - sxy * sxt) / det;
+
+                    if (double.IsNaN(du) || double.IsNaN(dv)) break;
+
+                    du = Math.Clamp(du, -maxStep, maxStep);
+                    dv = Math.Clamp(dv, -maxStep, maxStep);
+
+                    u += (float)du;
+                    v += (float)dv;
+
+                    if (Math.Abs(du) < 0.01 && Math.Abs(dv) < 0.01) break;
+                }
+
+                // Vincolo fisico: nessun punto può uscire di più dell'intera immagine.
+                vx[node] = Math.Clamp(u, -a.Width, a.Width);
+                vy[node] = Math.Clamp(v, -a.Height, a.Height);
+            }
+        });
+    }
+
+    private static void MedianFilter(float[] vx, float[] vy, int gridWidth, int gridHeight)
+    {
+        var ox = (float[])vx.Clone();
+        var oy = (float[])vy.Clone();
+        Span<float> wx = stackalloc float[9];
+        Span<float> wy = stackalloc float[9];
+
+        for (int gy = 0; gy < gridHeight; gy++)
+        {
+            for (int gx = 0; gx < gridWidth; gx++)
+            {
+                int n = 0;
+                for (int dy = -1; dy <= 1; dy++)
+                {
+                    int yy = gy + dy;
+                    if (yy < 0 || yy >= gridHeight) continue;
+                    for (int dx = -1; dx <= 1; dx++)
+                    {
+                        int xx = gx + dx;
+                        if (xx < 0 || xx >= gridWidth) continue;
+                        int idx = yy * gridWidth + xx;
+                        wx[n] = ox[idx];
+                        wy[n] = oy[idx];
+                        n++;
+                    }
+                }
+                wx[..n].Sort();
+                wy[..n].Sort();
+                int center = gy * gridWidth + gx;
+                vx[center] = wx[n / 2];
+                vy[center] = wy[n / 2];
+            }
+        }
+    }
+}

Titano/Pipeline/PipelineProgress.cs

@@ -0,0 +1,33 @@
+namespace Titano.Pipeline;
+
+public enum PipelinePhase
+{
+    Ingestion,
+    Analysis,
+    Rendering,
+    Finalizing,
+    Completed,
+    Failed,
+}
+
+/// <summary>Stato d'avanzamento pubblicato verso l'interfaccia; immutabile e sicuro da marshalare.</summary>
+public readonly record struct PipelineProgress(
+    PipelinePhase Phase,
+    int Completed,
+    int Total,
+    string Message,
+    double FramesPerSecond = 0,
+    TimeSpan Remaining = default)
+{
+    public double Fraction => Total <= 0 ? 0 : Math.Clamp(Completed / (double)Total, 0, 1);
+}
+
+/// <summary>Esito di una esportazione completata.</summary>
+public sealed record RenderResult(
+    string OutputPath,
+    int EncodedFrames,
+    long OutputBytes,
+    TimeSpan Elapsed,
+    string EncoderName,
+    bool HardwareAccelerated,
+    long PeakPixelMemoryBytes);

Titano/Pipeline/RenderPipeline.cs

@@ -0,0 +1,441 @@
+using System.Diagnostics;
+using System.Threading.Channels;
+using Titano.Analysis;
+using Titano.Core;
+using Titano.Imaging;
+using Titano.Metadata;
+using Titano.Motion;
+using Titano.Video;
+
+namespace Titano.Pipeline;
+
+/// <summary>
+/// Orchestrazione delle fasi di lavoro.
+///
+/// Architettura a flusso: i fotogrammi vengono decodificati da più thread e consegnati in
+/// ordine attraverso un canale a capacità limitata. Il limite del canale coincide con il
+/// numero di decodifiche simultanee, quindi il numero di buffer vivi — e con esso
+/// l'occupazione di memoria — resta costante qualunque sia la lunghezza della sequenza.
+/// Nessuna fase scrive su disco: l'unico file prodotto è il video finale.
+/// </summary>
+public sealed class RenderPipeline(TitanoProject project)
+{
+    private readonly TitanoProject _project = project;
+
+    // ------------------------------------------------------------------ ingestion
+
+    /// <summary>Legge i metadati dei file indicati e costruisce la sequenza ordinata.</summary>
+    public static async Task<TimelapseSequence> IngestAsync(IReadOnlyList<string> paths,
+                                                            double cadenceTolerance,
+                                                            IProgress<PipelineProgress>? progress,
+                                                            CancellationToken cancellation)
+    {
+        var metadata = new FrameMetadata[paths.Count];
+        int done = 0;
+
+        await Task.Run(() =>
+        {
+            var options = new ParallelOptions
+            {
+                CancellationToken = cancellation,
+                MaxDegreeOfParallelism = Math.Clamp(Environment.ProcessorCount, 1, 16),
+            };
+
+            Parallel.For(0, paths.Count, options, i =>
+            {
+                metadata[i] = MetadataReader.Read(paths[i]);
+                int completed = Interlocked.Increment(ref done);
+                if (completed % 16 == 0 || completed == paths.Count)
+                {
+                    progress?.Report(new PipelineProgress(PipelinePhase.Ingestion, completed, paths.Count,
+                                                          "Lettura metadati…"));
+                }
+            });
+        }, cancellation).ConfigureAwait(false);
+
+        var sequence = TimelapseSequence.Build(metadata);
+        sequence.RecomputeTiming(cadenceTolerance);
+        return sequence;
+    }
+
+    // ------------------------------------------------------------------ analisi fotometrica
+
+    /// <summary>
+    /// Passata di analisi: misura la luminanza di ogni fotogramma e calcola la curva di
+    /// deflicker. La decodifica avviene a risoluzione ridotta perché la media logaritmica
+    /// troncata è invariante alla scala, e questo rende la fase praticamente istantanea.
+    /// </summary>
+    public async Task AnalyzeAsync(IProgress<PipelineProgress>? progress, CancellationToken cancellation)
+    {
+        var sequence = _project.Sequence ?? throw new InvalidOperationException("Nessuna sequenza caricata.");
+        int count = sequence.Count;
+        if (count == 0) return;
+
+        var (workingWidth, workingHeight) = _project.ResolveWorkingSize();
+        if (workingWidth <= 0) throw new InvalidOperationException("Impossibile determinare la risoluzione dei fotogrammi.");
+
+        int analysisWidth = Math.Clamp(_project.General.AnalysisWidth, 128, workingWidth);
+        int analysisHeight = Math.Max(2, (int)Math.Round(analysisWidth * workingHeight / (double)workingWidth));
+
+        int parallelism = Math.Clamp(_project.General.DecodeParallelism, 1, 16);
+        var pool = new FrameBufferPool(parallelism + 2);
+        var stats = new LuminanceStats[count];
+        var failures = new bool[count];
+        int done = 0;
+
+        await Task.Run(() =>
+        {
+            var options = new ParallelOptions
+            {
+                CancellationToken = cancellation,
+                MaxDegreeOfParallelism = parallelism,
+            };
+
+            Parallel.For(0, count, options, i =>
+            {
+                var record = sequence.Frames[i];
+                try
+                {
+                    using var buffer = ImageDecoder.Decode(record.FilePath, analysisWidth, analysisHeight,
+                                                           record.Metadata.Orientation, pool);
+                    stats[i] = LuminanceAnalyzer.Analyze(buffer);
+                }
+                catch (Exception ex) when (ex is not OperationCanceledException)
+                {
+                    failures[i] = true;
+                }
+
+                int completed = Interlocked.Increment(ref done);
+                progress?.Report(new PipelineProgress(PipelinePhase.Analysis, completed, count,
+                                                      "Analisi della luminanza…"));
+            });
+        }, cancellation).ConfigureAwait(false);
+
+        // I fotogrammi illeggibili ereditano la misura del vicino: la curva resta continua.
+        for (int i = 0; i < count; i++)
+        {
+            if (!failures[i]) continue;
+            stats[i] = i > 0 ? stats[i - 1] : LuminanceStats.Empty;
+        }
+
+        var curve = DeflickerEngine.Compute(stats, _project.Deflicker);
+
+        for (int i = 0; i < count; i++)
+        {
+            var record = sequence.Frames[i];
+            record.MeasuredLuminance = Math.Pow(2, curve.Measured[i]);
+            record.TargetLuminance = Math.Pow(2, curve.Target[i]);
+            record.Gain = Math.Pow(2, curve.GainStops[i]);
+            record.ClippedFraction = stats[i].ClippedFraction;
+            record.LuminanceAnalyzed = !failures[i];
+        }
+
+        _project.Stats = stats;
+        _project.Curve = curve;
+    }
+
+    /// <summary>
+    /// Ricalcola solo la curva a partire dalle statistiche già misurate: permette di muovere
+    /// i cursori del deflicker con riscontro immediato, senza rileggere i file.
+    /// </summary>
+    public void RecomputeCurve()
+    {
+        if (_project.Stats is not { } stats || _project.Sequence is not { } sequence) return;
+
+        var curve = DeflickerEngine.Compute(stats, _project.Deflicker);
+        for (int i = 0; i < sequence.Count && i < curve.Count; i++)
+        {
+            var record = sequence.Frames[i];
+            record.MeasuredLuminance = Math.Pow(2, curve.Measured[i]);
+            record.TargetLuminance = Math.Pow(2, curve.Target[i]);
+            record.Gain = Math.Pow(2, curve.GainStops[i]);
+        }
+        _project.Curve = curve;
+    }
+
+    // ------------------------------------------------------------------ render ed esportazione
+
+    public async Task<RenderResult> RenderAsync(IProgress<PipelineProgress>? progress, CancellationToken cancellation)
+    {
+        var sequence = _project.Sequence ?? throw new InvalidOperationException("Nessuna sequenza caricata.");
+        if (sequence.Count == 0) throw new InvalidOperationException("La sequenza è vuota.");
+        if (string.IsNullOrWhiteSpace(_project.Export.OutputPath))
+            throw new InvalidOperationException("Percorso di destinazione non impostato.");
+
+        if (!_project.IsAnalyzed) await AnalyzeAsync(progress, cancellation).ConfigureAwait(false);
+
+        var (width, height) = _project.ResolveWorkingSize();
+        if (width <= 0) throw new InvalidOperationException("Impossibile determinare la risoluzione dei fotogrammi.");
+
+        var export = _project.Export.Clone();
+        export.Width = width;
+        export.Height = height;
+
+        return await Task.Run(() => RenderCore(sequence, export, progress, cancellation), cancellation)
+                         .ConfigureAwait(false);
+    }
+
+    private RenderResult RenderCore(TimelapseSequence sequence, ExportSettings export,
+                                    IProgress<PipelineProgress>? progress, CancellationToken cancellation)
+    {
+        int width = export.Width;
+        int height = export.Height;
+        int count = sequence.Count;
+        var curve = _project.Curve;
+
+        int parallelism = Math.Clamp(_project.General.DecodeParallelism, 1, 16);
+        var pool = new FrameBufferPool(parallelism + 8);
+        var flowEngine = new OpticalFlowEngine(_project.Flow);
+        var blurSettings = _project.MotionBlur;
+        var deflickerSettings = _project.Deflicker;
+
+        uint baseUnits = (uint)Math.Max(1, Math.Round(export.Timescale / Math.Max(1.0, export.FrameRate)));
+        double nominal = sequence.NominalInterval > 0 ? sequence.NominalInterval : 1.0;
+
+        var stopwatch = Stopwatch.StartNew();
+        using var session = new VideoEncoderSession(export, width, height);
+
+        // Canale a capacità limitata: al più "parallelism" decodifiche in volo.
+        var channel = Channel.CreateBounded<Task<ImageBuffer?>>(new BoundedChannelOptions(parallelism)
+        {
+            SingleReader = true,
+            SingleWriter = true,
+            FullMode = BoundedChannelFullMode.Wait,
+        });
+
+        var producer = Task.Run(async () =>
+        {
+            try
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    cancellation.ThrowIfCancellationRequested();
+                    int index = i;
+                    var task = Task.Run(() => DecodeAndCorrect(sequence, index, width, height, pool,
+                                                               curve, deflickerSettings), cancellation);
+                    await channel.Writer.WriteAsync(task, cancellation).ConfigureAwait(false);
+                }
+                channel.Writer.Complete();
+            }
+            catch (Exception ex)
+            {
+                channel.Writer.TryComplete(ex);
+            }
+        }, cancellation);
+
+        ImageBuffer? current = null;
+        ImageBuffer? next = null;
+        var blurScratch = pool.Rent(width, height);
+        var interpolated = pool.Rent(width, height);
+        var interpolatedBlur = pool.Rent(width, height);
+
+        int encoded = 0;
+        bool cancelled = false;
+
+        try
+        {
+            current = ReadNextOrSubstitute(channel, pool, width, height, null);
+            next = ReadNextOrSubstitute(channel, pool, width, height, current);
+
+            for (int i = 0; i < count && current is not null; i++)
+            {
+                if (cancellation.IsCancellationRequested) { cancelled = true; break; }
+
+                var record = sequence.Frames[i];
+                int subdivisions = ComputeSubdivisions(export, record, nominal);
+                uint duration = ComputeDuration(export, record, nominal, baseUnits, subdivisions);
+
+                MotionField? field = null;
+                bool needsFlow = blurSettings.Enabled || (export.Timing == FrameTimingMode.Interpolated && subdivisions > 1);
+                if (needsFlow && next is not null)
+                {
+                    field = flowEngine.Compute(current, next);
+                    record.MotionMagnitude = field.MedianMagnitude();
+                    record.MotionDirection = field.DominantDirection();
+                }
+
+                // In presenza di suddivisioni l'intervallo di ciascun fotogramma d'uscita si
+                // accorcia: lo shutter angle effettivo cresce e lo spostamento si riduce.
+                double effectiveAngle = Math.Min(360.0, record.ShutterAngle * subdivisions);
+                double missing = blurSettings.Enabled
+                    ? MotionBlurRenderer.MissingBlurFactor(effectiveAngle, blurSettings.TargetShutterAngle,
+                                                           blurSettings.Strength) / subdivisions
+                    : 0;
+
+                record.BlurLength = EncodeFrame(session, current, field, missing, blurSettings, blurScratch, duration);
+                encoded++;
+                record.OutputDurationUnits = (int)duration;
+
+                for (int k = 1; k < subdivisions && next is not null && field is not null; k++)
+                {
+                    if (cancellation.IsCancellationRequested) { cancelled = true; break; }
+                    float t = k / (float)subdivisions;
+                    FrameInterpolator.Interpolate(current, next, field, t, interpolated);
+                    EncodeFrame(session, interpolated, field, missing, blurSettings, interpolatedBlur, duration);
+                    encoded++;
+                }
+
+                ReportRenderProgress(progress, i + 1, count, encoded, stopwatch);
+
+                current.Dispose();
+                current = next;
+                next = ReadNextOrSubstitute(channel, pool, width, height, current);
+            }
+        }
+        finally
+        {
+            current?.Dispose();
+            next?.Dispose();
+            blurScratch.Dispose();
+            interpolated.Dispose();
+            interpolatedBlur.Dispose();
+
+            progress?.Report(new PipelineProgress(PipelinePhase.Finalizing, count, count,
+                                                  "Chiusura del contenitore…"));
+            session.Finish();
+
+            try { producer.Wait(TimeSpan.FromSeconds(5)); }
+            catch (AggregateException) { /* già segnalato dal canale */ }
+        }
+
+        stopwatch.Stop();
+
+        if (cancelled) cancellation.ThrowIfCancellationRequested();
+
+        return new RenderResult(
+            export.OutputPath,
+            session.EncodedFrames,
+            session.OutputBytes,
+            stopwatch.Elapsed,
+            session.EncoderName,
+            session.IsHardware,
+            pool.AllocatedBytes);
+    }
+
+    /// <summary>Applica la sfocatura, se prevista, e consegna il fotogramma all'encoder.</summary>
+    private static double EncodeFrame(VideoEncoderSession session, ImageBuffer frame, MotionField? field,
+                                      double missing, MotionBlurSettings settings, ImageBuffer scratch,
+                                      uint duration)
+    {
+        double blurLength = 0;
+        var toEncode = frame;
+
+        if (settings.Enabled && field is not null && missing > 1e-4)
+        {
+            blurLength = MotionBlurRenderer.Render(frame, scratch, field, missing, settings);
+            toEncode = scratch;
+        }
+
+        session.EncodeFrame(toEncode, duration);
+        return blurLength;
+    }
+
+    /// <summary>Decodifica un fotogramma e vi applica il guadagno di esposizione calcolato.</summary>
+    private static ImageBuffer? DecodeAndCorrect(TimelapseSequence sequence, int index, int width, int height,
+                                                 FrameBufferPool pool, DeflickerCurve? curve,
+                                                 DeflickerSettings settings)
+    {
+        var record = sequence.Frames[index];
+        ImageBuffer buffer;
+        try
+        {
+            buffer = ImageDecoder.Decode(record.FilePath, width, height, record.Metadata.Orientation, pool);
+        }
+        catch (Exception)
+        {
+            return null;                    // il consumatore sostituirà con l'ultimo fotogramma valido
+        }
+
+        if (curve is not null && index < curve.Count && settings.Enabled)
+        {
+            record.ClippedFraction = ExposureProcessor.Apply(buffer, curve.ChannelGain[index],
+                                                             settings.ProtectHighlights, settings.HighlightKnee);
+        }
+        return buffer;
+    }
+
+    /// <summary>
+    /// Preleva il prossimo fotogramma in ordine di sequenza.
+    /// Restituisce false quando il flusso è terminato; un buffer nullo con esito true segnala
+    /// un fotogramma illeggibile, che il chiamante sostituisce senza perdere il sincronismo.
+    /// </summary>
+    private static bool TryReadNext(Channel<Task<ImageBuffer?>> channel, out ImageBuffer? buffer)
+    {
+        buffer = null;
+        while (true)
+        {
+            Task<ImageBuffer?> task;
+            try
+            {
+                if (!channel.Reader.WaitToReadAsync().AsTask().GetAwaiter().GetResult()) return false;
+                if (!channel.Reader.TryRead(out task!)) continue;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+
+            try
+            {
+                buffer = task.GetAwaiter().GetResult();
+            }
+            catch (Exception)
+            {
+                buffer = null;
+            }
+            return true;
+        }
+    }
+
+    /// <summary>Legge il fotogramma successivo sostituendo gli illeggibili con una copia del precedente.</summary>
+    private static ImageBuffer? ReadNextOrSubstitute(Channel<Task<ImageBuffer?>> channel, FrameBufferPool pool,
+                                                     int width, int height, ImageBuffer? previous)
+    {
+        if (!TryReadNext(channel, out var buffer)) return null;
+        if (buffer is not null) return buffer;
+
+        return previous is not null
+            ? previous.CloneFromPool(pool)
+            : CreateBlack(pool, width, height);
+    }
+
+    private static ImageBuffer CreateBlack(FrameBufferPool pool, int width, int height)
+    {
+        var buffer = pool.Rent(width, height);
+        Array.Clear(buffer.Data, 0, buffer.SampleCount);
+        return buffer;
+    }
+
+    private static int ComputeSubdivisions(ExportSettings export, FrameRecord record, double nominal)
+    {
+        if (export.Timing != FrameTimingMode.Interpolated) return 1;
+        double ratio = record.IntervalSeconds / Math.Max(1e-6, nominal);
+        int max = (int)Math.Max(1, Math.Round(export.MaxAdaptiveStretch));
+        return Math.Clamp((int)Math.Round(ratio), 1, max);
+    }
+
+    private static uint ComputeDuration(ExportSettings export, FrameRecord record, double nominal,
+                                        uint baseUnits, int subdivisions)
+    {
+        if (export.Timing != FrameTimingMode.Adaptive) return baseUnits;
+
+        double ratio = record.IntervalSeconds / Math.Max(1e-6, nominal);
+        double limited = Math.Clamp(ratio, 1.0 / export.MaxAdaptiveStretch, export.MaxAdaptiveStretch);
+        return (uint)Math.Max(1, Math.Round(baseUnits * limited));
+    }
+
+    private static void ReportRenderProgress(IProgress<PipelineProgress>? progress, int completed, int total,
+                                             int encoded, Stopwatch stopwatch)
+    {
+        if (progress is null) return;
+
+        double seconds = stopwatch.Elapsed.TotalSeconds;
+        double fps = seconds > 0.001 ? encoded / seconds : 0;
+        var remaining = fps > 0.01
+            ? TimeSpan.FromSeconds((total - completed) / fps)
+            : TimeSpan.Zero;
+
+        progress.Report(new PipelineProgress(PipelinePhase.Rendering, completed, total,
+                                             "Elaborazione e codifica…", fps, remaining));
+    }
+}

Titano/Pipeline/TitanoProject.cs

@@ -0,0 +1,83 @@
+using Titano.Analysis;
+using Titano.Core;
+using Titano.Motion;
+using Titano.Video;
+
+namespace Titano.Pipeline;
+
+/// <summary>Impostazioni della sezione "Generale".</summary>
+public sealed class GeneralSettings
+{
+    /// <summary>Larghezza massima di lavoro; 0 = risoluzione nativa del primo fotogramma.</summary>
+    public int WorkingWidth { get; set; }
+
+    /// <summary>Larghezza usata nella passata di analisi fotometrica: incide solo sulla velocità.</summary>
+    public int AnalysisWidth { get; set; } = 1024;
+
+    /// <summary>Decodifiche simultanee. Limita anche i buffer in volo, quindi la memoria occupata.</summary>
+    public int DecodeParallelism { get; set; } = Math.Clamp(Environment.ProcessorCount / 2, 2, 8);
+
+    /// <summary>Tolleranza sulla cadenza oltre la quale un intervallo è segnalato come anomalo.</summary>
+    public double CadenceTolerance { get; set; } = 0.35;
+
+    public GeneralSettings Clone() => (GeneralSettings)MemberwiseClone();
+}
+
+/// <summary>
+/// Stato completo di un progetto: sequenza caricata e tutti i parametri dei tre pannelli
+/// di configurazione. È l'unico oggetto che l'interfaccia scambia con il motore.
+/// </summary>
+public sealed class TitanoProject
+{
+    public GeneralSettings General { get; set; } = new();
+    public DeflickerSettings Deflicker { get; set; } = new();
+    public MotionBlurSettings MotionBlur { get; set; } = new();
+    public OpticalFlowSettings Flow { get; set; } = new();
+    public ExportSettings Export { get; set; } = new();
+
+    public TimelapseSequence? Sequence { get; set; }
+
+    /// <summary>Curva di deflicker dell'ultima analisi, usata dal grafico e dall'esportazione.</summary>
+    public DeflickerCurve? Curve { get; set; }
+
+    /// <summary>Statistiche fotometriche per fotogramma dell'ultima analisi.</summary>
+    public IReadOnlyList<LuminanceStats>? Stats { get; set; }
+
+    public bool HasSequence => Sequence is { Count: > 0 };
+    public bool IsAnalyzed => Curve is not null && Stats is not null;
+
+    /// <summary>
+    /// Risoluzione di lavoro effettiva: parte dal primo fotogramma, applica l'eventuale limite
+    /// dell'utente e arrotonda a valori pari, richiesti dal sottocampionamento cromatico 4:2:0.
+    /// </summary>
+    public (int Width, int Height) ResolveWorkingSize()
+    {
+        if (Sequence is not { Count: > 0 }) return (0, 0);
+
+        var first = Sequence.Frames[0].Metadata;
+        int sourceWidth = first.PixelWidth;
+        int sourceHeight = first.PixelHeight;
+
+        if (sourceWidth <= 0 || sourceHeight <= 0)
+        {
+            (sourceWidth, sourceHeight) = Imaging.ImageDecoder.ProbeDisplaySize(first.FilePath, first.Orientation);
+        }
+        else if (Imaging.ImageDecoder.SwapsAxes(first.Orientation))
+        {
+            (sourceWidth, sourceHeight) = (sourceHeight, sourceWidth);
+        }
+
+        if (sourceWidth <= 0 || sourceHeight <= 0) return (0, 0);
+
+        int targetWidth = Export.Width > 0 ? Export.Width
+            : General.WorkingWidth > 0 ? Math.Min(General.WorkingWidth, sourceWidth)
+            : sourceWidth;
+
+        double aspect = sourceHeight / (double)sourceWidth;
+        int targetHeight = Export.Height > 0 ? Export.Height : (int)Math.Round(targetWidth * aspect);
+
+        targetWidth = Math.Max(2, targetWidth & ~1);
+        targetHeight = Math.Max(2, targetHeight & ~1);
+        return (targetWidth, targetHeight);
+    }
+}

Titano/Program.cs

@@ -0,0 +1,85 @@
+using System.Runtime.InteropServices;
+using Titano.Diagnostics;
+
+namespace Titano;
+
+internal static class Program
+{
+    private const int AttachParentProcess = -1;
+
+    [DllImport("kernel32.dll")]
+    private static extern bool AttachConsole(int processId);
+
+    [STAThread]
+    private static int Main(string[] args)
+    {
+        if (args.Length > 0 && args[0] is "--selftest" or "-t")
+        {
+            AttachConsole(AttachParentProcess);
+            string directory = args.Length > 1
+                ? args[1]
+                : Path.Combine(Path.GetTempPath(), "Titano.SelfTest");
+            Directory.CreateDirectory(directory);
+
+            Console.WriteLine();
+            Console.Write(SelfTest.DescribeEnvironment());
+            return SelfTest.Run(directory, Console.Out);
+        }
+
+        if (args.Length > 1 && args[0] == "--capture")
+        {
+            AttachConsole(AttachParentProcess);
+            ApplicationConfiguration.Initialize();
+            return Capture(args[1], args.Length > 2 ? args[2] : null,
+                           args.Length > 3 && int.TryParse(args[3], out int tab) ? tab : 0);
+        }
+
+        ApplicationConfiguration.Initialize();
+        Application.Run(new UI.MainForm());
+        return 0;
+    }
+
+    /// <summary>
+    /// Apre l'interfaccia, opzionalmente vi carica una sequenza, e ne salva un'immagine.
+    /// Serve a verificare la resa dei controlli disegnati a mano senza intervento manuale.
+    /// </summary>
+    private static int Capture(string outputPath, string? sequenceDirectory, int settingsTab)
+    {
+        using var form = new UI.MainForm();
+        form.Show();
+        Pump(200);
+
+        if (sequenceDirectory is not null && Directory.Exists(sequenceDirectory))
+        {
+            string[] files = [.. Directory.EnumerateFiles(sequenceDirectory)
+                                          .Where(Metadata.MetadataReader.IsSupported)];
+            var work = form.PrepareForCaptureAsync(files);
+            while (!work.IsCompleted) Pump(30);
+            Pump(2500);                         // attesa del rendering asincrono dell'anteprima
+        }
+
+        if (settingsTab > 0)
+        {
+            form.SelectSettingsTab(settingsTab);
+            Pump(200);
+        }
+
+        using var bitmap = new Bitmap(form.Width, form.Height);
+        form.DrawToBitmap(bitmap, new Rectangle(0, 0, form.Width, form.Height));
+        bitmap.Save(outputPath, System.Drawing.Imaging.ImageFormat.Png);
+
+        Console.WriteLine($"Interfaccia catturata in {outputPath} ({bitmap.Width}×{bitmap.Height}).");
+        return 0;
+    }
+
+    private static void Pump(int milliseconds)
+    {
+        var deadline = Environment.TickCount64 + milliseconds;
+        do
+        {
+            Application.DoEvents();
+            Thread.Sleep(10);
+        }
+        while (Environment.TickCount64 < deadline);
+    }
+}

Titano/README.md

@@ -0,0 +1,103 @@
+# Titano
+
+Applicazione desktop per la creazione e l'ottimizzazione di time-lapse di livello
+professionale, sviluppata interamente in-house.
+
+## Il vincolo che definisce il progetto
+
+**Zero librerie di terze parti.** Il file di progetto non contiene alcun
+`<PackageReference>`: tutto ciò che non è la libreria standard di .NET è scritto qui dentro
+oppure ottenuto tramite P/Invoke diretto verso componenti del sistema operativo.
+
+| Ambito | Come è risolto |
+|---|---|
+| Parsing EXIF / XMP | Parser binario proprietario (`Metadata/`) |
+| Analisi fotometrica e deflicker | Algoritmi proprietari (`Analysis/`) |
+| Campo vettoriale e motion blur | Schema differenziale piramidale proprietario (`Motion/`) |
+| Contenitore MP4 | Multiplexer ISO-BMFF proprietario (`Video/Mp4Muxer.cs`) |
+| Decodifica immagini | WIC, componente di Windows, via COM interop scritto a mano |
+| Codifica video | Media Foundation Transform, encoder hardware di sistema |
+| Interfaccia grafica | WinForms + GDI+, ogni controllo disegnato a mano (`UI/`) |
+
+Non viene invocato nessun processo esterno: niente FFmpeg, niente ExifTool.
+
+## Principi architetturali
+
+**Nessun file temporaneo.** I dati passano fra le fasi solo attraverso buffer in RAM. L'unica
+scrittura su disco è il flusso compresso finale, prodotto in streaming: `ftyp` e l'header
+`mdat` vengono scritti all'apertura, i pacchetti dell'encoder scorrono direttamente nel file
+e `moov` viene aggiunto in chiusura.
+
+**Impronta di memoria costante.** I fotogrammi vivono in array float presi da un pool
+(`Imaging/ImageBuffer.cs`) e la decodifica è governata da un canale a capacità limitata: al
+più *N* fotogrammi sono vivi contemporaneamente, dove *N* è il numero di decodifiche
+simultanee scelto dall'utente. L'occupazione non dipende dalla lunghezza della sequenza —
+la verifica automatica lo misura esplicitamente.
+
+**Interfaccia reattiva.** Ingestion, analisi e render girano su thread di lavoro; il thread
+dell'interfaccia riceve solo aggiornamenti di stato immutabili tramite `IProgress<T>`.
+
+## Struttura
+
+```
+Metadata/    parser binario TIFF/Exif, scanner XMP, riconoscimento contenitori
+Core/        sequenza, intervalli reali, cadenza nominale, shutter angle
+Imaging/     buffer poolati, spazio colore lineare, decodifica via WIC
+Analysis/    misura di luminanza, curva di deflicker, applicazione dei guadagni
+Motion/      piramide gaussiana, optical flow, motion blur, interpolazione
+Video/       conversione NV12, encoder Media Foundation, multiplexer MP4
+Pipeline/    orchestrazione delle fasi, progetto e impostazioni
+UI/          tema scuro, grafico vettoriale, tabella virtuale, pannelli
+Diagnostics/ sequenza sintetica, verifica end-to-end, ispettore MP4
+```
+
+## Note sugli algoritmi
+
+**Deflicker.** Per ogni fotogramma si esegue una regressione lineare locale pesata sulla
+finestra mobile. I pesi combinano una gaussiana sulla distanza temporale e, in seconda
+passata, un peso di robustezza di Tukey che neutralizza i fotogrammi anomali. La componente
+lineare segue senza ritardo le rampe reali di luce (alba, tramonto) e rimuove solo la
+componente ad alta frequenza dovuta alle micro-variazioni del diaframma. La misura è la media
+logaritmica troncata: invariante alla scala, insensibile a cieli bruciati e ombre chiuse.
+
+**Motion blur.** Lo shutter angle reale è `360 × posa / intervallo`. La scia già incisa nel
+fotogramma e quella sintetica si compongono in quadratura, quindi per raggiungere l'apertura
+obiettivo serve una scia di `√(obiettivo² − reale²)` volte lo spostamento: sommare
+linearmente produrrebbe un'immagine sistematicamente troppo morbida. Il filtro di
+ricostruzione è di tipo *gather*: un campione contribuisce al pixel centrale solo se la
+propria scia lo raggiunge davvero, così lo sfondo fermo non viene trascinato nei soggetti in
+movimento.
+
+**Optical flow.** Schema differenziale piramidale: su ogni nodo di una griglia rada si risolve
+iterativamente il sistema normale 2×2 costruito dai gradienti spaziali e dalla differenza
+temporale. Un filtro mediano fra un livello e l'altro elimina i vettori spuri delle zone
+piatte. L'analisi avviene a risoluzione ridotta e i vettori vengono riportati in scala piena:
+il costo non dipende dalla dimensione dei file sorgente.
+
+## Compilazione ed esecuzione
+
+```
+dotnet build -c Release
+dotnet run  -c Release
+```
+
+Richiede .NET 10 SDK su Windows x64.
+
+## Verifica automatica
+
+```
+Titano.exe --selftest [cartella]
+```
+
+Genera una sequenza sintetica dalle proprietà note — traslazione, sfarfallio e rampa di luce
+imposti, pausa dell'intervallometro inclusa — e la fa attraversare l'intera pipeline,
+confrontando 23 grandezze misurate con i valori attesi: campi Exif, cadenza, shutter angle,
+riduzione dello sfarfallio, conservazione della rampa, modulo e direzione del campo
+vettoriale, attenuazione del dettaglio dovuta alla sfocatura, struttura del contenitore
+prodotto e — prova conclusiva — la ri-decodifica del file con il lettore di sistema.
+
+```
+Titano.exe --capture <file.png> [cartella-sequenza] [scheda]
+```
+
+Cattura l'interfaccia in un'immagine, per verificarne la resa in modo riproducibile.

Titano/Titano.csproj

@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <!--
+    Titano - motore di time-lapse professionale.
+
+    VINCOLO ARCHITETTURALE: questo progetto non contiene NESSUN <PackageReference>.
+    Tutto ciò che non è BCL è implementato in-house oppure ottenuto tramite
+    P/Invoke diretto verso API native del sistema operativo (WIC, Media Foundation,
+    GDI+, DWM, Kernel32), che il brief consente esplicitamente.
+  -->
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <UseWindowsForms>true</UseWindowsForms>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <LangVersion>latest</LangVersion>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Platforms>x64</Platforms>
+    <PlatformTarget>x64</PlatformTarget>
+    <AssemblyName>Titano</AssemblyName>
+    <RootNamespace>Titano</RootNamespace>
+    <ApplicationHighDpiMode>PerMonitorV2</ApplicationHighDpiMode>
+    <ApplicationDefaultFont>Segoe UI, 9pt</ApplicationDefaultFont>
+    <EnableWindowsTargeting>true</EnableWindowsTargeting>
+    <ServerGarbageCollection>true</ServerGarbageCollection>
+    <ConcurrentGarbageCollection>true</ConcurrentGarbageCollection>
+    <InvariantGlobalization>false</InvariantGlobalization>
+    <Product>Titano</Product>
+    <Company>Titano</Company>
+    <AssemblyVersion>1.0.0.0</AssemblyVersion>
+    <FileVersion>1.0.0.0</FileVersion>
+    <Version>1.0.0</Version>
+    <!--
+      CA1416: le API Windows-only sono intenzionali, il progetto è vincolato a win-x64.
+      WFO1000: riguarda la serializzazione dei controlli nel designer visuale. Qui l'intera
+      interfaccia è costruita in codice e nessun controllo viene mai serializzato.
+    -->
+    <NoWarn>$(NoWarn);CA1416;WFO1000</NoWarn>
+  </PropertyGroup>
+
+</Project>

Titano/Titano.slnx

@@ -0,0 +1,3 @@
+<Solution>
+  <Project Path="Titano.csproj" />
+</Solution>

Titano/UI/Controls.cs

@@ -0,0 +1,488 @@
+using System.Globalization;
+
+namespace Titano.UI;
+
+/// <summary>Pulsante disegnato interamente a mano, con varianti primaria e secondaria.</summary>
+internal sealed class DarkButton : Control
+{
+    private bool _hover;
+    private bool _pressed;
+
+    public bool Primary { get; set; }
+    public bool Danger { get; set; }
+
+    public DarkButton()
+    {
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        Height = 32;
+        Font = Theme.Body;
+        Cursor = Cursors.Hand;
+    }
+
+    protected override void OnMouseEnter(EventArgs e) { _hover = true; Invalidate(); base.OnMouseEnter(e); }
+    protected override void OnMouseLeave(EventArgs e) { _hover = false; _pressed = false; Invalidate(); base.OnMouseLeave(e); }
+    protected override void OnMouseDown(MouseEventArgs e) { _pressed = true; Invalidate(); base.OnMouseDown(e); }
+    protected override void OnMouseUp(MouseEventArgs e) { _pressed = false; Invalidate(); base.OnMouseUp(e); }
+    protected override void OnEnabledChanged(EventArgs e) { Invalidate(); base.OnEnabledChanged(e); }
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Parent?.BackColor ?? Theme.Surface);
+
+        var bounds = new RectangleF(0.5f, 0.5f, Width - 1, Height - 1);
+        Color fill, stroke, text;
+
+        if (!Enabled)
+        {
+            fill = Theme.SurfaceAlt;
+            stroke = Theme.Border;
+            text = Theme.TextFaint;
+        }
+        else if (Primary)
+        {
+            fill = _pressed ? Theme.AccentDim : _hover ? Theme.Mix(Theme.Accent, Color.White, 0.12) : Theme.Accent;
+            stroke = fill;
+            text = Color.FromArgb(0x0B, 0x12, 0x1C);
+        }
+        else if (Danger)
+        {
+            fill = _pressed ? Theme.SurfaceAlt : _hover ? Theme.Mix(Theme.Danger, Theme.Surface, 0.75) : Theme.Surface;
+            stroke = Theme.Danger;
+            text = Theme.Danger;
+        }
+        else
+        {
+            fill = _pressed ? Theme.Surface : _hover ? Theme.SurfaceHover : Theme.SurfaceAlt;
+            stroke = _hover ? Theme.BorderStrong : Theme.Border;
+            text = Theme.Text;
+        }
+
+        Theme.FillAndStroke(g, bounds, 6f, fill, stroke);
+
+        TextRenderer.DrawText(g, Text, Font, new Rectangle(0, 0, Width, Height), text,
+                              TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter |
+                              TextFormatFlags.EndEllipsis);
+    }
+}
+
+/// <summary>Interruttore a due stati con etichetta, disegnato a mano.</summary>
+internal sealed class DarkCheckBox : Control
+{
+    private bool _checked;
+    private bool _hover;
+
+    public event EventHandler? CheckedChanged;
+
+    public bool Checked
+    {
+        get => _checked;
+        set
+        {
+            if (_checked == value) return;
+            _checked = value;
+            Invalidate();
+            CheckedChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    public DarkCheckBox()
+    {
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        Height = 26;
+        Font = Theme.Body;
+        Cursor = Cursors.Hand;
+    }
+
+    protected override void OnMouseEnter(EventArgs e) { _hover = true; Invalidate(); base.OnMouseEnter(e); }
+    protected override void OnMouseLeave(EventArgs e) { _hover = false; Invalidate(); base.OnMouseLeave(e); }
+    protected override void OnClick(EventArgs e) { Checked = !Checked; base.OnClick(e); }
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Parent?.BackColor ?? Theme.Surface);
+
+        const int size = 17;
+        int top = (Height - size) / 2;
+        var box = new RectangleF(0.5f, top + 0.5f, size, size);
+
+        Color fill = _checked ? Theme.Accent : _hover ? Theme.SurfaceHover : Theme.SurfaceAlt;
+        Color stroke = _checked ? Theme.Accent : _hover ? Theme.BorderStrong : Theme.Border;
+        Theme.FillAndStroke(g, box, 4f, fill, stroke);
+
+        if (_checked)
+        {
+            using var pen = new Pen(Color.FromArgb(0x0B, 0x12, 0x1C), 2f)
+            {
+                StartCap = System.Drawing.Drawing2D.LineCap.Round,
+                EndCap = System.Drawing.Drawing2D.LineCap.Round,
+            };
+            g.DrawLines(pen,
+            [
+                new PointF(box.Left + 4f, box.Top + 8.5f),
+                new PointF(box.Left + 7f, box.Top + 11.5f),
+                new PointF(box.Left + 13f, box.Top + 5f),
+            ]);
+        }
+
+        var textRect = new Rectangle(size + 9, 0, Width - size - 9, Height);
+        TextRenderer.DrawText(g, Text, Font, textRect, Enabled ? Theme.Text : Theme.TextFaint,
+                              TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis);
+    }
+}
+
+/// <summary>
+/// Cursore continuo con didascalia e valore, unità di misura opzionale e tacche.
+/// Sostituisce il TrackBar di sistema, che non è tematizzabile.
+/// </summary>
+internal sealed class ParameterSlider : Control
+{
+    private double _value;
+    private bool _dragging;
+    private bool _hover;
+
+    public string Caption { get; set; } = string.Empty;
+    public string Unit { get; set; } = string.Empty;
+    public string ValueFormat { get; set; } = "0.##";
+    public double Minimum { get; set; }
+    public double Maximum { get; set; } = 1;
+    public double Step { get; set; }
+
+    public event EventHandler? ValueChanged;
+
+    public double Value
+    {
+        get => _value;
+        set
+        {
+            double clamped = Math.Clamp(value, Minimum, Maximum);
+            if (Step > 0) clamped = Math.Round(clamped / Step) * Step;
+            if (Math.Abs(clamped - _value) < 1e-9) return;
+            _value = clamped;
+            Invalidate();
+            ValueChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    /// <summary>Imposta il valore senza sollevare l'evento: usata al caricamento delle impostazioni.</summary>
+    public void SetValueSilently(double value)
+    {
+        _value = Math.Clamp(value, Minimum, Maximum);
+        Invalidate();
+    }
+
+    public ParameterSlider()
+    {
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        Height = 46;
+        Font = Theme.Body;
+    }
+
+    private Rectangle TrackBounds => new(2, Height - 20, Width - 4, 12);
+
+    protected override void OnMouseEnter(EventArgs e) { _hover = true; Invalidate(); base.OnMouseEnter(e); }
+    protected override void OnMouseLeave(EventArgs e) { _hover = false; Invalidate(); base.OnMouseLeave(e); }
+
+    protected override void OnMouseDown(MouseEventArgs e)
+    {
+        if (e.Button != MouseButtons.Left || !Enabled) return;
+        _dragging = true;
+        UpdateFromMouse(e.X);
+        base.OnMouseDown(e);
+    }
+
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+        if (_dragging) UpdateFromMouse(e.X);
+        base.OnMouseMove(e);
+    }
+
+    protected override void OnMouseUp(MouseEventArgs e)
+    {
+        _dragging = false;
+        base.OnMouseUp(e);
+    }
+
+    protected override void OnMouseWheel(MouseEventArgs e)
+    {
+        if (!Enabled) return;
+        double increment = Step > 0 ? Step : (Maximum - Minimum) / 50.0;
+        Value += Math.Sign(e.Delta) * increment;
+    }
+
+    private void UpdateFromMouse(int x)
+    {
+        var track = TrackBounds;
+        double fraction = Math.Clamp((x - track.Left) / (double)Math.Max(1, track.Width), 0, 1);
+        Value = Minimum + fraction * (Maximum - Minimum);
+    }
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Parent?.BackColor ?? Theme.Surface);
+
+        Color captionColor = Enabled ? Theme.TextMuted : Theme.TextFaint;
+        Color valueColor = Enabled ? Theme.Text : Theme.TextFaint;
+
+        TextRenderer.DrawText(g, Caption, Theme.Small, new Rectangle(0, 2, Width - 90, 16),
+                              captionColor, TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
+
+        string display = _value.ToString(ValueFormat, CultureInfo.CurrentCulture) +
+                         (string.IsNullOrEmpty(Unit) ? string.Empty : " " + Unit);
+        TextRenderer.DrawText(g, display, Theme.SmallBold, new Rectangle(Width - 92, 2, 92, 16),
+                              valueColor, TextFormatFlags.Right | TextFormatFlags.VerticalCenter);
+
+        var track = TrackBounds;
+        float centerY = track.Top + track.Height / 2f;
+        var groove = new RectangleF(track.Left, centerY - 2f, track.Width, 4f);
+        Theme.FillRounded(g, groove, 2f, Enabled ? Theme.SurfaceAlt : Theme.Surface);
+
+        double span = Maximum - Minimum;
+        float fraction = span <= 0 ? 0 : (float)((_value - Minimum) / span);
+        var filled = new RectangleF(track.Left, centerY - 2f, track.Width * fraction, 4f);
+        if (filled.Width > 0.5f)
+            Theme.FillRounded(g, filled, 2f, Enabled ? Theme.Accent : Theme.Border);
+
+        float knobX = track.Left + track.Width * fraction;
+        float radius = _dragging ? 7.5f : _hover ? 7f : 6f;
+        var knob = new RectangleF(knobX - radius, centerY - radius, radius * 2, radius * 2);
+
+        using (var brush = new SolidBrush(Enabled ? Theme.Text : Theme.TextFaint)) g.FillEllipse(brush, knob);
+        using (var pen = new Pen(Enabled ? Theme.Accent : Theme.Border, 2f))
+            g.DrawEllipse(pen, RectangleF.Inflate(knob, -1f, -1f));
+    }
+}
+
+/// <summary>Etichetta e menu a discesa affiancati, con lo stile del tema.</summary>
+internal sealed class LabeledCombo : Panel
+{
+    public ComboBox Combo { get; }
+
+    public LabeledCombo(string caption)
+    {
+        Height = 46;
+        BackColor = Theme.Surface;
+
+        var label = new Label
+        {
+            Text = caption,
+            Font = Theme.Small,
+            ForeColor = Theme.TextMuted,
+            Dock = DockStyle.Top,
+            Height = 16,
+            TextAlign = ContentAlignment.MiddleLeft,
+        };
+
+        Combo = new ComboBox
+        {
+            DropDownStyle = ComboBoxStyle.DropDownList,
+            FlatStyle = FlatStyle.Flat,
+            BackColor = Theme.SurfaceAlt,
+            ForeColor = Theme.Text,
+            Font = Theme.Body,
+            Dock = DockStyle.Top,
+            DrawMode = DrawMode.OwnerDrawFixed,
+            ItemHeight = 20,
+        };
+        Combo.DrawItem += DrawItem;
+
+        Controls.Add(Combo);
+        Controls.Add(label);
+    }
+
+    private void DrawItem(object? sender, DrawItemEventArgs e)
+    {
+        if (e.Index < 0) return;
+        bool selected = (e.State & DrawItemState.Selected) != 0;
+        e.Graphics.FillRectangle(new SolidBrush(selected ? Theme.AccentDim : Theme.SurfaceAlt), e.Bounds);
+        TextRenderer.DrawText(e.Graphics, Combo.Items[e.Index]?.ToString() ?? string.Empty, Theme.Body,
+                              Rectangle.Inflate(e.Bounds, -4, 0), Theme.Text,
+                              TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
+    }
+}
+
+/// <summary>Intestazione di sezione con filetto di separazione.</summary>
+internal sealed class SectionHeader : Control
+{
+    public SectionHeader(string text)
+    {
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        Text = text;
+        Height = 30;
+    }
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Parent?.BackColor ?? Theme.Surface);
+
+        var size = TextRenderer.MeasureText(g, Text, Theme.SmallBold);
+        TextRenderer.DrawText(g, Text.ToUpperInvariant(), Theme.SmallBold,
+                              new Rectangle(0, 0, Width, Height), Theme.TextFaint,
+                              TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
+
+        int lineStart = size.Width + 14;
+        if (lineStart < Width - 4)
+        {
+            using var pen = new Pen(Theme.Border);
+            int y = Height / 2;
+            g.DrawLine(pen, lineStart, y, Width - 2, y);
+        }
+    }
+}
+
+/// <summary>Selettore a schede orizzontali usato dal pannello di configurazione.</summary>
+internal sealed class TabStrip : Control
+{
+    private readonly List<string> _tabs = [];
+    private int _selected;
+    private int _hovered = -1;
+
+    public event EventHandler? SelectedChanged;
+
+    public int SelectedIndex
+    {
+        get => _selected;
+        set
+        {
+            int clamped = Math.Clamp(value, 0, Math.Max(0, _tabs.Count - 1));
+            if (clamped == _selected) return;
+            _selected = clamped;
+            Invalidate();
+            SelectedChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    public TabStrip(params string[] tabs)
+    {
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        _tabs.AddRange(tabs);
+        Height = 36;
+        Cursor = Cursors.Hand;
+    }
+
+    /// <summary>
+    /// Larghezze proporzionali al testo: le etichette lunghe non vengono troncate solo
+    /// perché condividono la barra con etichette corte.
+    /// </summary>
+    private float[] TabWidths()
+    {
+        var widths = new float[_tabs.Count];
+        float total = 0;
+
+        using (var graphics = CreateGraphics())
+        {
+            for (int i = 0; i < _tabs.Count; i++)
+            {
+                widths[i] = TextRenderer.MeasureText(graphics, _tabs[i], Theme.SmallBold).Width + 22;
+                total += widths[i];
+            }
+        }
+
+        if (total <= 0) return widths;
+        float scale = Width / total;
+        for (int i = 0; i < widths.Length; i++) widths[i] *= scale;
+        return widths;
+    }
+
+    private int IndexAt(int x)
+    {
+        if (_tabs.Count == 0) return -1;
+        var widths = TabWidths();
+        float cursor = 0;
+        for (int i = 0; i < widths.Length; i++)
+        {
+            cursor += widths[i];
+            if (x < cursor) return i;
+        }
+        return _tabs.Count - 1;
+    }
+
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+        int index = IndexAt(e.X);
+        if (index != _hovered) { _hovered = index; Invalidate(); }
+        base.OnMouseMove(e);
+    }
+
+    protected override void OnMouseLeave(EventArgs e) { _hovered = -1; Invalidate(); base.OnMouseLeave(e); }
+    protected override void OnMouseDown(MouseEventArgs e) { SelectedIndex = IndexAt(e.X); base.OnMouseDown(e); }
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Theme.Background);
+        if (_tabs.Count == 0) return;
+
+        var widths = TabWidths();
+        float offset = 0;
+
+        for (int i = 0; i < _tabs.Count; i++)
+        {
+            var bounds = new RectangleF(offset, 0, widths[i], Height);
+            offset += widths[i];
+            bool active = i == _selected;
+
+            if (active) Theme.FillRounded(g, new RectangleF(bounds.X + 2, 3, bounds.Width - 4, Height - 6), 6f, Theme.SurfaceAlt);
+            else if (i == _hovered) Theme.FillRounded(g, new RectangleF(bounds.X + 2, 3, bounds.Width - 4, Height - 6), 6f, Theme.Surface);
+
+            TextRenderer.DrawText(g, _tabs[i], active ? Theme.SmallBold : Theme.Small,
+                                  Rectangle.Round(bounds), active ? Theme.Text : Theme.TextMuted,
+                                  TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter |
+                                  TextFormatFlags.EndEllipsis);
+
+            if (active)
+            {
+                using var brush = new SolidBrush(Theme.Accent);
+                g.FillRectangle(brush, bounds.X + bounds.Width / 2 - 12, Height - 3, 24, 2);
+            }
+        }
+    }
+}
+
+/// <summary>Barra di avanzamento sottile con etichetta interna.</summary>
+internal sealed class DarkProgressBar : Control
+{
+    private double _fraction;
+
+    public double Fraction
+    {
+        get => _fraction;
+        set { _fraction = Math.Clamp(value, 0, 1); Invalidate(); }
+    }
+
+    public DarkProgressBar()
+    {
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        Height = 22;
+    }
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Parent?.BackColor ?? Theme.Surface);
+
+        var bounds = new RectangleF(0, (Height - 8) / 2f, Width, 8);
+        Theme.FillRounded(g, bounds, 4f, Theme.SurfaceAlt);
+
+        if (_fraction > 0.0005)
+        {
+            var filled = new RectangleF(bounds.X, bounds.Y, (float)(bounds.Width * _fraction), bounds.Height);
+            Theme.FillRounded(g, filled, 4f, Theme.Accent);
+        }
+    }
+}

Titano/UI/FrameTable.cs

@@ -0,0 +1,288 @@
+using Titano.Core;
+using Titano.Metadata;
+
+namespace Titano.UI;
+
+/// <summary>
+/// Tabella dei fotogrammi a rendering virtuale: disegna soltanto le righe visibili, quindi
+/// regge sequenze da decine di migliaia di scatti senza creare un controllo per riga.
+/// Barra di scorrimento, intestazioni e selezione sono disegnate a mano nel tema scuro.
+/// </summary>
+internal sealed class FrameTable : Control
+{
+    private sealed record Column(string Title, int Width, bool RightAligned, Func<FrameRecord, string> Value);
+
+    private const int RowHeight = 24;
+    private const int HeaderHeight = 30;
+    private const int ScrollWidth = 12;
+
+    private readonly Column[] _columns;
+    private TimelapseSequence? _sequence;
+    private int _scroll;
+    private int _hoverRow = -1;
+    private int _selectedIndex = -1;
+    private bool _draggingScroll;
+    private int _dragOffset;
+
+    public event EventHandler? SelectionChanged;
+
+    public int SelectedIndex
+    {
+        get => _selectedIndex;
+        set
+        {
+            if (_selectedIndex == value) return;
+            _selectedIndex = value;
+            EnsureVisible(value);
+            Invalidate();
+            SelectionChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    public FrameTable()
+    {
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        BackColor = Theme.Surface;
+        TabStop = true;
+
+        _columns =
+        [
+            new Column("#", 52, true, r => (r.Index + 1).ToString()),
+            new Column("File", 178, false, r => r.FileName),
+            new Column("Ora di scatto", 104, false, r => r.Metadata.CaptureTime?.ToString("HH:mm:ss.ff") ?? "—"),
+            new Column("Δt", 68, true, r => r.CadenceText),
+            new Column("Posa", 62, true, r => r.Metadata.ExposureText),
+            new Column("Apertura", 68, true, r => r.Metadata.ApertureText),
+            new Column("ISO", 52, true, r => r.Metadata.IsoText),
+            new Column("Otturatore", 74, true, r => r.ShutterAngle > 0 ? $"{r.ShutterAngle:0.#}°" : "—"),
+            new Column("Luminanza", 80, true, r => r.LuminanceAnalyzed ? $"{Math.Log2(Math.Max(r.MeasuredLuminance, 1e-9)):0.00}" : "—"),
+            new Column("Target", 72, true, r => r.LuminanceAnalyzed ? $"{Math.Log2(Math.Max(r.TargetLuminance, 1e-9)):0.00}" : "—"),
+            new Column("Guadagno", 76, true, r => r.LuminanceAnalyzed ? $"{r.GainStops:+0.00;-0.00;0.00}" : "—"),
+            new Column("Blur", 62, true, r => r.BlurLength > 0.01 ? $"{r.BlurLength:0.0} px" : "—"),
+            new Column("Movimento", 82, true, r => r.MotionMagnitude > 0.01 ? $"{r.MotionMagnitude:0.0} px" : "—"),
+        ];
+    }
+
+    public void SetSequence(TimelapseSequence? sequence)
+    {
+        _sequence = sequence;
+        _scroll = 0;
+        _hoverRow = -1;
+        _selectedIndex = sequence is { Count: > 0 } ? 0 : -1;
+        Invalidate();
+    }
+
+    public void Refresh(TimelapseSequence? sequence)
+    {
+        _sequence = sequence;
+        Invalidate();
+    }
+
+    private int VisibleRows => Math.Max(1, (Height - HeaderHeight) / RowHeight);
+    private int RowCount => _sequence?.Count ?? 0;
+    private int MaxScroll => Math.Max(0, RowCount - VisibleRows);
+
+    private void EnsureVisible(int index)
+    {
+        if (index < 0) return;
+        if (index < _scroll) _scroll = index;
+        else if (index >= _scroll + VisibleRows) _scroll = index - VisibleRows + 1;
+        _scroll = Math.Clamp(_scroll, 0, MaxScroll);
+    }
+
+    // ------------------------------------------------------------------ interazione
+
+    protected override bool IsInputKey(Keys keyData) => keyData is Keys.Up or Keys.Down or Keys.PageUp or Keys.PageDown;
+
+    protected override void OnKeyDown(KeyEventArgs e)
+    {
+        if (RowCount == 0) return;
+        switch (e.KeyCode)
+        {
+            case Keys.Up: SelectedIndex = Math.Max(0, _selectedIndex - 1); break;
+            case Keys.Down: SelectedIndex = Math.Min(RowCount - 1, _selectedIndex + 1); break;
+            case Keys.PageUp: SelectedIndex = Math.Max(0, _selectedIndex - VisibleRows); break;
+            case Keys.PageDown: SelectedIndex = Math.Min(RowCount - 1, _selectedIndex + VisibleRows); break;
+            case Keys.Home: SelectedIndex = 0; break;
+            case Keys.End: SelectedIndex = RowCount - 1; break;
+            default: base.OnKeyDown(e); return;
+        }
+        e.Handled = true;
+    }
+
+    protected override void OnMouseWheel(MouseEventArgs e)
+    {
+        _scroll = Math.Clamp(_scroll - Math.Sign(e.Delta) * 3, 0, MaxScroll);
+        Invalidate();
+    }
+
+    protected override void OnMouseDown(MouseEventArgs e)
+    {
+        Focus();
+
+        if (e.X >= Width - ScrollWidth && RowCount > VisibleRows)
+        {
+            var thumb = ThumbBounds();
+            if (thumb.Contains(e.Location)) { _draggingScroll = true; _dragOffset = e.Y - thumb.Top; }
+            else ScrollToThumb(e.Y - thumb.Height / 2);
+            return;
+        }
+
+        int row = (e.Y - HeaderHeight) / RowHeight;
+        int index = _scroll + row;
+        if (e.Y >= HeaderHeight && index >= 0 && index < RowCount) SelectedIndex = index;
+        base.OnMouseDown(e);
+    }
+
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+        if (_draggingScroll) { ScrollToThumb(e.Y - _dragOffset); return; }
+
+        int row = e.Y >= HeaderHeight ? (e.Y - HeaderHeight) / RowHeight : -1;
+        if (row != _hoverRow) { _hoverRow = row; Invalidate(); }
+        base.OnMouseMove(e);
+    }
+
+    protected override void OnMouseUp(MouseEventArgs e) { _draggingScroll = false; base.OnMouseUp(e); }
+    protected override void OnMouseLeave(EventArgs e) { _hoverRow = -1; Invalidate(); base.OnMouseLeave(e); }
+
+    private Rectangle ThumbBounds()
+    {
+        int trackHeight = Height - HeaderHeight;
+        if (RowCount <= VisibleRows) return new Rectangle(Width - ScrollWidth, HeaderHeight, ScrollWidth, trackHeight);
+
+        int thumbHeight = Math.Max(28, trackHeight * VisibleRows / RowCount);
+        int available = trackHeight - thumbHeight;
+        int offset = MaxScroll == 0 ? 0 : available * _scroll / MaxScroll;
+        return new Rectangle(Width - ScrollWidth + 2, HeaderHeight + offset, ScrollWidth - 4, thumbHeight);
+    }
+
+    private void ScrollToThumb(int top)
+    {
+        int trackHeight = Height - HeaderHeight;
+        int thumbHeight = Math.Max(28, trackHeight * VisibleRows / Math.Max(1, RowCount));
+        int available = Math.Max(1, trackHeight - thumbHeight);
+        double fraction = Math.Clamp((top - HeaderHeight) / (double)available, 0, 1);
+        _scroll = (int)Math.Round(fraction * MaxScroll);
+        Invalidate();
+    }
+
+    // ------------------------------------------------------------------ disegno
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Theme.Surface);
+
+        int contentWidth = Width - (RowCount > VisibleRows ? ScrollWidth : 0);
+        DrawHeader(g, contentWidth);
+
+        if (_sequence is not { Count: > 0 })
+        {
+            TextRenderer.DrawText(g, "Trascina qui le immagini della sequenza, oppure usa «Aggiungi cartella»",
+                                  Theme.Body, new Rectangle(0, HeaderHeight, Width, Height - HeaderHeight),
+                                  Theme.TextFaint,
+                                  TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);
+            return;
+        }
+
+        int last = Math.Min(RowCount, _scroll + VisibleRows + 1);
+        for (int index = _scroll; index < last; index++)
+        {
+            int y = HeaderHeight + (index - _scroll) * RowHeight;
+            if (y > Height) break;
+            DrawRow(g, _sequence.Frames[index], index, y, contentWidth);
+        }
+
+        DrawScrollBar(g);
+    }
+
+    private void DrawHeader(Graphics g, int contentWidth)
+    {
+        using (var brush = new SolidBrush(Theme.Background))
+            g.FillRectangle(brush, 0, 0, Width, HeaderHeight);
+        using (var pen = new Pen(Theme.Border))
+            g.DrawLine(pen, 0, HeaderHeight - 1, Width, HeaderHeight - 1);
+
+        int x = 8;
+        foreach (var column in _columns)
+        {
+            if (x > contentWidth) break;
+            var bounds = new Rectangle(x, 0, Math.Min(column.Width - 8, contentWidth - x), HeaderHeight);
+            TextRenderer.DrawText(g, column.Title, Theme.SmallBold, bounds, Theme.TextMuted,
+                                  (column.RightAligned ? TextFormatFlags.Right : TextFormatFlags.Left) |
+                                  TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis);
+            x += column.Width;
+        }
+    }
+
+    private void DrawRow(Graphics g, FrameRecord record, int index, int y, int contentWidth)
+    {
+        bool selected = index == _selectedIndex;
+        bool hovered = _hoverRow == index - _scroll;
+
+        if (selected)
+        {
+            using var brush = new SolidBrush(Color.FromArgb(58, Theme.Accent));
+            g.FillRectangle(brush, 0, y, contentWidth, RowHeight);
+            using var edge = new SolidBrush(Theme.Accent);
+            g.FillRectangle(edge, 0, y, 2, RowHeight);
+        }
+        else if (hovered)
+        {
+            using var brush = new SolidBrush(Theme.SurfaceAlt);
+            g.FillRectangle(brush, 0, y, contentWidth, RowHeight);
+        }
+        else if ((index & 1) == 1)
+        {
+            using var brush = new SolidBrush(Color.FromArgb(0x1F, 0x22, 0x29));
+            g.FillRectangle(brush, 0, y, contentWidth, RowHeight);
+        }
+
+        int x = 8;
+        for (int c = 0; c < _columns.Length; c++)
+        {
+            var column = _columns[c];
+            if (x > contentWidth) break;
+
+            Color color = c switch
+            {
+                0 => Theme.TextFaint,
+                1 => selected ? Theme.Text : Theme.Text,
+                10 => GainColor(record),
+                _ => Theme.TextMuted,
+            };
+
+            // Un intervallo anomalo va segnalato dove si legge: sulla colonna Δt.
+            if (c == 3 && record.IsCadenceAnomaly) color = Theme.Warning;
+            if (c == 2 && record.Metadata.CaptureSource == TimestampSource.FileSystem) color = Theme.Warning;
+
+            var bounds = new Rectangle(x, y, Math.Min(column.Width - 8, Math.Max(0, contentWidth - x)), RowHeight);
+            TextRenderer.DrawText(g, column.Value(record), c == 1 ? Theme.Body : Theme.Small, bounds, color,
+                                  (column.RightAligned ? TextFormatFlags.Right : TextFormatFlags.Left) |
+                                  TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis);
+            x += column.Width;
+        }
+    }
+
+    private static Color GainColor(FrameRecord record)
+    {
+        if (!record.LuminanceAnalyzed) return Theme.TextFaint;
+        double stops = Math.Abs(record.GainStops);
+        if (stops < 0.02) return Theme.TextMuted;
+        return record.GainStops > 0 ? Theme.Success : Theme.Danger;
+    }
+
+    private void DrawScrollBar(Graphics g)
+    {
+        if (RowCount <= VisibleRows) return;
+
+        using (var track = new SolidBrush(Theme.Background))
+            g.FillRectangle(track, Width - ScrollWidth, HeaderHeight, ScrollWidth, Height - HeaderHeight);
+
+        var thumb = ThumbBounds();
+        Theme.FillRounded(g, thumb, 3f, _draggingScroll ? Theme.Accent : Theme.BorderStrong);
+    }
+}

Titano/UI/LuminanceChart.cs

@@ -0,0 +1,549 @@
+using System.Drawing.Drawing2D;
+using Titano.Analysis;
+using Titano.Core;
+
+namespace Titano.UI;
+
+/// <summary>
+/// Sistema di rendering vettoriale per la curva di esposizione.
+///
+/// Sovrappone la luminanza misurata (lo sfarfallio, in ambra) alla curva target calcolata
+/// dal deflicker (in blu), riempiendo lo scarto fra le due — che è esattamente la correzione
+/// applicata. Una corsia inferiore mostra il guadagno in stop per fotogramma e le anomalie
+/// di cadenza dell'intervallometro. Tutto è disegnato con primitive vettoriali: zoom e
+/// spostamento non degradano la resa.
+/// </summary>
+internal sealed class LuminanceChart : Control
+{
+    private TimelapseSequence? _sequence;
+    private DeflickerCurve? _curve;
+
+    private double _viewStart;
+    private double _viewEnd = 1;
+    private int _hoverIndex = -1;
+    private int _selectedIndex = -1;
+    private Point _mousePosition;
+    private bool _panning;
+    private double _panAnchor;
+    private int _panOriginX;
+
+    private const int GutterLeft = 62;
+    private const int GutterBottom = 22;
+    private const int GutterTop = 26;
+    private const int GainLaneHeight = 62;
+
+    public event EventHandler? SelectionChanged;
+
+    public int SelectedIndex
+    {
+        get => _selectedIndex;
+        set
+        {
+            if (_selectedIndex == value) return;
+            _selectedIndex = value;
+            Invalidate();
+            SelectionChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    public LuminanceChart()
+    {
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        BackColor = Theme.Surface;
+    }
+
+    public void SetData(TimelapseSequence? sequence, DeflickerCurve? curve)
+    {
+        _sequence = sequence;
+        _curve = curve;
+        _viewStart = 0;
+        _viewEnd = Math.Max(1, (sequence?.Count ?? 1) - 1);
+        _hoverIndex = -1;
+        Invalidate();
+    }
+
+    /// <summary>Aggiorna la sola curva conservando zoom e selezione (cursori del deflicker).</summary>
+    public void UpdateCurve(DeflickerCurve? curve)
+    {
+        _curve = curve;
+        Invalidate();
+    }
+
+    private Rectangle PlotArea
+    {
+        get
+        {
+            int height = Math.Max(40, Height - GutterTop - GutterBottom - GainLaneHeight);
+            return new Rectangle(GutterLeft, GutterTop, Math.Max(10, Width - GutterLeft - 12), height);
+        }
+    }
+
+    private Rectangle GainArea
+    {
+        get
+        {
+            var plot = PlotArea;
+            return new Rectangle(plot.Left, plot.Bottom + 6, plot.Width, GainLaneHeight - 12);
+        }
+    }
+
+    // ------------------------------------------------------------------ interazione
+
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+        _mousePosition = e.Location;
+
+        if (_panning)
+        {
+            var plot = PlotArea;
+            double span = _viewEnd - _viewStart;
+            double delta = (e.X - _panOriginX) / (double)Math.Max(1, plot.Width) * span;
+            double start = _panAnchor - delta;
+            int max = Math.Max(0, (_sequence?.Count ?? 1) - 1);
+            start = Math.Clamp(start, 0, Math.Max(0, max - span));
+            _viewStart = start;
+            _viewEnd = start + span;
+            Invalidate();
+            return;
+        }
+
+        int index = IndexAt(e.X);
+        if (index != _hoverIndex) { _hoverIndex = index; Invalidate(); }
+        else if (index >= 0) Invalidate();
+
+        base.OnMouseMove(e);
+    }
+
+    protected override void OnMouseLeave(EventArgs e)
+    {
+        _hoverIndex = -1;
+        Invalidate();
+        base.OnMouseLeave(e);
+    }
+
+    protected override void OnMouseDown(MouseEventArgs e)
+    {
+        Focus();
+        if (e.Button == MouseButtons.Left)
+        {
+            int index = IndexAt(e.X);
+            if (index >= 0) SelectedIndex = index;
+        }
+        else if (e.Button == MouseButtons.Right)
+        {
+            _panning = true;
+            _panAnchor = _viewStart;
+            _panOriginX = e.X;
+            Cursor = Cursors.SizeWE;
+        }
+        base.OnMouseDown(e);
+    }
+
+    protected override void OnMouseUp(MouseEventArgs e)
+    {
+        _panning = false;
+        Cursor = Cursors.Default;
+        base.OnMouseUp(e);
+    }
+
+    protected override void OnMouseWheel(MouseEventArgs e)
+    {
+        if (_sequence is not { Count: > 1 }) return;
+
+        int last = _sequence.Count - 1;
+        var plot = PlotArea;
+        double fraction = Math.Clamp((e.X - plot.Left) / (double)Math.Max(1, plot.Width), 0, 1);
+        double focus = _viewStart + fraction * (_viewEnd - _viewStart);
+
+        double factor = e.Delta > 0 ? 0.8 : 1.25;
+        double span = Math.Clamp((_viewEnd - _viewStart) * factor, 4, last);
+
+        _viewStart = Math.Clamp(focus - fraction * span, 0, Math.Max(0, last - span));
+        _viewEnd = _viewStart + span;
+        Invalidate();
+    }
+
+    protected override void OnMouseDoubleClick(MouseEventArgs e)
+    {
+        _viewStart = 0;
+        _viewEnd = Math.Max(1, (_sequence?.Count ?? 1) - 1);
+        Invalidate();
+        base.OnMouseDoubleClick(e);
+    }
+
+    private int IndexAt(int x)
+    {
+        if (_sequence is not { Count: > 0 }) return -1;
+        var plot = PlotArea;
+        if (x < plot.Left - 4 || x > plot.Right + 4) return -1;
+
+        double fraction = (x - plot.Left) / (double)Math.Max(1, plot.Width);
+        double position = _viewStart + fraction * (_viewEnd - _viewStart);
+        return Math.Clamp((int)Math.Round(position), 0, _sequence.Count - 1);
+    }
+
+    private float XFor(double index, Rectangle plot)
+    {
+        double span = Math.Max(1e-6, _viewEnd - _viewStart);
+        return plot.Left + (float)((index - _viewStart) / span * plot.Width);
+    }
+
+    // ------------------------------------------------------------------ disegno
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Theme.Surface);
+
+        var plot = PlotArea;
+
+        if (_sequence is not { Count: > 1 } || _curve is null || _curve.Count < 2)
+        {
+            DrawEmptyState(g);
+            return;
+        }
+
+        // Estensione verticale: unione delle due curve con un margine costante.
+        double minValue = double.MaxValue, maxValue = double.MinValue;
+        int from = Math.Max(0, (int)Math.Floor(_viewStart));
+        int to = Math.Min(_curve.Count - 1, (int)Math.Ceiling(_viewEnd));
+
+        for (int i = from; i <= to; i++)
+        {
+            minValue = Math.Min(minValue, Math.Min(_curve.Measured[i], _curve.Target[i]));
+            maxValue = Math.Max(maxValue, Math.Max(_curve.Measured[i], _curve.Target[i]));
+        }
+        if (minValue > maxValue) { minValue = -4; maxValue = -1; }
+
+        double padding = Math.Max(0.12, (maxValue - minValue) * 0.15);
+        minValue -= padding;
+        maxValue += padding;
+
+        DrawGrid(g, plot, minValue, maxValue);
+        DrawCadenceMarkers(g, plot);
+        DrawCorrectionBand(g, plot, from, to, minValue, maxValue);
+        DrawCurve(g, plot, _curve.Measured, from, to, minValue, maxValue, Theme.Measured, 1.4f);
+        DrawCurve(g, plot, _curve.Target, from, to, minValue, maxValue, Theme.Accent, 2.1f);
+        DrawGainLane(g, from, to);
+        DrawSelection(g, plot);
+        DrawLegend(g);
+        DrawHover(g, plot, minValue, maxValue);
+    }
+
+    private void DrawEmptyState(Graphics g)
+    {
+        string message = _sequence is null
+            ? "Nessuna sequenza caricata"
+            : "Esegui l'analisi per visualizzare la curva di esposizione";
+
+        TextRenderer.DrawText(g, message, Theme.Body, new Rectangle(0, 0, Width, Height),
+                              Theme.TextFaint,
+                              TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);
+    }
+
+    private float YFor(double value, Rectangle plot, double min, double max)
+    {
+        double span = Math.Max(1e-6, max - min);
+        return plot.Bottom - (float)((value - min) / span * plot.Height);
+    }
+
+    private void DrawGrid(Graphics g, Rectangle plot, double min, double max)
+    {
+        using var gridPen = new Pen(Theme.Border) { DashStyle = DashStyle.Dot };
+        using var axisPen = new Pen(Theme.BorderStrong);
+
+        // Linee orizzontali a passo di stop intero (o mezzo stop se l'intervallo è stretto).
+        double step = (max - min) > 4 ? 1.0 : (max - min) > 1.6 ? 0.5 : 0.25;
+        double first = Math.Ceiling(min / step) * step;
+
+        for (double value = first; value <= max; value += step)
+        {
+            float y = YFor(value, plot, min, max);
+            g.DrawLine(gridPen, plot.Left, y, plot.Right, y);
+            TextRenderer.DrawText(g, value.ToString("0.##") + " EV", Theme.Small,
+                                  new Rectangle(0, (int)y - 8, GutterLeft - 6, 16), Theme.TextFaint,
+                                  TextFormatFlags.Right | TextFormatFlags.VerticalCenter);
+        }
+
+        g.DrawLine(axisPen, plot.Left, plot.Top, plot.Left, plot.Bottom);
+        g.DrawLine(axisPen, plot.Left, plot.Bottom, plot.Right, plot.Bottom);
+
+        // Etichette dei fotogrammi lungo l'asse orizzontale.
+        int count = _sequence!.Count;
+        double span = _viewEnd - _viewStart;
+        double labelStep = NiceStep(span / 8.0);
+        double firstLabel = Math.Ceiling(_viewStart / labelStep) * labelStep;
+
+        for (double index = firstLabel; index <= _viewEnd; index += labelStep)
+        {
+            float x = XFor(index, plot);
+            if (x < plot.Left - 1 || x > plot.Right + 1) continue;
+            g.DrawLine(gridPen, x, plot.Top, x, plot.Bottom);
+
+            int frame = Math.Clamp((int)Math.Round(index), 0, count - 1);
+            TextRenderer.DrawText(g, (frame + 1).ToString(), Theme.Small,
+                                  new Rectangle((int)x - 30, Height - GutterBottom + 2, 60, 16),
+                                  Theme.TextFaint,
+                                  TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);
+        }
+    }
+
+    private static double NiceStep(double raw)
+    {
+        if (raw <= 1) return 1;
+        double magnitude = Math.Pow(10, Math.Floor(Math.Log10(raw)));
+        double normalized = raw / magnitude;
+        double nice = normalized <= 1 ? 1 : normalized <= 2 ? 2 : normalized <= 5 ? 5 : 10;
+        return nice * magnitude;
+    }
+
+    /// <summary>Tacche verticali sugli intervalli che si discostano dalla cadenza nominale.</summary>
+    private void DrawCadenceMarkers(Graphics g, Rectangle plot)
+    {
+        if (_sequence is null) return;
+        using var brush = new SolidBrush(Color.FromArgb(60, Theme.Warning));
+
+        for (int i = Math.Max(0, (int)_viewStart); i <= Math.Min(_sequence.Count - 1, (int)Math.Ceiling(_viewEnd)); i++)
+        {
+            if (!_sequence.Frames[i].IsCadenceAnomaly) continue;
+            float x = XFor(i, plot);
+            float next = XFor(i + 1, plot);
+            g.FillRectangle(brush, x, plot.Top, Math.Max(1.5f, next - x), plot.Height);
+        }
+    }
+
+    /// <summary>Area fra misurato e target: è la correzione che verrà applicata.</summary>
+    private void DrawCorrectionBand(Graphics g, Rectangle plot, int from, int to, double min, double max)
+    {
+        if (to - from < 1) return;
+
+        var points = new List<PointF>((to - from + 1) * 2);
+        for (int i = from; i <= to; i++) points.Add(new PointF(XFor(i, plot), YFor(_curve!.Measured[i], plot, min, max)));
+        for (int i = to; i >= from; i--) points.Add(new PointF(XFor(i, plot), YFor(_curve!.Target[i], plot, min, max)));
+
+        using var path = new GraphicsPath();
+        path.AddPolygon(points.ToArray());
+        using var brush = new SolidBrush(Color.FromArgb(38, Theme.Accent));
+
+        var clip = g.Clip;
+        g.SetClip(plot);
+        g.FillPath(brush, path);
+        g.Clip = clip;
+    }
+
+    private void DrawCurve(Graphics g, Rectangle plot, double[] values, int from, int to,
+                           double min, double max, Color color, float width)
+    {
+        if (to - from < 1) return;
+
+        var clip = g.Clip;
+        g.SetClip(Rectangle.Inflate(plot, 2, 2));
+
+        using var pen = new Pen(color, width)
+        {
+            LineJoin = LineJoin.Round,
+            StartCap = LineCap.Round,
+            EndCap = LineCap.Round,
+        };
+
+        int visible = to - from + 1;
+        if (visible > plot.Width * 2)
+        {
+            // Più campioni che pixel: si traccia l'inviluppo min/max per colonna,
+            // preservando l'ampiezza reale dello sfarfallio invece di alias arbitrari.
+            DrawEnvelope(g, plot, values, from, to, min, max, color);
+        }
+        else
+        {
+            var points = new PointF[visible];
+            for (int i = 0; i < visible; i++)
+            {
+                points[i] = new PointF(XFor(from + i, plot), YFor(values[from + i], plot, min, max));
+            }
+            if (points.Length >= 2) g.DrawLines(pen, points);
+        }
+
+        // Punti singoli quando lo zoom è sufficiente a distinguerli.
+        if (visible <= 90)
+        {
+            using var dot = new SolidBrush(color);
+            for (int i = from; i <= to; i++)
+            {
+                float x = XFor(i, plot);
+                float y = YFor(values[i], plot, min, max);
+                g.FillEllipse(dot, x - 2f, y - 2f, 4f, 4f);
+            }
+        }
+
+        g.Clip = clip;
+    }
+
+    private void DrawEnvelope(Graphics g, Rectangle plot, double[] values, int from, int to,
+                              double min, double max, Color color)
+    {
+        using var pen = new Pen(Color.FromArgb(200, color), 1f);
+        double perPixel = (to - from + 1) / (double)plot.Width;
+
+        for (int px = 0; px < plot.Width; px++)
+        {
+            int start = from + (int)(px * perPixel);
+            int end = Math.Min(to, from + (int)((px + 1) * perPixel));
+            if (start > end) continue;
+
+            double lo = double.MaxValue, hi = double.MinValue;
+            for (int i = start; i <= end; i++)
+            {
+                lo = Math.Min(lo, values[i]);
+                hi = Math.Max(hi, values[i]);
+            }
+
+            float x = plot.Left + px;
+            g.DrawLine(pen, x, YFor(hi, plot, min, max), x, YFor(lo, plot, min, max) + 0.5f);
+        }
+    }
+
+    /// <summary>Corsia inferiore: guadagno per fotogramma in stop, con lo zero al centro.</summary>
+    private void DrawGainLane(Graphics g, int from, int to)
+    {
+        var lane = GainArea;
+        if (lane.Height < 12) return;
+
+        double peak = 0.05;
+        for (int i = from; i <= to; i++) peak = Math.Max(peak, Math.Abs(_curve!.GainStops[i]));
+        peak = Math.Max(peak, 0.05);
+
+        float zero = lane.Top + lane.Height / 2f;
+        using (var basePen = new Pen(Theme.Border)) g.DrawLine(basePen, lane.Left, zero, lane.Right, zero);
+
+        TextRenderer.DrawText(g, "guadagno", Theme.Small, new Rectangle(0, (int)zero - 8, GutterLeft - 6, 16),
+                              Theme.TextFaint, TextFormatFlags.Right | TextFormatFlags.VerticalCenter);
+        TextRenderer.DrawText(g, $"fondoscala ±{peak:0.##} EV", Theme.Small,
+                              new Rectangle(Width - 172, 4, 160, 16), Theme.TextFaint,
+                              TextFormatFlags.Right | TextFormatFlags.VerticalCenter);
+
+        double perColumn = (to - from + 1) / (double)Math.Max(1, lane.Width);
+        float barWidth = Math.Max(1f, (float)(lane.Width / (double)Math.Max(1, to - from + 1)) - 1f);
+
+        using var positive = new SolidBrush(Color.FromArgb(190, Theme.Success));
+        using var negative = new SolidBrush(Color.FromArgb(190, Theme.Danger));
+
+        if (perColumn <= 1.0)
+        {
+            for (int i = from; i <= to; i++)
+            {
+                double gain = _curve!.GainStops[i];
+                float x = XFor(i, lane) - barWidth / 2f;
+                float height = (float)(Math.Abs(gain) / peak * (lane.Height / 2f - 2));
+                if (height < 0.6f) continue;
+                var rect = gain >= 0
+                    ? new RectangleF(x, zero - height, barWidth, height)
+                    : new RectangleF(x, zero, barWidth, height);
+                g.FillRectangle(gain >= 0 ? positive : negative, rect);
+            }
+        }
+        else
+        {
+            for (int px = 0; px < lane.Width; px++)
+            {
+                int start = from + (int)(px * perColumn);
+                int end = Math.Min(to, from + (int)((px + 1) * perColumn));
+                if (start > end) continue;
+
+                double lo = 0, hi = 0;
+                for (int i = start; i <= end; i++)
+                {
+                    lo = Math.Min(lo, _curve!.GainStops[i]);
+                    hi = Math.Max(hi, _curve!.GainStops[i]);
+                }
+
+                float x = lane.Left + px;
+                float top = zero - (float)(hi / peak * (lane.Height / 2f - 2));
+                float bottom = zero - (float)(lo / peak * (lane.Height / 2f - 2));
+                g.FillRectangle(hi >= -lo ? positive : negative, x, top, 1f, Math.Max(1f, bottom - top));
+            }
+        }
+    }
+
+    private void DrawSelection(Graphics g, Rectangle plot)
+    {
+        if (_selectedIndex < 0 || _sequence is null || _selectedIndex >= _sequence.Count) return;
+        float x = XFor(_selectedIndex, plot);
+        if (x < plot.Left || x > plot.Right) return;
+
+        using var pen = new Pen(Color.FromArgb(150, Theme.Text), 1f) { DashStyle = DashStyle.Dash };
+        g.DrawLine(pen, x, plot.Top, x, GainArea.Bottom);
+    }
+
+    private void DrawLegend(Graphics g)
+    {
+        var entries = new (Color Color, string Label)[]
+        {
+            (Theme.Measured, "luminanza misurata"),
+            (Theme.Accent, "curva target"),
+            (Theme.Warning, "cadenza anomala"),
+        };
+
+        int x = GutterLeft;
+        for (int i = 0; i < entries.Length; i++)
+        {
+            var (color, label) = entries[i];
+            // L'ultima voce indica una fascia di sfondo, non una curva: si disegna come tale.
+            bool band = i == entries.Length - 1;
+            using (var brush = new SolidBrush(band ? Color.FromArgb(90, color) : color))
+                g.FillRectangle(brush, x, band ? 5 : 10, 14, band ? 12 : 3);
+            var size = TextRenderer.MeasureText(g, label, Theme.Small);
+            TextRenderer.DrawText(g, label, Theme.Small, new Rectangle(x + 19, 4, size.Width + 4, 16),
+                                  Theme.TextMuted, TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
+            x += 19 + size.Width + 18;
+        }
+    }
+
+    private void DrawHover(Graphics g, Rectangle plot, double min, double max)
+    {
+        if (_hoverIndex < 0 || _sequence is null || _hoverIndex >= _sequence.Count || _curve is null) return;
+
+        float x = XFor(_hoverIndex, plot);
+        if (x < plot.Left - 2 || x > plot.Right + 2) return;
+
+        using (var pen = new Pen(Color.FromArgb(90, Theme.Text), 1f)) g.DrawLine(pen, x, plot.Top, x, GainArea.Bottom);
+
+        float measuredY = YFor(_curve.Measured[_hoverIndex], plot, min, max);
+        float targetY = YFor(_curve.Target[_hoverIndex], plot, min, max);
+
+        using (var brush = new SolidBrush(Theme.Measured)) g.FillEllipse(brush, x - 3.5f, measuredY - 3.5f, 7, 7);
+        using (var brush = new SolidBrush(Theme.Accent)) g.FillEllipse(brush, x - 3.5f, targetY - 3.5f, 7, 7);
+
+        var record = _sequence.Frames[_hoverIndex];
+        string[] lines =
+        [
+            $"#{_hoverIndex + 1}  {record.FileName}",
+            $"misurata  {_curve.Measured[_hoverIndex]:0.00} EV",
+            $"target    {_curve.Target[_hoverIndex]:0.00} EV",
+            $"guadagno  {_curve.GainStops[_hoverIndex]:+0.00;-0.00;0.00} EV",
+            $"intervallo {record.CadenceText}   otturatore {record.ShutterAngle:0.#}°",
+        ];
+
+        int widthNeeded = 0;
+        foreach (string line in lines)
+            widthNeeded = Math.Max(widthNeeded, TextRenderer.MeasureText(g, line, Theme.Small).Width);
+
+        int boxWidth = widthNeeded + 18;
+        int boxHeight = lines.Length * 15 + 12;
+        int boxX = (int)(x + 14);
+        if (boxX + boxWidth > Width - 6) boxX = (int)(x - 14 - boxWidth);
+        int boxY = Math.Clamp(_mousePosition.Y - boxHeight / 2, plot.Top, Math.Max(plot.Top, Height - boxHeight - 4));
+
+        var box = new RectangleF(boxX, boxY, boxWidth, boxHeight);
+        Theme.FillAndStroke(g, box, 6f, Color.FromArgb(242, Theme.Background), Theme.BorderStrong);
+
+        for (int i = 0; i < lines.Length; i++)
+        {
+            TextRenderer.DrawText(g, lines[i], i == 0 ? Theme.SmallBold : Theme.Small,
+                                  new Rectangle(boxX + 9, boxY + 6 + i * 15, boxWidth - 18, 15),
+                                  i == 0 ? Theme.Text : Theme.TextMuted,
+                                  TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
+        }
+    }
+}

Titano/UI/MainForm.cs

@@ -0,0 +1,588 @@
+using Titano.Core;
+using Titano.Metadata;
+using Titano.Pipeline;
+
+namespace Titano.UI;
+
+/// <summary>Finestra principale: collega i controlli disegnati a mano al motore di elaborazione.</summary>
+internal sealed class MainForm : Form
+{
+    private readonly TitanoProject _project = new();
+
+    private readonly LuminanceChart _chart;
+    private readonly FrameTable _table;
+    private readonly PreviewPanel _preview;
+    private readonly SettingsPanel _settings;
+    private readonly DarkProgressBar _progress;
+    private readonly Label _status;
+    private readonly Label _summary;
+
+    private readonly DarkButton _addFilesButton;
+    private readonly DarkButton _addFolderButton;
+    private readonly DarkButton _clearButton;
+    private readonly DarkButton _analyzeButton;
+    private readonly DarkButton _exportButton;
+    private readonly DarkButton _cancelButton;
+
+    private CancellationTokenSource? _operation;
+    private bool _busy;
+
+    public MainForm()
+    {
+        Text = "Titano — time-lapse";
+        MinimumSize = new Size(1180, 720);
+        Size = new Size(1560, 950);
+        StartPosition = FormStartPosition.CenterScreen;
+        BackColor = Theme.Background;
+        ForeColor = Theme.Text;
+        Font = Theme.Body;
+        AllowDrop = true;
+        DoubleBuffered = true;
+
+        _chart = new LuminanceChart { Dock = DockStyle.Fill };
+        _table = new FrameTable { Dock = DockStyle.Fill };
+        _preview = new PreviewPanel(_project) { Dock = DockStyle.Fill };
+        _settings = new SettingsPanel(_project) { Dock = DockStyle.Fill };
+        _progress = new DarkProgressBar { Dock = DockStyle.Fill };
+
+        _status = new Label
+        {
+            Dock = DockStyle.Fill,
+            ForeColor = Theme.TextMuted,
+            Font = Theme.Small,
+            TextAlign = ContentAlignment.MiddleLeft,
+            Text = "Pronto. Trascina qui una sequenza di immagini per iniziare.",
+        };
+
+        _summary = new Label
+        {
+            Dock = DockStyle.Fill,
+            ForeColor = Theme.TextFaint,
+            Font = Theme.Small,
+            TextAlign = ContentAlignment.MiddleRight,
+            Text = string.Empty,
+        };
+
+        _addFilesButton = new DarkButton { Text = "Aggiungi file…", Width = 130 };
+        _addFolderButton = new DarkButton { Text = "Aggiungi cartella…", Width = 150 };
+        _clearButton = new DarkButton { Text = "Svuota", Width = 84 };
+        _analyzeButton = new DarkButton { Text = "Analizza sequenza", Width = 160 };
+        _exportButton = new DarkButton { Text = "Esporta video", Width = 140, Primary = true };
+        _cancelButton = new DarkButton { Text = "Annulla", Width = 96, Danger = true, Visible = false };
+
+        BuildLayout();
+        WireEvents();
+        UpdateCommandState();
+    }
+
+    protected override void OnHandleCreated(EventArgs e)
+    {
+        base.OnHandleCreated(e);
+        Theme.ApplyDarkTitleBar(this);
+    }
+
+    protected override void OnShown(EventArgs e)
+    {
+        base.OnShown(e);
+        // La cornice viene ridisegnata dal sistema alla comparsa: l'attributo va riconfermato.
+        Theme.ApplyDarkTitleBar(this);
+    }
+
+    // ------------------------------------------------------------------ struttura
+
+    private void BuildLayout()
+    {
+        var toolbar = BuildToolbar();
+        var statusBar = BuildStatusBar();
+
+        var settingsHost = new Panel
+        {
+            Dock = DockStyle.Right,
+            Width = 372,
+            BackColor = Theme.Surface,
+            Padding = new Padding(1, 0, 0, 0),
+        };
+        settingsHost.Controls.Add(_settings);
+        settingsHost.Paint += (_, e) =>
+        {
+            using var pen = new Pen(Theme.Border);
+            e.Graphics.DrawLine(pen, 0, 0, 0, settingsHost.Height);
+        };
+
+        var center = new Panel { Dock = DockStyle.Fill, BackColor = Theme.Background };
+
+        var tableHost = Card(_table, "Fotogrammi", DockStyle.Fill);
+        var chartHost = Card(_chart, "Curva di esposizione", DockStyle.Top, 268);
+        var previewHost = Card(_preview, "Anteprima", DockStyle.Top, 300);
+
+        var chartSplitter = new Splitter { Dock = DockStyle.Top, Height = 6, BackColor = Theme.Background };
+        var previewSplitter = new Splitter { Dock = DockStyle.Top, Height = 6, BackColor = Theme.Background };
+
+        center.Controls.Add(tableHost);
+        center.Controls.Add(chartSplitter);
+        center.Controls.Add(chartHost);
+        center.Controls.Add(previewSplitter);
+        center.Controls.Add(previewHost);
+
+        Controls.Add(center);
+        Controls.Add(settingsHost);
+        Controls.Add(statusBar);
+        Controls.Add(toolbar);
+    }
+
+    /// <summary>Riquadro con intestazione: unità visiva ricorrente dell'interfaccia.</summary>
+    private static Panel Card(Control content, string title, DockStyle dock, int height = 0)
+    {
+        var host = new Panel
+        {
+            Dock = dock,
+            BackColor = Theme.Surface,
+            Padding = new Padding(1, 30, 1, 1),
+            Margin = new Padding(0),
+        };
+        if (height > 0) host.Height = height;
+
+        host.Controls.Add(content);
+        host.Paint += (_, e) =>
+        {
+            var g = e.Graphics;
+            Theme.HighQuality(g);
+            using (var brush = new SolidBrush(Theme.Background))
+                g.FillRectangle(brush, 0, 0, host.Width, 30);
+            TextRenderer.DrawText(g, title, Theme.SmallBold, new Rectangle(12, 0, host.Width - 24, 30),
+                                  Theme.TextMuted, TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
+            using var pen = new Pen(Theme.Border);
+            g.DrawRectangle(pen, 0, 0, host.Width - 1, host.Height - 1);
+            g.DrawLine(pen, 0, 29, host.Width, 29);
+        };
+        return host;
+    }
+
+    private Panel BuildToolbar()
+    {
+        var bar = new Panel { Dock = DockStyle.Top, Height = 58, BackColor = Theme.Background };
+
+        var title = new Label
+        {
+            Text = "TITANO",
+            Font = Theme.Title,
+            ForeColor = Theme.Text,
+            AutoSize = false,
+            Bounds = new Rectangle(16, 12, 110, 32),
+            TextAlign = ContentAlignment.MiddleLeft,
+        };
+
+        var subtitle = new Label
+        {
+            Text = "elaborazione time-lapse",
+            Font = Theme.Small,
+            ForeColor = Theme.TextFaint,
+            AutoSize = false,
+            Bounds = new Rectangle(112, 20, 160, 18),
+            TextAlign = ContentAlignment.MiddleLeft,
+        };
+
+        int x = 288;
+        foreach (var button in new[] { _addFilesButton, _addFolderButton, _clearButton })
+        {
+            button.Bounds = new Rectangle(x, 13, button.Width, 32);
+            bar.Controls.Add(button);
+            x += button.Width + 8;
+        }
+
+        _analyzeButton.Bounds = new Rectangle(x + 16, 13, _analyzeButton.Width, 32);
+        bar.Controls.Add(_analyzeButton);
+        x += _analyzeButton.Width + 24;
+
+        _exportButton.Bounds = new Rectangle(x, 13, _exportButton.Width, 32);
+        bar.Controls.Add(_exportButton);
+
+        bar.Controls.Add(title);
+        bar.Controls.Add(subtitle);
+
+        bar.Paint += (_, e) =>
+        {
+            using var pen = new Pen(Theme.Border);
+            e.Graphics.DrawLine(pen, 0, bar.Height - 1, bar.Width, bar.Height - 1);
+        };
+        return bar;
+    }
+
+    private Panel BuildStatusBar()
+    {
+        var bar = new Panel { Dock = DockStyle.Bottom, Height = 52, BackColor = Theme.Background };
+
+        var layout = new TableLayoutPanel
+        {
+            Dock = DockStyle.Fill,
+            ColumnCount = 3,
+            RowCount = 2,
+            BackColor = Theme.Background,
+            Padding = new Padding(16, 6, 16, 6),
+        };
+        layout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 60));
+        layout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 40));
+        layout.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 104));
+        layout.RowStyles.Add(new RowStyle(SizeType.Percent, 50));
+        layout.RowStyles.Add(new RowStyle(SizeType.Percent, 50));
+
+        layout.Controls.Add(_status, 0, 0);
+        layout.Controls.Add(_summary, 1, 0);
+        layout.Controls.Add(_progress, 0, 1);
+        layout.SetColumnSpan(_progress, 2);
+
+        _cancelButton.Dock = DockStyle.Fill;
+        _cancelButton.Margin = new Padding(8, 4, 0, 4);
+        layout.Controls.Add(_cancelButton, 2, 0);
+        layout.SetRowSpan(_cancelButton, 2);
+
+        bar.Controls.Add(layout);
+        bar.Paint += (_, e) =>
+        {
+            using var pen = new Pen(Theme.Border);
+            e.Graphics.DrawLine(pen, 0, 0, bar.Width, 0);
+        };
+        return bar;
+    }
+
+    // ------------------------------------------------------------------ eventi
+
+    private void WireEvents()
+    {
+        _addFilesButton.Click += (_, _) => AddFiles();
+        _addFolderButton.Click += (_, _) => AddFolder();
+        _clearButton.Click += (_, _) => ClearSequence();
+        _analyzeButton.Click += async (_, _) => await AnalyzeAsync();
+        _exportButton.Click += async (_, _) => await ExportAsync();
+        _cancelButton.Click += (_, _) => _operation?.Cancel();
+
+        _chart.SelectionChanged += (_, _) =>
+        {
+            if (_chart.SelectedIndex >= 0) _table.SelectedIndex = _chart.SelectedIndex;
+            ShowPreview(_chart.SelectedIndex);
+        };
+
+        _table.SelectionChanged += (_, _) =>
+        {
+            if (_table.SelectedIndex >= 0) _chart.SelectedIndex = _table.SelectedIndex;
+            ShowPreview(_table.SelectedIndex);
+        };
+
+        _settings.DeflickerChanged += (_, _) => RecomputeCurve();
+        _settings.AnalysisInvalidated += (_, _) => InvalidateAnalysis();
+        _settings.PreviewInvalidated += (_, _) => ShowPreview(_table.SelectedIndex);
+        _settings.BrowseOutputRequested += (_, _) => BrowseOutput();
+
+        DragEnter += (_, e) =>
+        {
+            if (e.Data?.GetDataPresent(DataFormats.FileDrop) == true) e.Effect = DragDropEffects.Copy;
+        };
+        DragDrop += (_, e) =>
+        {
+            if (e.Data?.GetData(DataFormats.FileDrop) is string[] items) _ = LoadAsync(ExpandPaths(items));
+        };
+    }
+
+    // ------------------------------------------------------------------ comandi
+
+    private void AddFiles()
+    {
+        using var dialog = new OpenFileDialog
+        {
+            Multiselect = true,
+            Title = "Seleziona i fotogrammi della sequenza",
+            Filter = "Immagini (" + string.Join(";", MetadataReader.SupportedExtensions.Select(e => "*" + e)) + ")|" +
+                     string.Join(";", MetadataReader.SupportedExtensions.Select(e => "*" + e)) + "|Tutti i file|*.*",
+        };
+        if (dialog.ShowDialog(this) == DialogResult.OK) _ = LoadAsync(dialog.FileNames);
+    }
+
+    private void AddFolder()
+    {
+        using var dialog = new FolderBrowserDialog { Description = "Seleziona la cartella della sequenza" };
+        if (dialog.ShowDialog(this) == DialogResult.OK) _ = LoadAsync(ExpandPaths([dialog.SelectedPath]));
+    }
+
+    private static string[] ExpandPaths(IEnumerable<string> items)
+    {
+        var files = new List<string>();
+        foreach (string item in items)
+        {
+            if (Directory.Exists(item))
+            {
+                files.AddRange(Directory.EnumerateFiles(item).Where(MetadataReader.IsSupported));
+            }
+            else if (File.Exists(item) && MetadataReader.IsSupported(item))
+            {
+                files.Add(item);
+            }
+        }
+        return [.. files];
+    }
+
+    private async Task LoadAsync(IReadOnlyList<string> paths)
+    {
+        if (_busy || paths.Count == 0)
+        {
+            if (paths.Count == 0) SetStatus("Nessun file d'immagine riconosciuto fra quelli indicati.");
+            return;
+        }
+
+        BeginOperation("Lettura dei metadati…");
+        try
+        {
+            var progress = new Progress<PipelineProgress>(ReportProgress);
+            var sequence = await RenderPipeline.IngestAsync(paths, _project.General.CadenceTolerance,
+                                                            progress, _operation!.Token);
+            _project.Sequence = sequence;
+            _project.Curve = null;
+            _project.Stats = null;
+
+            _table.SetSequence(sequence);
+            _chart.SetData(sequence, null);
+            SuggestOutputPath(sequence);
+            UpdateSummary();
+            ShowPreview(0);
+
+            SetStatus($"{sequence.Count} fotogrammi caricati. Cadenza nominale {sequence.NominalInterval:0.###} s, " +
+                      $"{sequence.CadenceAnomalies} intervalli anomali.");
+        }
+        catch (OperationCanceledException)
+        {
+            SetStatus("Caricamento annullato.");
+        }
+        catch (Exception ex)
+        {
+            SetStatus("Caricamento non riuscito: " + ex.Message);
+        }
+        finally
+        {
+            EndOperation();
+        }
+    }
+
+    private void ClearSequence()
+    {
+        if (_busy) return;
+        _project.Sequence = null;
+        _project.Curve = null;
+        _project.Stats = null;
+        _table.SetSequence(null);
+        _chart.SetData(null, null);
+        _preview.Clear();
+        _summary.Text = string.Empty;
+        SetStatus("Sequenza svuotata.");
+        UpdateCommandState();
+    }
+
+    private async Task AnalyzeAsync()
+    {
+        if (_busy || !_project.HasSequence) return;
+
+        BeginOperation("Analisi della luminanza…");
+        try
+        {
+            var pipeline = new RenderPipeline(_project);
+            var progress = new Progress<PipelineProgress>(ReportProgress);
+            await pipeline.AnalyzeAsync(progress, _operation!.Token);
+
+            _chart.SetData(_project.Sequence, _project.Curve);
+            _table.Refresh(_project.Sequence);
+            UpdateSummary();
+            ShowPreview(_table.SelectedIndex);
+
+            var curve = _project.Curve!;
+            double before = Analysis.DeflickerCurve.FlickerIndex(curve.Measured);
+            var corrected = new double[curve.Count];
+            for (int i = 0; i < curve.Count; i++) corrected[i] = curve.Measured[i] + curve.GainStops[i];
+            double after = Analysis.DeflickerCurve.FlickerIndex(corrected);
+
+            SetStatus($"Analisi completata. Sfarfallio {before:0.000} EV → {after:0.000} EV " +
+                      $"({100 * (1 - after / Math.Max(before, 1e-9)):0.#}% di riduzione).");
+        }
+        catch (OperationCanceledException)
+        {
+            SetStatus("Analisi annullata.");
+        }
+        catch (Exception ex)
+        {
+            SetStatus("Analisi non riuscita: " + ex.Message);
+        }
+        finally
+        {
+            EndOperation();
+        }
+    }
+
+    private async Task ExportAsync()
+    {
+        if (_busy || !_project.HasSequence) return;
+
+        if (string.IsNullOrWhiteSpace(_project.Export.OutputPath))
+        {
+            BrowseOutput();
+            if (string.IsNullOrWhiteSpace(_project.Export.OutputPath)) return;
+        }
+
+        BeginOperation("Elaborazione e codifica…");
+        try
+        {
+            var pipeline = new RenderPipeline(_project);
+            var progress = new Progress<PipelineProgress>(ReportProgress);
+            var result = await pipeline.RenderAsync(progress, _operation!.Token);
+
+            _table.Refresh(_project.Sequence);
+            SetStatus($"Esportazione completata: {result.EncodedFrames} fotogrammi, " +
+                      $"{result.OutputBytes / (1024.0 * 1024.0):0.0} MiB in {result.Elapsed.TotalSeconds:0.0} s " +
+                      $"con {result.EncoderName}{(result.HardwareAccelerated ? " (hardware)" : " (software)")}.");
+        }
+        catch (OperationCanceledException)
+        {
+            SetStatus("Esportazione interrotta. Il file contiene i fotogrammi già codificati.");
+        }
+        catch (Exception ex)
+        {
+            SetStatus("Esportazione non riuscita: " + ex.Message);
+        }
+        finally
+        {
+            EndOperation();
+        }
+    }
+
+    private void BrowseOutput()
+    {
+        using var dialog = new SaveFileDialog
+        {
+            Title = "Destinazione del video",
+            Filter = "Video MP4|*.mp4",
+            DefaultExt = "mp4",
+            FileName = Path.GetFileName(_project.Export.OutputPath) is { Length: > 0 } name ? name : "timelapse.mp4",
+        };
+        if (dialog.ShowDialog(this) != DialogResult.OK) return;
+
+        _project.Export.OutputPath = dialog.FileName;
+        _settings.OutputPathBox.Text = dialog.FileName;
+    }
+
+    private void SuggestOutputPath(TimelapseSequence sequence)
+    {
+        if (!string.IsNullOrWhiteSpace(_project.Export.OutputPath) || sequence.Count == 0) return;
+
+        string? directory = Path.GetDirectoryName(sequence.Frames[0].FilePath);
+        if (directory is null) return;
+
+        string suggestion = Path.Combine(directory, "timelapse.mp4");
+        _project.Export.OutputPath = suggestion;
+        _settings.OutputPathBox.Text = suggestion;
+    }
+
+    // ------------------------------------------------------------------ aggiornamenti
+
+    private void RecomputeCurve()
+    {
+        if (!_project.IsAnalyzed) return;
+        new RenderPipeline(_project).RecomputeCurve();
+        _chart.UpdateCurve(_project.Curve);
+        _table.Refresh(_project.Sequence);
+        UpdateSummary();
+        ShowPreview(_table.SelectedIndex);
+    }
+
+    private void InvalidateAnalysis()
+    {
+        if (_project.Sequence is { } sequence) sequence.RecomputeTiming(_project.General.CadenceTolerance);
+        _project.Curve = null;
+        _project.Stats = null;
+        _chart.SetData(_project.Sequence, null);
+        _table.Refresh(_project.Sequence);
+        UpdateSummary();
+        UpdateCommandState();
+    }
+
+    private void ShowPreview(int index)
+    {
+        if (_project.Sequence is not { Count: > 0 } sequence || index < 0) { _preview.Clear(); return; }
+        _preview.Show(sequence, Math.Clamp(index, 0, sequence.Count - 1));
+    }
+
+    private void UpdateSummary()
+    {
+        if (_project.Sequence is not { Count: > 0 } sequence)
+        {
+            _summary.Text = string.Empty;
+            return;
+        }
+
+        var (width, height) = _project.ResolveWorkingSize();
+        double outputSeconds = sequence.Count / Math.Max(1.0, _project.Export.FrameRate);
+
+        _summary.Text = $"{sequence.Count} scatti · {sequence.TotalDuration:hh\\:mm\\:ss} di ripresa · " +
+                        $"{width}×{height} · {outputSeconds:0.0} s di video" +
+                        (_project.IsAnalyzed ? " · analizzata" : string.Empty);
+    }
+
+    private void ReportProgress(PipelineProgress progress)
+    {
+        _progress.Fraction = progress.Fraction;
+        string detail = progress.Total > 0 ? $" {progress.Completed}/{progress.Total}" : string.Empty;
+        string speed = progress.FramesPerSecond > 0.01
+            ? $"  ·  {progress.FramesPerSecond:0.0} fps  ·  {progress.Remaining:hh\\:mm\\:ss} rimanenti"
+            : string.Empty;
+        _status.Text = progress.Message + detail + speed;
+    }
+
+    private void SetStatus(string message)
+    {
+        _status.Text = message;
+        _progress.Fraction = 0;
+    }
+
+    private void BeginOperation(string message)
+    {
+        _busy = true;
+        _operation?.Dispose();
+        _operation = new CancellationTokenSource();
+        _status.Text = message;
+        _progress.Fraction = 0;
+        _cancelButton.Visible = true;
+        UpdateCommandState();
+    }
+
+    private void EndOperation()
+    {
+        _busy = false;
+        _cancelButton.Visible = false;
+        _progress.Fraction = 0;
+        UpdateCommandState();
+    }
+
+    private void UpdateCommandState()
+    {
+        bool hasSequence = _project.HasSequence;
+        _addFilesButton.Enabled = !_busy;
+        _addFolderButton.Enabled = !_busy;
+        _clearButton.Enabled = !_busy && hasSequence;
+        _analyzeButton.Enabled = !_busy && hasSequence;
+        _exportButton.Enabled = !_busy && hasSequence;
+    }
+
+    protected override void OnFormClosing(FormClosingEventArgs e)
+    {
+        _operation?.Cancel();
+        base.OnFormClosing(e);
+    }
+
+    /// <summary>
+    /// Carica e analizza una sequenza senza interazione: usata dalla modalità di cattura
+    /// dell'interfaccia, che serve a verificare la resa grafica in modo riproducibile.
+    /// </summary>
+    internal void SelectSettingsTab(int index) => _settings.SelectPage(index);
+
+    internal async Task PrepareForCaptureAsync(IReadOnlyList<string> paths)
+    {
+        await LoadAsync(paths);
+        await AnalyzeAsync();
+        _table.SelectedIndex = Math.Min(12, Math.Max(0, (_project.Sequence?.Count ?? 1) - 1));
+    }
+}

Titano/UI/PreviewPanel.cs

@@ -0,0 +1,272 @@
+using System.Drawing.Imaging;
+using Titano.Core;
+using Titano.Imaging;
+using Titano.Motion;
+using Titano.Pipeline;
+
+namespace Titano.UI;
+
+/// <summary>
+/// Anteprima del fotogramma selezionato, resa dallo stesso motore usato in esportazione:
+/// decodifica, correzione di esposizione e — se attivo — motion blur sintetico calcolato
+/// sul campo vettoriale verso il fotogramma successivo.
+/// </summary>
+internal sealed class PreviewPanel : Control
+{
+    private readonly TitanoProject _project;
+    private Bitmap? _bitmap;
+    private string _caption = string.Empty;
+    private string _status = "Nessun fotogramma selezionato";
+    private CancellationTokenSource? _pending;
+    private int _requestId;
+    private bool _busy;
+
+    public PreviewPanel(TitanoProject project)
+    {
+        _project = project;
+        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
+                 ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw, true);
+        BackColor = Theme.Background;
+    }
+
+    public void Clear()
+    {
+        Interlocked.Increment(ref _requestId);
+        _pending?.Cancel();
+        SwapBitmap(null);
+        _caption = string.Empty;
+        _status = "Nessun fotogramma selezionato";
+        Invalidate();
+    }
+
+    /// <summary>Richiede il rendering del fotogramma indicato; le richieste precedenti vengono annullate.</summary>
+    public void Show(TimelapseSequence sequence, int index)
+    {
+        if (index < 0 || index >= sequence.Count) { Clear(); return; }
+
+        int requestId = Interlocked.Increment(ref _requestId);
+        _pending?.Cancel();
+        var source = new CancellationTokenSource();
+        _pending = source;
+
+        var record = sequence.Frames[index];
+        _caption = $"#{index + 1}  {record.FileName}";
+        _busy = true;
+        Invalidate();
+
+        var project = _project;
+        var token = source.Token;
+
+        _ = Task.Run(() =>
+        {
+            try
+            {
+                var (bitmap, status) = Render(project, sequence, index, PreviewSize(), token);
+                if (token.IsCancellationRequested || requestId != Volatile.Read(ref _requestId))
+                {
+                    bitmap?.Dispose();
+                    return;
+                }
+
+                BeginInvoke(() =>
+                {
+                    if (requestId != Volatile.Read(ref _requestId)) { bitmap?.Dispose(); return; }
+                    SwapBitmap(bitmap);
+                    _status = status;
+                    _busy = false;
+                    Invalidate();
+                });
+            }
+            catch (Exception ex)
+            {
+                if (token.IsCancellationRequested) return;
+                try
+                {
+                    BeginInvoke(() =>
+                    {
+                        SwapBitmap(null);
+                        _status = "Anteprima non disponibile: " + ex.Message;
+                        _busy = false;
+                        Invalidate();
+                    });
+                }
+                catch (InvalidOperationException) { /* finestra già chiusa */ }
+            }
+        }, token);
+    }
+
+    private Size PreviewSize()
+    {
+        int width = Math.Clamp(Width - 24, 160, 1600);
+        int height = Math.Clamp(Height - 46, 120, 1200);
+        return new Size(width, height);
+    }
+
+    private void SwapBitmap(Bitmap? bitmap)
+    {
+        var previous = _bitmap;
+        _bitmap = bitmap;
+        previous?.Dispose();
+    }
+
+    // ------------------------------------------------------------------ rendering
+
+    private static (Bitmap? Bitmap, string Status) Render(TitanoProject project, TimelapseSequence sequence,
+                                                          int index, Size available, CancellationToken token)
+    {
+        var record = sequence.Frames[index];
+        var metadata = record.Metadata;
+
+        int sourceWidth = metadata.PixelWidth;
+        int sourceHeight = metadata.PixelHeight;
+        if (sourceWidth <= 0 || sourceHeight <= 0)
+            (sourceWidth, sourceHeight) = ImageDecoder.ProbeDisplaySize(metadata.FilePath, metadata.Orientation);
+        else if (ImageDecoder.SwapsAxes(metadata.Orientation))
+            (sourceWidth, sourceHeight) = (sourceHeight, sourceWidth);
+
+        if (sourceWidth <= 0 || sourceHeight <= 0) return (null, "Immagine non leggibile");
+
+        double scale = Math.Min(available.Width / (double)sourceWidth, available.Height / (double)sourceHeight);
+        scale = Math.Min(scale, 1.0);
+        int width = Math.Max(16, (int)(sourceWidth * scale) & ~1);
+        int height = Math.Max(16, (int)(sourceHeight * scale) & ~1);
+
+        var pool = new FrameBufferPool(4);
+        using var frame = ImageDecoder.Decode(metadata.FilePath, width, height, metadata.Orientation, pool);
+        token.ThrowIfCancellationRequested();
+
+        var status = new System.Text.StringBuilder();
+        status.Append($"{sourceWidth}×{sourceHeight}");
+
+        var curve = project.Curve;
+        if (project.Deflicker.Enabled && curve is not null && index < curve.Count)
+        {
+            Analysis.ExposureProcessor.Apply(frame, curve.ChannelGain[index],
+                                             project.Deflicker.ProtectHighlights, project.Deflicker.HighlightKnee);
+            status.Append($"   guadagno {curve.GainStops[index]:+0.00;-0.00;0.00} EV");
+        }
+
+        ImageBuffer result = frame;
+        ImageBuffer? blurred = null;
+
+        if (project.MotionBlur.Enabled && index + 1 < sequence.Count)
+        {
+            var nextMetadata = sequence.Frames[index + 1].Metadata;
+            using var next = ImageDecoder.Decode(nextMetadata.FilePath, width, height, nextMetadata.Orientation, pool);
+            token.ThrowIfCancellationRequested();
+
+            if (project.Deflicker.Enabled && curve is not null && index + 1 < curve.Count)
+            {
+                Analysis.ExposureProcessor.Apply(next, curve.ChannelGain[index + 1],
+                                                 project.Deflicker.ProtectHighlights, project.Deflicker.HighlightKnee);
+            }
+
+            var flow = new OpticalFlowEngine(project.Flow).Compute(frame, next);
+            token.ThrowIfCancellationRequested();
+
+            double missing = MotionBlurRenderer.MissingBlurFactor(record.ShutterAngle,
+                                                                 project.MotionBlur.TargetShutterAngle,
+                                                                 project.MotionBlur.Strength);
+            // La scia è proporzionale alla risoluzione: in anteprima va riscalata.
+            var scaledSettings = project.MotionBlur.Clone();
+            scaledSettings.MaxBlurPixels = project.MotionBlur.MaxBlurPixels * scale;
+
+            blurred = pool.Rent(width, height);
+            double length = MotionBlurRenderer.Render(frame, blurred, flow, missing, scaledSettings);
+            result = blurred;
+
+            status.Append($"   otturatore {record.ShutterAngle:0.#}° → {project.MotionBlur.TargetShutterAngle:0}°");
+            status.Append($"   scia {length:0.0} px");
+        }
+
+        var bitmap = ToBitmap(result);
+        blurred?.Dispose();
+        return (bitmap, status.ToString());
+    }
+
+    /// <summary>Conversione dal buffer in luce lineare a una bitmap GDI+ a 32 bit.</summary>
+    private static unsafe Bitmap ToBitmap(ImageBuffer buffer)
+    {
+        var bitmap = new Bitmap(buffer.Width, buffer.Height, PixelFormat.Format32bppRgb);
+        var locked = bitmap.LockBits(new Rectangle(0, 0, buffer.Width, buffer.Height),
+                                     ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb);
+        try
+        {
+            var data = buffer.Data;
+            byte* basePtr = (byte*)locked.Scan0;
+
+            for (int y = 0; y < buffer.Height; y++)
+            {
+                byte* row = basePtr + (long)y * locked.Stride;
+                int sourceIndex = y * buffer.Width * ImageBuffer.Channels;
+                for (int x = 0; x < buffer.Width; x++)
+                {
+                    int i = sourceIndex + x * ImageBuffer.Channels;
+                    byte* pixel = row + x * 4;
+                    pixel[0] = ColorSpace.ToSrgbByte(data[i + 2]);
+                    pixel[1] = ColorSpace.ToSrgbByte(data[i + 1]);
+                    pixel[2] = ColorSpace.ToSrgbByte(data[i]);
+                    pixel[3] = 255;
+                }
+            }
+        }
+        finally
+        {
+            bitmap.UnlockBits(locked);
+        }
+        return bitmap;
+    }
+
+    // ------------------------------------------------------------------ disegno
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        var g = e.Graphics;
+        Theme.HighQuality(g);
+        g.Clear(Theme.Background);
+
+        var frame = new Rectangle(0, 0, Width, Height - 22);
+
+        if (_bitmap is null)
+        {
+            TextRenderer.DrawText(g, _busy ? "Elaborazione dell'anteprima…" : _status, Theme.Body, frame,
+                                  Theme.TextFaint,
+                                  TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);
+            return;
+        }
+
+        double scale = Math.Min(frame.Width / (double)_bitmap.Width, frame.Height / (double)_bitmap.Height);
+        int width = Math.Max(1, (int)(_bitmap.Width * scale));
+        int height = Math.Max(1, (int)(_bitmap.Height * scale));
+        var target = new Rectangle(frame.Left + (frame.Width - width) / 2,
+                                   frame.Top + (frame.Height - height) / 2, width, height);
+
+        g.DrawImage(_bitmap, target);
+        using (var pen = new Pen(Theme.Border)) g.DrawRectangle(pen, target);
+
+        if (_busy)
+        {
+            using var overlay = new SolidBrush(Color.FromArgb(120, Theme.Background));
+            g.FillRectangle(overlay, target);
+            TextRenderer.DrawText(g, "Aggiornamento…", Theme.Small, target, Theme.Text,
+                                  TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);
+        }
+
+        var footer = new Rectangle(8, Height - 20, Width - 16, 18);
+        TextRenderer.DrawText(g, _caption, Theme.SmallBold, footer, Theme.Text,
+                              TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis);
+        TextRenderer.DrawText(g, _status, Theme.Small, footer, Theme.TextMuted,
+                              TextFormatFlags.Right | TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _pending?.Cancel();
+            _pending?.Dispose();
+            _bitmap?.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+}

Titano/UI/SettingsPanel.cs

@@ -0,0 +1,354 @@
+using Titano.Pipeline;
+using Titano.Video;
+
+namespace Titano.UI;
+
+/// <summary>
+/// Pannello di configurazione avanzata, suddiviso nelle tre sezioni richieste:
+/// Generale, Elaborazione immagini (deflicker, motion blur, campo vettoriale) ed
+/// Esportazione video. Ogni controllo scrive direttamente nel progetto e segnala
+/// quale parte della pipeline va ricalcolata.
+/// </summary>
+internal sealed class SettingsPanel : Panel
+{
+    private readonly TitanoProject _project;
+    private readonly TabStrip _tabs;
+    private readonly Panel[] _pages;
+
+    /// <summary>Un parametro del deflicker è cambiato: basta ricalcolare la curva.</summary>
+    public event EventHandler? DeflickerChanged;
+
+    /// <summary>È cambiato un parametro che invalida l'analisi già svolta.</summary>
+    public event EventHandler? AnalysisInvalidated;
+
+    /// <summary>È cambiato un parametro che modifica solo l'anteprima o l'esportazione.</summary>
+    public event EventHandler? PreviewInvalidated;
+
+    public event EventHandler? BrowseOutputRequested;
+
+    public TextBox OutputPathBox { get; }
+
+    public SettingsPanel(TitanoProject project)
+    {
+        _project = project;
+        BackColor = Theme.Surface;
+        Padding = new Padding(0);
+
+        _tabs = new TabStrip("Generale", "Elaborazione immagini", "Esportazione") { Dock = DockStyle.Top };
+        _tabs.SelectedChanged += (_, _) => ShowPage(_tabs.SelectedIndex);
+
+        OutputPathBox = new TextBox
+        {
+            BackColor = Theme.SurfaceAlt,
+            ForeColor = Theme.Text,
+            BorderStyle = BorderStyle.FixedSingle,
+            Font = Theme.Body,
+            Dock = DockStyle.Top,
+        };
+        OutputPathBox.TextChanged += (_, _) =>
+        {
+            _project.Export.OutputPath = OutputPathBox.Text;
+            PreviewInvalidated?.Invoke(this, EventArgs.Empty);
+        };
+
+        // L'ordine di inserimento determina l'ordine di ancoraggio: i controlli in coda alla
+        // collezione vengono disposti per primi, quindi la barra delle schede va aggiunta
+        // dopo le pagine per riservarsi la propria fascia in alto.
+        _pages = [BuildGeneralPage(), BuildImagePage(), BuildExportPage()];
+        foreach (var page in _pages)
+        {
+            page.Dock = DockStyle.Fill;
+            page.Visible = false;
+            Controls.Add(page);
+        }
+        Controls.Add(_tabs);
+
+        ShowPage(0);
+    }
+
+    /// <summary>Seleziona una delle tre sezioni; usata anche dalla modalità di cattura.</summary>
+    internal void SelectPage(int index) => _tabs.SelectedIndex = index;
+
+    private void ShowPage(int index)
+    {
+        for (int i = 0; i < _pages.Length; i++) _pages[i].Visible = i == index;
+    }
+
+    // ------------------------------------------------------------------ pagine
+
+    private Panel BuildGeneralPage()
+    {
+        var stack = NewStack();
+
+        stack.Add(new SectionHeader("Sequenza"));
+        stack.Add(Combo("Risoluzione di lavoro",
+            ["Nativa (piena risoluzione)", "3840 px (4K UHD)", "2560 px", "1920 px (Full HD)", "1280 px"],
+            WorkingWidthToIndex(_project.General.WorkingWidth),
+            index =>
+            {
+                _project.General.WorkingWidth = index switch { 1 => 3840, 2 => 2560, 3 => 1920, 4 => 1280, _ => 0 };
+                AnalysisInvalidated?.Invoke(this, EventArgs.Empty);
+            }));
+
+        stack.Add(Slider("Tolleranza sulla cadenza", 0.05, 1.0, _project.General.CadenceTolerance, 0.05, "0.00", "×",
+            value =>
+            {
+                _project.General.CadenceTolerance = value;
+                AnalysisInvalidated?.Invoke(this, EventArgs.Empty);
+            }));
+
+        stack.Add(new SectionHeader("Prestazioni"));
+        stack.Add(Slider("Larghezza della passata di analisi", 256, 2048, _project.General.AnalysisWidth, 64, "0", "px",
+            value =>
+            {
+                _project.General.AnalysisWidth = (int)value;
+                AnalysisInvalidated?.Invoke(this, EventArgs.Empty);
+            }));
+
+        stack.Add(Slider("Decodifiche simultanee", 1, 16, _project.General.DecodeParallelism, 1, "0", "thread",
+            value =>
+            {
+                _project.General.DecodeParallelism = (int)value;
+                PreviewInvalidated?.Invoke(this, EventArgs.Empty);
+            }));
+
+        stack.Add(Note("Le decodifiche simultanee determinano anche quanti fotogrammi restano " +
+                       "contemporaneamente in memoria: l'occupazione non dipende dalla lunghezza della sequenza."));
+        return stack.Panel;
+    }
+
+    private Panel BuildImagePage()
+    {
+        var stack = NewStack();
+
+        // ---- Deflicker
+        stack.Add(new SectionHeader("Deflicker"));
+
+        var deflickerEnabled = Check("Correzione dell'esposizione attiva", _project.Deflicker.Enabled, value =>
+        {
+            _project.Deflicker.Enabled = value;
+            DeflickerChanged?.Invoke(this, EventArgs.Empty);
+        });
+        stack.Add(deflickerEnabled);
+
+        stack.Add(Slider("Finestra temporale", 3, 121, _project.Deflicker.WindowFrames, 2, "0", "fotogrammi",
+            value => { _project.Deflicker.WindowFrames = (int)value; DeflickerChanged?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Intensità della correzione", 0, 1, _project.Deflicker.Strength, 0.05, "0.00", string.Empty,
+            value => { _project.Deflicker.Strength = value; DeflickerChanged?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Correzione massima", 0.1, 3.0, _project.Deflicker.MaxCorrectionStops, 0.1, "0.0", "EV",
+            value => { _project.Deflicker.MaxCorrectionStops = value; DeflickerChanged?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Check("Scarta i fotogrammi anomali", _project.Deflicker.RejectOutliers, value =>
+        {
+            _project.Deflicker.RejectOutliers = value;
+            DeflickerChanged?.Invoke(this, EventArgs.Empty);
+        }));
+
+        stack.Add(Check("Stabilizza il bilanciamento colore", _project.Deflicker.StabilizeColor, value =>
+        {
+            _project.Deflicker.StabilizeColor = value;
+            DeflickerChanged?.Invoke(this, EventArgs.Empty);
+        }));
+
+        stack.Add(Check("Proteggi le alte luci", _project.Deflicker.ProtectHighlights, value =>
+        {
+            _project.Deflicker.ProtectHighlights = value;
+            PreviewInvalidated?.Invoke(this, EventArgs.Empty);
+        }));
+
+        stack.Add(Slider("Innesco della compressione", 0.4, 0.98, _project.Deflicker.HighlightKnee, 0.02, "0.00", string.Empty,
+            value => { _project.Deflicker.HighlightKnee = value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        // ---- Motion blur
+        stack.Add(new SectionHeader("Motion blur sintetico"));
+
+        stack.Add(Check("Sfocatura di movimento attiva", _project.MotionBlur.Enabled, value =>
+        {
+            _project.MotionBlur.Enabled = value;
+            PreviewInvalidated?.Invoke(this, EventArgs.Empty);
+        }));
+
+        stack.Add(Slider("Shutter angle obiettivo", 0, 360, _project.MotionBlur.TargetShutterAngle, 5, "0", "°",
+            value => { _project.MotionBlur.TargetShutterAngle = value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Intensità", 0, 1, _project.MotionBlur.Strength, 0.05, "0.00", string.Empty,
+            value => { _project.MotionBlur.Strength = value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Lunghezza massima della scia", 4, 160, _project.MotionBlur.MaxBlurPixels, 2, "0", "px",
+            value => { _project.MotionBlur.MaxBlurPixels = value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Campioni per pixel", 3, 65, _project.MotionBlur.MaxSamples, 2, "0", string.Empty,
+            value => { _project.MotionBlur.MaxSamples = (int)value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Note("La scia sintetizzata compensa in quadratura la sfocatura mancante: " +
+                       "√(obiettivo² − reale²). A 180° si ottiene la resa cinematografica."));
+
+        // ---- Optical flow
+        stack.Add(new SectionHeader("Campo vettoriale di movimento"));
+
+        stack.Add(Slider("Larghezza di analisi del movimento", 320, 1920, _project.Flow.AnalysisWidth, 32, "0", "px",
+            value => { _project.Flow.AnalysisWidth = (int)value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Passo della griglia", 4, 32, _project.Flow.CellSize, 1, "0", "px",
+            value => { _project.Flow.CellSize = (int)value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Livelli della piramide", 1, 6, _project.Flow.PyramidLevels, 1, "0", string.Empty,
+            value => { _project.Flow.PyramidLevels = (int)value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Raggio della finestra", 2, 12, _project.Flow.WindowRadius, 1, "0", "px",
+            value => { _project.Flow.WindowRadius = (int)value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Iterazioni per livello", 1, 12, _project.Flow.Iterations, 1, "0", string.Empty,
+            value => { _project.Flow.Iterations = (int)value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        return stack.Panel;
+    }
+
+    private Panel BuildExportPage()
+    {
+        var stack = NewStack();
+
+        stack.Add(new SectionHeader("Formato"));
+        stack.Add(Combo("Codec", ["H.264 / AVC", "H.265 / HEVC"], _project.Export.Codec == VideoCodec.H264 ? 0 : 1,
+            index =>
+            {
+                _project.Export.Codec = index == 0 ? VideoCodec.H264 : VideoCodec.Hevc;
+                PreviewInvalidated?.Invoke(this, EventArgs.Empty);
+            }));
+
+        stack.Add(Combo("Profilo H.264", ["Baseline", "Main", "High"],
+            _project.Export.Profile switch { H264Profile.Baseline => 0, H264Profile.Main => 1, _ => 2 },
+            index => _project.Export.Profile = index switch
+            {
+                0 => H264Profile.Baseline,
+                1 => H264Profile.Main,
+                _ => H264Profile.High,
+            }));
+
+        stack.Add(Slider("Frame rate", 6, 120, _project.Export.FrameRate, 1, "0", "fps",
+            value => { _project.Export.FrameRate = value; PreviewInvalidated?.Invoke(this, EventArgs.Empty); }));
+
+        stack.Add(Slider("Bitrate medio", 5, 250, _project.Export.BitrateMbps, 5, "0", "Mb/s",
+            value => _project.Export.BitrateMbps = value));
+
+        stack.Add(Slider("Intervallo fra fotogrammi chiave", 1, 10, _project.Export.KeyframeIntervalSeconds, 1, "0", "s",
+            value => _project.Export.KeyframeIntervalSeconds = (int)value));
+
+        stack.Add(new SectionHeader("Andamento temporale"));
+        stack.Add(Combo("Durata dei fotogrammi",
+            ["Costante — un fotogramma per scatto",
+             "Adattiva — durata proporzionale all'intervallo",
+             "Interpolata — cadenza uniformata con fotogrammi sintetici"],
+            (int)_project.Export.Timing,
+            index =>
+            {
+                _project.Export.Timing = (FrameTimingMode)index;
+                PreviewInvalidated?.Invoke(this, EventArgs.Empty);
+            }));
+
+        stack.Add(Slider("Dilatazione massima", 1.5, 8, _project.Export.MaxAdaptiveStretch, 0.5, "0.0", "×",
+            value => _project.Export.MaxAdaptiveStretch = value));
+
+        stack.Add(new SectionHeader("Codifica"));
+        stack.Add(Check("Preferisci l'encoder hardware", _project.Export.PreferHardware,
+            value => _project.Export.PreferHardware = value));
+
+        stack.Add(new SectionHeader("Destinazione"));
+        stack.Add(OutputPathBox);
+
+        var browse = new DarkButton { Text = "Scegli il file di destinazione…", Height = 32, Dock = DockStyle.Top };
+        browse.Click += (_, _) => BrowseOutputRequested?.Invoke(this, EventArgs.Empty);
+        stack.Add(browse);
+
+        stack.Add(Note("Il video viene scritto in un unico flusso continuo: l'elaborazione non " +
+                       "genera alcun file temporaneo su disco."));
+
+        return stack.Panel;
+    }
+
+    // ------------------------------------------------------------------ costruttori di controlli
+
+    private sealed class Stack(Panel panel)
+    {
+        public Panel Panel { get; } = panel;
+        private int _y;
+
+        public void Add(Control control)
+        {
+            control.Dock = DockStyle.None;
+            control.Left = 14;
+            control.Top = _y;
+            control.Width = Panel.ClientSize.Width - 34;
+            control.Anchor = AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Right;
+            Panel.Controls.Add(control);
+            _y += control.Height + 6;
+        }
+    }
+
+    private static Stack NewStack()
+    {
+        var panel = new Panel
+        {
+            BackColor = Theme.Surface,
+            Padding = new Padding(0, 8, 0, 12),
+            Width = 360,
+        };
+        var host = new Panel { BackColor = Theme.Surface, Dock = DockStyle.Fill, AutoScroll = true, Width = 360 };
+        panel.Controls.Add(host);
+        return new Stack(host);
+    }
+
+    private static ParameterSlider Slider(string caption, double min, double max, double value, double step,
+                                          string format, string unit, Action<double> onChange)
+    {
+        var slider = new ParameterSlider
+        {
+            Caption = caption,
+            Minimum = min,
+            Maximum = max,
+            Step = step,
+            ValueFormat = format,
+            Unit = unit,
+        };
+        slider.SetValueSilently(value);
+        slider.ValueChanged += (_, _) => onChange(slider.Value);
+        return slider;
+    }
+
+    private static DarkCheckBox Check(string caption, bool value, Action<bool> onChange)
+    {
+        var box = new DarkCheckBox { Text = caption, Checked = value };
+        box.CheckedChanged += (_, _) => onChange(box.Checked);
+        return box;
+    }
+
+    private static LabeledCombo Combo(string caption, string[] items, int selected, Action<int> onChange)
+    {
+        var row = new LabeledCombo(caption);
+        row.Combo.Items.AddRange(items);
+        row.Combo.SelectedIndex = Math.Clamp(selected, 0, items.Length - 1);
+        row.Combo.SelectedIndexChanged += (_, _) => onChange(row.Combo.SelectedIndex);
+        return row;
+    }
+
+    private static Label Note(string text) => new()
+    {
+        Text = text,
+        Font = Theme.Small,
+        ForeColor = Theme.TextFaint,
+        AutoSize = false,
+        Height = 52,
+        BackColor = Theme.Surface,
+    };
+
+    private static int WorkingWidthToIndex(int width) => width switch
+    {
+        3840 => 1,
+        2560 => 2,
+        1920 => 3,
+        1280 => 4,
+        _ => 0,
+    };
+}

Titano/UI/Theme.cs

@@ -0,0 +1,110 @@
+using System.Drawing.Drawing2D;
+using System.Runtime.InteropServices;
+
+namespace Titano.UI;
+
+/// <summary>
+/// Tavolozza e primitive di disegno del tema scuro. Tutti i controlli dell'applicazione
+/// sono resi con GDI+ a partire da questi valori: nessun tema di terze parti.
+/// </summary>
+internal static class Theme
+{
+    public static readonly Color Background = Color.FromArgb(0x14, 0x16, 0x1A);
+    public static readonly Color Surface = Color.FromArgb(0x1B, 0x1E, 0x24);
+    public static readonly Color SurfaceAlt = Color.FromArgb(0x22, 0x26, 0x2E);
+    public static readonly Color SurfaceHover = Color.FromArgb(0x2A, 0x2F, 0x39);
+    public static readonly Color Border = Color.FromArgb(0x2E, 0x33, 0x3D);
+    public static readonly Color BorderStrong = Color.FromArgb(0x3C, 0x43, 0x50);
+
+    public static readonly Color Text = Color.FromArgb(0xE6, 0xE9, 0xEF);
+    public static readonly Color TextMuted = Color.FromArgb(0x98, 0xA0, 0xAE);
+    public static readonly Color TextFaint = Color.FromArgb(0x6B, 0x73, 0x82);
+
+    public static readonly Color Accent = Color.FromArgb(0x4C, 0x9A, 0xFF);
+    public static readonly Color AccentDim = Color.FromArgb(0x2F, 0x6C, 0xC2);
+    public static readonly Color Measured = Color.FromArgb(0xF5, 0xA5, 0x24);
+    public static readonly Color Success = Color.FromArgb(0x35, 0xC4, 0x8F);
+    public static readonly Color Warning = Color.FromArgb(0xE8, 0xB3, 0x39);
+    public static readonly Color Danger = Color.FromArgb(0xF0, 0x57, 0x5A);
+
+    public static readonly Font Body = new("Segoe UI", 9f, FontStyle.Regular, GraphicsUnit.Point);
+    public static readonly Font BodyBold = new("Segoe UI", 9f, FontStyle.Bold, GraphicsUnit.Point);
+    public static readonly Font Small = new("Segoe UI", 8f, FontStyle.Regular, GraphicsUnit.Point);
+    public static readonly Font SmallBold = new("Segoe UI", 8f, FontStyle.Bold, GraphicsUnit.Point);
+    public static readonly Font Title = new("Segoe UI Semibold", 14f, FontStyle.Regular, GraphicsUnit.Point);
+
+    private const int DwmUseImmersiveDarkMode = 20;
+
+    [DllImport("dwmapi.dll")]
+    private static extern int DwmSetWindowAttribute(IntPtr window, int attribute, ref int value, int size);
+
+    /// <summary>Estende il tema scuro alla barra del titolo, disegnata dal sistema.</summary>
+    public static void ApplyDarkTitleBar(Form form)
+    {
+        if (!form.IsHandleCreated) return;
+        int enabled = 1;
+        DwmSetWindowAttribute(form.Handle, DwmUseImmersiveDarkMode, ref enabled, sizeof(int));
+    }
+
+    /// <summary>Rettangolo con angoli arrotondati, primitiva di base dell'interfaccia.</summary>
+    public static GraphicsPath RoundedRect(RectangleF bounds, float radius)
+    {
+        var path = new GraphicsPath();
+        if (radius <= 0.5f)
+        {
+            path.AddRectangle(bounds);
+            return path;
+        }
+
+        float diameter = Math.Min(radius * 2, Math.Min(bounds.Width, bounds.Height));
+        var arc = new RectangleF(bounds.X, bounds.Y, diameter, diameter);
+
+        path.AddArc(arc, 180, 90);
+        arc.X = bounds.Right - diameter;
+        path.AddArc(arc, 270, 90);
+        arc.Y = bounds.Bottom - diameter;
+        path.AddArc(arc, 0, 90);
+        arc.X = bounds.X;
+        path.AddArc(arc, 90, 90);
+        path.CloseFigure();
+        return path;
+    }
+
+    public static void FillRounded(Graphics g, RectangleF bounds, float radius, Color fill)
+    {
+        using var path = RoundedRect(bounds, radius);
+        using var brush = new SolidBrush(fill);
+        g.FillPath(brush, path);
+    }
+
+    public static void DrawRounded(Graphics g, RectangleF bounds, float radius, Color stroke, float width = 1f)
+    {
+        using var path = RoundedRect(bounds, radius);
+        using var pen = new Pen(stroke, width);
+        g.DrawPath(pen, path);
+    }
+
+    public static void FillAndStroke(Graphics g, RectangleF bounds, float radius, Color fill, Color stroke)
+    {
+        FillRounded(g, bounds, radius, fill);
+        DrawRounded(g, RectangleF.Inflate(bounds, -0.5f, -0.5f), radius, stroke);
+    }
+
+    public static void HighQuality(Graphics g)
+    {
+        g.SmoothingMode = SmoothingMode.AntiAlias;
+        g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
+        g.InterpolationMode = InterpolationMode.HighQualityBilinear;
+        g.PixelOffsetMode = PixelOffsetMode.HighQuality;
+    }
+
+    public static Color Mix(Color a, Color b, double t)
+    {
+        t = Math.Clamp(t, 0, 1);
+        return Color.FromArgb(
+            (int)(a.A + (b.A - a.A) * t),
+            (int)(a.R + (b.R - a.R) * t),
+            (int)(a.G + (b.G - a.G) * t),
+            (int)(a.B + (b.B - a.B) * t));
+    }
+}

Titano/Video/AnnexBParser.cs

@@ -0,0 +1,61 @@
+namespace Titano.Video;
+
+/// <summary>
+/// Scansione di un bitstream Annex-B (quello prodotto dagli encoder di sistema): individua
+/// le NAL unit delimitate dai codici di avvio 00 00 01 / 00 00 00 01, senza copie di memoria.
+/// </summary>
+internal static class AnnexBParser
+{
+    internal readonly record struct NalRange(int Start, int Length);
+
+    public static NalEnumerator EnumerateNals(ReadOnlySpan<byte> data) => new(data);
+
+    internal ref struct NalEnumerator(ReadOnlySpan<byte> data)
+    {
+        private readonly ReadOnlySpan<byte> _data = data;
+        private int _position = 0;
+        private NalRange _current = default;
+
+        public readonly NalEnumerator GetEnumerator() => this;
+
+        public readonly NalRange Current => _current;
+
+        public bool MoveNext()
+        {
+            int start = FindStartCode(_data, _position, out int codeLength);
+            if (start < 0) return false;
+
+            int payloadStart = start + codeLength;
+            int next = FindStartCode(_data, payloadStart, out _);
+            int end = next < 0 ? _data.Length : next;
+
+            // Gli zeri finali non fanno parte della NAL (trailing_zero_8bits).
+            while (end > payloadStart && _data[end - 1] == 0) end--;
+
+            _position = next < 0 ? _data.Length : next;
+            _current = new NalRange(payloadStart, end - payloadStart);
+            return _current.Length > 0 || next >= 0;
+        }
+
+        private static int FindStartCode(ReadOnlySpan<byte> data, int from, out int codeLength)
+        {
+            for (int i = Math.Max(0, from); i + 2 < data.Length; i++)
+            {
+                if (data[i] != 0 || data[i + 1] != 0) continue;
+
+                if (data[i + 2] == 1)
+                {
+                    codeLength = 3;
+                    return i;
+                }
+                if (data[i + 2] == 0 && i + 3 < data.Length && data[i + 3] == 1)
+                {
+                    codeLength = 4;
+                    return i;
+                }
+            }
+            codeLength = 0;
+            return -1;
+        }
+    }
+}

Titano/Video/BoxWriter.cs

@@ -0,0 +1,119 @@
+using System.Buffers.Binary;
+using System.Text;
+
+namespace Titano.Video;
+
+/// <summary>
+/// Scrittore di box ISO-BMFF. Ogni box riserva quattro byte per la propria dimensione e li
+/// corregge alla chiusura: i box possono così essere annidati scrivendo direttamente sul
+/// flusso di uscita, senza costruire alberi in memoria.
+/// </summary>
+internal sealed class BoxWriter : IDisposable
+{
+    private readonly Stream _stream;
+    private readonly long _start;
+    private bool _closed;
+
+    public BoxWriter(Stream stream, string type)
+    {
+        _stream = stream;
+        _start = stream.Position;
+
+        Span<byte> header = stackalloc byte[8];
+        BinaryPrimitives.WriteUInt32BigEndian(header, 0);       // segnaposto
+        Encoding.ASCII.GetBytes(type, header[4..]);
+        _stream.Write(header);
+    }
+
+    public BoxWriter Child(string type) => new(_stream, type);
+
+    public void WriteFullBoxHeader(byte version, uint flags)
+    {
+        Span<byte> buffer = stackalloc byte[4];
+        buffer[0] = version;
+        buffer[1] = (byte)((flags >> 16) & 0xFF);
+        buffer[2] = (byte)((flags >> 8) & 0xFF);
+        buffer[3] = (byte)(flags & 0xFF);
+        _stream.Write(buffer);
+    }
+
+    public void WriteByte(byte value) => _stream.WriteByte(value);
+
+    public void WriteBytes(ReadOnlySpan<byte> value) => _stream.Write(value);
+
+    public void WriteUInt16(ushort value)
+    {
+        Span<byte> buffer = stackalloc byte[2];
+        BinaryPrimitives.WriteUInt16BigEndian(buffer, value);
+        _stream.Write(buffer);
+    }
+
+    public void WriteUInt32(uint value)
+    {
+        Span<byte> buffer = stackalloc byte[4];
+        BinaryPrimitives.WriteUInt32BigEndian(buffer, value);
+        _stream.Write(buffer);
+    }
+
+    public void WriteUInt64(ulong value)
+    {
+        Span<byte> buffer = stackalloc byte[8];
+        BinaryPrimitives.WriteUInt64BigEndian(buffer, value);
+        _stream.Write(buffer);
+    }
+
+    public void WriteFourCc(string value)
+    {
+        Span<byte> buffer = stackalloc byte[4];
+        buffer.Fill((byte)' ');
+        Encoding.ASCII.GetBytes(value.AsSpan(0, Math.Min(4, value.Length)), buffer);
+        _stream.Write(buffer);
+    }
+
+    /// <summary>Stringa terminata da NUL, come richiesto dal box hdlr.</summary>
+    public void WriteCString(string value)
+    {
+        _stream.Write(Encoding.UTF8.GetBytes(value));
+        _stream.WriteByte(0);
+    }
+
+    /// <summary>Stringa Pascal in campo fisso da 32 byte (compressorname del sample entry).</summary>
+    public void WritePascalString32(string value)
+    {
+        Span<byte> buffer = stackalloc byte[32];
+        buffer.Clear();
+        int length = Math.Min(31, Encoding.ASCII.GetByteCount(value));
+        buffer[0] = (byte)length;
+        Encoding.ASCII.GetBytes(value.AsSpan(0, length), buffer[1..]);
+        _stream.Write(buffer);
+    }
+
+    /// <summary>Matrice di trasformazione identità in virgola fissa 16.16 / 2.30.</summary>
+    public void WriteMatrix()
+    {
+        WriteUInt32(0x00010000);
+        WriteUInt32(0);
+        WriteUInt32(0);
+        WriteUInt32(0);
+        WriteUInt32(0x00010000);
+        WriteUInt32(0);
+        WriteUInt32(0);
+        WriteUInt32(0);
+        WriteUInt32(0x40000000);
+    }
+
+    public void Dispose()
+    {
+        if (_closed) return;
+        _closed = true;
+
+        long end = _stream.Position;
+        long size = end - _start;
+
+        _stream.Position = _start;
+        Span<byte> buffer = stackalloc byte[4];
+        BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)size);
+        _stream.Write(buffer);
+        _stream.Position = end;
+    }
+}

Titano/Video/ExportSettings.cs

@@ -0,0 +1,55 @@
+namespace Titano.Video;
+
+/// <summary>Come viene tradotta in durate di fotogramma la cadenza reale della sequenza.</summary>
+public enum FrameTimingMode
+{
+    /// <summary>Ogni scatto dura esattamente un fotogramma: il time-lapse classico.</summary>
+    Constant,
+
+    /// <summary>La durata segue l'intervallo reale: le pause dell'intervallometro restano visibili.</summary>
+    Adaptive,
+
+    /// <summary>La sequenza viene riportata su una griglia temporale uniforme sintetizzando i fotogrammi mancanti.</summary>
+    Interpolated,
+}
+
+public enum H264Profile
+{
+    Baseline = 66,
+    Main = 77,
+    High = 100,
+}
+
+/// <summary>Parametri del pannello "Esportazione video".</summary>
+public sealed class ExportSettings
+{
+    public string OutputPath { get; set; } = string.Empty;
+
+    public VideoCodec Codec { get; set; } = VideoCodec.H264;
+    public H264Profile Profile { get; set; } = H264Profile.High;
+
+    /// <summary>Larghezza del video; 0 = dedotta dal primo fotogramma.</summary>
+    public int Width { get; set; }
+    public int Height { get; set; }
+
+    public double FrameRate { get; set; } = 30.0;
+
+    /// <summary>Bitrate medio in megabit al secondo.</summary>
+    public double BitrateMbps { get; set; } = 60.0;
+
+    public FrameTimingMode Timing { get; set; } = FrameTimingMode.Constant;
+
+    /// <summary>Fattore di dilatazione applicato in modalità adattiva, limitato per non congelare la scena.</summary>
+    public double MaxAdaptiveStretch { get; set; } = 4.0;
+
+    public bool PreferHardware { get; set; } = true;
+
+    public int KeyframeIntervalSeconds { get; set; } = 2;
+
+    /// <summary>Unità temporali della traccia video: 90 kHz consente durate variabili precise.</summary>
+    public uint Timescale { get; set; } = 90000;
+
+    public uint AverageBitrate => (uint)Math.Clamp(BitrateMbps * 1_000_000.0, 1_000_000.0, 800_000_000.0);
+
+    public ExportSettings Clone() => (ExportSettings)MemberwiseClone();
+}

Titano/Video/MediaFoundationInterop.cs

@@ -0,0 +1,433 @@
+using System.Runtime.InteropServices;
+
+namespace Titano.Video;
+
+// ---------------------------------------------------------------------------------------
+// Binding manuale verso Media Foundation (mfplat.dll / mfreadwrite.dll), lo stack di
+// codifica nativo di Windows che espone gli encoder hardware di Intel, AMD e NVIDIA.
+// Le interfacce sono dichiarate con l'ordine di vtable esatto; le voci non utilizzate
+// sono comunque presenti per non alterare gli offset.
+// ---------------------------------------------------------------------------------------
+
+[ComImport, Guid("2cd2d921-c447-44a7-a13c-4adabfc247e3"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFAttributes
+{
+    void GetItem(ref Guid key, IntPtr value);
+    void GetItemType(ref Guid key, out int type);
+    void CompareItem(ref Guid key, IntPtr value, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    void Compare(IMFAttributes attributes, int matchType, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    [PreserveSig] int GetUINT32(ref Guid key, out uint value);
+    [PreserveSig] int GetUINT64(ref Guid key, out ulong value);
+    [PreserveSig] int GetDouble(ref Guid key, out double value);
+    [PreserveSig] int GetGUID(ref Guid key, out Guid value);
+    [PreserveSig] int GetStringLength(ref Guid key, out uint length);
+    [PreserveSig] int GetString(ref Guid key, [Out, MarshalAs(UnmanagedType.LPWStr)] System.Text.StringBuilder value, uint size, ref uint length);
+    void GetAllocatedString(ref Guid key, out IntPtr value, out uint length);
+    [PreserveSig] int GetBlobSize(ref Guid key, out uint size);
+    [PreserveSig] int GetBlob(ref Guid key, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint bufferSize, ref uint blobSize);
+    void GetAllocatedBlob(ref Guid key, out IntPtr buffer, out uint size);
+    void GetUnknown(ref Guid key, ref Guid riid, out IntPtr value);
+    void SetItem(ref Guid key, IntPtr value);
+    void DeleteItem(ref Guid key);
+    void DeleteAllItems();
+    void SetUINT32(ref Guid key, uint value);
+    void SetUINT64(ref Guid key, ulong value);
+    void SetDouble(ref Guid key, double value);
+    void SetGUID(ref Guid key, ref Guid value);
+    void SetString(ref Guid key, [MarshalAs(UnmanagedType.LPWStr)] string value);
+    void SetBlob(ref Guid key, [MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint size);
+    void SetUnknown(ref Guid key, IntPtr unknown);
+    void LockStore();
+    void UnlockStore();
+    void GetCount(out uint count);
+    void GetItemByIndex(uint index, out Guid key, IntPtr value);
+    void CopyAllItems(IMFAttributes destination);
+}
+
+[ComImport, Guid("44ae0fa8-ea31-4109-8d2e-4cae4997c555"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFMediaType
+{
+    // --- IMFAttributes
+    void GetItem(ref Guid key, IntPtr value);
+    void GetItemType(ref Guid key, out int type);
+    void CompareItem(ref Guid key, IntPtr value, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    void Compare(IMFAttributes attributes, int matchType, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    [PreserveSig] int GetUINT32(ref Guid key, out uint value);
+    [PreserveSig] int GetUINT64(ref Guid key, out ulong value);
+    [PreserveSig] int GetDouble(ref Guid key, out double value);
+    [PreserveSig] int GetGUID(ref Guid key, out Guid value);
+    [PreserveSig] int GetStringLength(ref Guid key, out uint length);
+    [PreserveSig] int GetString(ref Guid key, [Out, MarshalAs(UnmanagedType.LPWStr)] System.Text.StringBuilder value, uint size, ref uint length);
+    void GetAllocatedString(ref Guid key, out IntPtr value, out uint length);
+    [PreserveSig] int GetBlobSize(ref Guid key, out uint size);
+    [PreserveSig] int GetBlob(ref Guid key, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint bufferSize, ref uint blobSize);
+    void GetAllocatedBlob(ref Guid key, out IntPtr buffer, out uint size);
+    void GetUnknown(ref Guid key, ref Guid riid, out IntPtr value);
+    void SetItem(ref Guid key, IntPtr value);
+    void DeleteItem(ref Guid key);
+    void DeleteAllItems();
+    void SetUINT32(ref Guid key, uint value);
+    void SetUINT64(ref Guid key, ulong value);
+    void SetDouble(ref Guid key, double value);
+    void SetGUID(ref Guid key, ref Guid value);
+    void SetString(ref Guid key, [MarshalAs(UnmanagedType.LPWStr)] string value);
+    void SetBlob(ref Guid key, [MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint size);
+    void SetUnknown(ref Guid key, IntPtr unknown);
+    void LockStore();
+    void UnlockStore();
+    void GetCount(out uint count);
+    void GetItemByIndex(uint index, out Guid key, IntPtr value);
+    void CopyAllItems(IMFAttributes destination);
+    // --- IMFMediaType
+    void GetMajorType(out Guid majorType);
+    void IsCompressedFormat([MarshalAs(UnmanagedType.Bool)] out bool compressed);
+    [PreserveSig] int IsEqual(IMFMediaType type, out uint flags);
+    void GetRepresentation(Guid representation, out IntPtr data);
+    void FreeRepresentation(Guid representation, IntPtr data);
+}
+
+[ComImport, Guid("045fa593-8799-42b8-bc8d-8968c6453507"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFMediaBuffer
+{
+    void Lock(out IntPtr buffer, out uint maxLength, out uint currentLength);
+    void Unlock();
+    void GetCurrentLength(out uint length);
+    void SetCurrentLength(uint length);
+    void GetMaxLength(out uint length);
+}
+
+[ComImport, Guid("c40a00f2-b93a-4d80-ae8c-5a1c634f58e4"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFSample
+{
+    // --- IMFAttributes
+    void GetItem(ref Guid key, IntPtr value);
+    void GetItemType(ref Guid key, out int type);
+    void CompareItem(ref Guid key, IntPtr value, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    void Compare(IMFAttributes attributes, int matchType, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    [PreserveSig] int GetUINT32(ref Guid key, out uint value);
+    [PreserveSig] int GetUINT64(ref Guid key, out ulong value);
+    [PreserveSig] int GetDouble(ref Guid key, out double value);
+    [PreserveSig] int GetGUID(ref Guid key, out Guid value);
+    [PreserveSig] int GetStringLength(ref Guid key, out uint length);
+    [PreserveSig] int GetString(ref Guid key, [Out, MarshalAs(UnmanagedType.LPWStr)] System.Text.StringBuilder value, uint size, ref uint length);
+    void GetAllocatedString(ref Guid key, out IntPtr value, out uint length);
+    [PreserveSig] int GetBlobSize(ref Guid key, out uint size);
+    [PreserveSig] int GetBlob(ref Guid key, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint bufferSize, ref uint blobSize);
+    void GetAllocatedBlob(ref Guid key, out IntPtr buffer, out uint size);
+    void GetUnknown(ref Guid key, ref Guid riid, out IntPtr value);
+    void SetItem(ref Guid key, IntPtr value);
+    void DeleteItem(ref Guid key);
+    void DeleteAllItems();
+    void SetUINT32(ref Guid key, uint value);
+    void SetUINT64(ref Guid key, ulong value);
+    void SetDouble(ref Guid key, double value);
+    void SetGUID(ref Guid key, ref Guid value);
+    void SetString(ref Guid key, [MarshalAs(UnmanagedType.LPWStr)] string value);
+    void SetBlob(ref Guid key, [MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint size);
+    void SetUnknown(ref Guid key, IntPtr unknown);
+    void LockStore();
+    void UnlockStore();
+    void GetCount(out uint count);
+    void GetItemByIndex(uint index, out Guid key, IntPtr value);
+    void CopyAllItems(IMFAttributes destination);
+    // --- IMFSample
+    void GetSampleFlags(out uint flags);
+    void SetSampleFlags(uint flags);
+    [PreserveSig] int GetSampleTime(out long time);
+    void SetSampleTime(long time);
+    [PreserveSig] int GetSampleDuration(out long duration);
+    void SetSampleDuration(long duration);
+    void GetBufferCount(out uint count);
+    void GetBufferByIndex(uint index, out IMFMediaBuffer buffer);
+    void ConvertToContiguousBuffer(out IMFMediaBuffer buffer);
+    void AddBuffer(IMFMediaBuffer buffer);
+    void RemoveBufferByIndex(uint index);
+    void RemoveAllBuffers();
+    void GetTotalLength(out uint length);
+    void CopyToBuffer(IMFMediaBuffer buffer);
+}
+
+[ComImport, Guid("bf94c121-5b05-4e6f-8000-ba598961414d"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFTransform
+{
+    void GetStreamLimits(out uint inputMin, out uint inputMax, out uint outputMin, out uint outputMax);
+    void GetStreamCount(out uint inputs, out uint outputs);
+    [PreserveSig] int GetStreamIDs(uint inputSize, [Out, MarshalAs(UnmanagedType.LPArray)] uint[] inputIds,
+                                   uint outputSize, [Out, MarshalAs(UnmanagedType.LPArray)] uint[] outputIds);
+    void GetInputStreamInfo(uint streamId, out MftInputStreamInfo info);
+    void GetOutputStreamInfo(uint streamId, out MftOutputStreamInfo info);
+    [PreserveSig] int GetAttributes(out IMFAttributes attributes);
+    [PreserveSig] int GetInputStreamAttributes(uint streamId, out IMFAttributes attributes);
+    [PreserveSig] int GetOutputStreamAttributes(uint streamId, out IMFAttributes attributes);
+    [PreserveSig] int DeleteInputStream(uint streamId);
+    [PreserveSig] int AddInputStreams(uint count, [MarshalAs(UnmanagedType.LPArray)] uint[] ids);
+    [PreserveSig] int GetInputAvailableType(uint streamId, uint index, out IMFMediaType type);
+    [PreserveSig] int GetOutputAvailableType(uint streamId, uint index, out IMFMediaType type);
+    [PreserveSig] int SetInputType(uint streamId, IMFMediaType? type, uint flags);
+    [PreserveSig] int SetOutputType(uint streamId, IMFMediaType? type, uint flags);
+    [PreserveSig] int GetInputCurrentType(uint streamId, out IMFMediaType type);
+    [PreserveSig] int GetOutputCurrentType(uint streamId, out IMFMediaType type);
+    [PreserveSig] int GetInputStatus(uint streamId, out uint flags);
+    [PreserveSig] int GetOutputStatus(out uint flags);
+    [PreserveSig] int SetOutputBounds(long lower, long upper);
+    [PreserveSig] int ProcessEvent(uint streamId, IntPtr mediaEvent);
+    [PreserveSig] int ProcessMessage(int message, IntPtr param);
+    [PreserveSig] int ProcessInput(uint streamId, IMFSample sample, uint flags);
+    [PreserveSig] int ProcessOutput(uint flags, uint count, ref MftOutputDataBuffer buffers, out uint status);
+}
+
+[ComImport, Guid("7fee9e9a-4a89-47a6-899c-b6a53a70fb67"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFActivate
+{
+    // --- IMFAttributes
+    void GetItem(ref Guid key, IntPtr value);
+    void GetItemType(ref Guid key, out int type);
+    void CompareItem(ref Guid key, IntPtr value, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    void Compare(IMFAttributes attributes, int matchType, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    [PreserveSig] int GetUINT32(ref Guid key, out uint value);
+    [PreserveSig] int GetUINT64(ref Guid key, out ulong value);
+    [PreserveSig] int GetDouble(ref Guid key, out double value);
+    [PreserveSig] int GetGUID(ref Guid key, out Guid value);
+    [PreserveSig] int GetStringLength(ref Guid key, out uint length);
+    [PreserveSig] int GetString(ref Guid key, [Out, MarshalAs(UnmanagedType.LPWStr)] System.Text.StringBuilder value, uint size, ref uint length);
+    void GetAllocatedString(ref Guid key, out IntPtr value, out uint length);
+    [PreserveSig] int GetBlobSize(ref Guid key, out uint size);
+    [PreserveSig] int GetBlob(ref Guid key, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint bufferSize, ref uint blobSize);
+    void GetAllocatedBlob(ref Guid key, out IntPtr buffer, out uint size);
+    void GetUnknown(ref Guid key, ref Guid riid, out IntPtr value);
+    void SetItem(ref Guid key, IntPtr value);
+    void DeleteItem(ref Guid key);
+    void DeleteAllItems();
+    void SetUINT32(ref Guid key, uint value);
+    void SetUINT64(ref Guid key, ulong value);
+    void SetDouble(ref Guid key, double value);
+    void SetGUID(ref Guid key, ref Guid value);
+    void SetString(ref Guid key, [MarshalAs(UnmanagedType.LPWStr)] string value);
+    void SetBlob(ref Guid key, [MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint size);
+    void SetUnknown(ref Guid key, IntPtr unknown);
+    void LockStore();
+    void UnlockStore();
+    void GetCount(out uint count);
+    void GetItemByIndex(uint index, out Guid key, IntPtr value);
+    void CopyAllItems(IMFAttributes destination);
+    // --- IMFActivate
+    [PreserveSig] int ActivateObject(ref Guid riid, out IntPtr instance);
+    [PreserveSig] int ShutdownObject();
+    [PreserveSig] int DetachObject();
+}
+
+[ComImport, Guid("2cd0bd52-bcd5-4b89-b62c-eadc0c031e7d"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFMediaEventGenerator
+{
+    [PreserveSig] int GetEvent(uint flags, out IMFMediaEvent mediaEvent);
+    [PreserveSig] int BeginGetEvent(IntPtr callback, IntPtr state);
+    [PreserveSig] int EndGetEvent(IntPtr result, out IMFMediaEvent mediaEvent);
+    [PreserveSig] int QueueEvent(uint met, ref Guid extendedType, int status, IntPtr value);
+}
+
+[ComImport, Guid("df598932-f10c-4e39-bba2-c308f101daa3"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface IMFMediaEvent
+{
+    // --- IMFAttributes (le prime 30 voci)
+    void GetItem(ref Guid key, IntPtr value);
+    void GetItemType(ref Guid key, out int type);
+    void CompareItem(ref Guid key, IntPtr value, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    void Compare(IMFAttributes attributes, int matchType, [MarshalAs(UnmanagedType.Bool)] out bool result);
+    [PreserveSig] int GetUINT32(ref Guid key, out uint value);
+    [PreserveSig] int GetUINT64(ref Guid key, out ulong value);
+    [PreserveSig] int GetDouble(ref Guid key, out double value);
+    [PreserveSig] int GetGUID(ref Guid key, out Guid value);
+    [PreserveSig] int GetStringLength(ref Guid key, out uint length);
+    [PreserveSig] int GetString(ref Guid key, [Out, MarshalAs(UnmanagedType.LPWStr)] System.Text.StringBuilder value, uint size, ref uint length);
+    void GetAllocatedString(ref Guid key, out IntPtr value, out uint length);
+    [PreserveSig] int GetBlobSize(ref Guid key, out uint size);
+    [PreserveSig] int GetBlob(ref Guid key, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint bufferSize, ref uint blobSize);
+    void GetAllocatedBlob(ref Guid key, out IntPtr buffer, out uint size);
+    void GetUnknown(ref Guid key, ref Guid riid, out IntPtr value);
+    void SetItem(ref Guid key, IntPtr value);
+    void DeleteItem(ref Guid key);
+    void DeleteAllItems();
+    void SetUINT32(ref Guid key, uint value);
+    void SetUINT64(ref Guid key, ulong value);
+    void SetDouble(ref Guid key, double value);
+    void SetGUID(ref Guid key, ref Guid value);
+    void SetString(ref Guid key, [MarshalAs(UnmanagedType.LPWStr)] string value);
+    void SetBlob(ref Guid key, [MarshalAs(UnmanagedType.LPArray)] byte[] buffer, uint size);
+    void SetUnknown(ref Guid key, IntPtr unknown);
+    void LockStore();
+    void UnlockStore();
+    void GetCount(out uint count);
+    void GetItemByIndex(uint index, out Guid key, IntPtr value);
+    void CopyAllItems(IMFAttributes destination);
+    // --- IMFMediaEvent
+    [PreserveSig] int GetEventType(out uint met);
+    [PreserveSig] int GetExtendedType(out Guid extendedType);
+    [PreserveSig] int GetStatus(out int status);
+    [PreserveSig] int GetValue(IntPtr value);
+}
+
+[ComImport, Guid("901db4c7-31ce-41a2-85dc-8fa0bf41b8da"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+internal interface ICodecAPI
+{
+    [PreserveSig] int IsSupported(ref Guid api);
+    [PreserveSig] int IsModifiable(ref Guid api);
+    [PreserveSig] int GetParameterRange(ref Guid api, out PropVariant min, out PropVariant max, out PropVariant delta);
+    [PreserveSig] int GetParameterValues(ref Guid api, out IntPtr values, out uint count);
+    [PreserveSig] int GetDefaultValue(ref Guid api, out PropVariant value);
+    [PreserveSig] int GetValue(ref Guid api, out PropVariant value);
+    [PreserveSig] int SetValue(ref Guid api, ref PropVariant value);
+}
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct MftInputStreamInfo
+{
+    public long MaxLatency;
+    public uint Flags;
+    public uint Size;
+    public uint MaxLookahead;
+    public uint Alignment;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct MftOutputStreamInfo
+{
+    public uint Flags;
+    public uint Size;
+    public uint Alignment;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct MftOutputDataBuffer
+{
+    public uint StreamId;
+    public IntPtr Sample;
+    public uint Status;
+    public IntPtr Events;
+}
+
+/// <summary>PROPVARIANT ridotta ai soli tipi scalari usati per la configurazione dell'encoder.</summary>
+[StructLayout(LayoutKind.Sequential, Size = 24)]
+internal struct PropVariant
+{
+    public ushort Type;
+    public ushort Reserved1;
+    public ushort Reserved2;
+    public ushort Reserved3;
+    public ulong Value;
+
+    public const ushort VtUI4 = 19;
+    public const ushort VtBool = 11;
+
+    public static PropVariant FromUInt32(uint value) => new() { Type = VtUI4, Value = value };
+}
+
+internal static class MediaFoundation
+{
+    public const uint Version = 0x00020070;
+    public const uint StartupLite = 1;
+
+    // Categorie e formati
+    public static Guid CategoryVideoEncoder = new("f79eac7d-e545-4387-bdee-d647d7bde42a");
+    public static Guid MajorTypeVideo = new("73646976-0000-0010-8000-00aa00389b71");
+    public static Guid VideoFormatH264 = new("34363248-0000-0010-8000-00aa00389b71");
+    public static Guid VideoFormatHevc = new("43564548-0000-0010-8000-00aa00389b71");
+    public static Guid VideoFormatNv12 = new("3231564e-0000-0010-8000-00aa00389b71");
+
+    // Attributi dei media type
+    public static Guid MtMajorType = new("48eba18e-f8c9-4687-bf11-0a74c9f96a8f");
+    public static Guid MtSubtype = new("f7e34c9a-42e8-4714-b74b-cb29d72c35e5");
+    public static Guid MtAvgBitrate = new("20332624-fb0d-4d9e-bd0d-cbf6786c102e");
+    public static Guid MtFrameSize = new("1652c33d-d6b2-4012-b834-72030849a37d");
+    public static Guid MtFrameRate = new("c459a2e8-3d2c-4e44-b132-fee5156c7bb0");
+    public static Guid MtPixelAspectRatio = new("c6376a1e-8d0a-4027-be45-6d9a0ad39bb6");
+    public static Guid MtInterlaceMode = new("e2724bb8-e676-4806-b4b2-a8d6efb44ccd");
+    public static Guid MtMpeg2Profile = new("ad76a80b-2d5c-4e0b-b375-64e520137036");
+    public static Guid MtMpegSequenceHeader = new("3c036de7-3ad0-4c9e-9216-ee6d6ac21cb3");
+    public static Guid MtAllSamplesIndependent = new("c9173739-5e56-461c-b713-46fb995cb95f");
+    public static Guid MtYuvMatrix = new("3e23d450-2c75-4d25-a00e-b91670d12327");
+    public static Guid MtVideoPrimaries = new("dbfbe4d7-0740-4ee0-8192-850ab0e21935");
+    public static Guid MtTransferFunction = new("5fb0fce9-be5c-4935-a811-ec838f8eed93");
+    public static Guid MtVideoNominalRange = new("c21b8ee5-b956-4071-8daf-325edf5cab11");
+
+    // Attributi delle trasformazioni
+    public static Guid TransformAsync = new("f81a699a-649a-497d-8c73-29f8fed6ad7a");
+    public static Guid TransformAsyncUnlock = new("e5666d6b-3422-4eb6-a421-da7db1f8e207");
+    public static Guid LowLatency = new("9c27891a-ed7a-40e1-88e8-b22727a024ee");
+    public static Guid MftFriendlyName = new("314ffbae-5b41-4c95-9c19-4e7d586face3");
+    public static Guid MftEnumHardwareUrl = new("2fb866ac-b078-4942-ab6c-003d05cda674");
+
+    // Attributi dei campioni
+    public static Guid SampleCleanPoint = new("9cdf01d8-a0f0-43ba-b077-eaa06cbd728a");
+
+    // Parametri ICodecAPI
+    public static Guid AvEncCommonRateControlMode = new("1c0608e9-370c-4710-8a58-cb6181c42423");
+    public static Guid AvEncCommonMeanBitRate = new("f7222374-2144-4815-b550-a37f8e12ee52");
+    public static Guid AvEncMpvDefaultBPictureCount = new("8d390aac-dc5c-4200-b57f-814d04babab2");
+    public static Guid AvEncMpvgopSize = new("95f31b26-95a4-41aa-9303-246a7fc6eef1");
+
+    // Messaggi e stati
+    public const int MessageCommandFlush = 0x00000000;
+    public const int MessageCommandDrain = 0x00000001;
+    public const int MessageNotifyBeginStreaming = 0x10000000;
+    public const int MessageNotifyEndStreaming = 0x10000001;
+    public const int MessageNotifyEndOfStream = 0x10000002;
+    public const int MessageNotifyStartOfStream = 0x10000003;
+
+    public const uint EventTransformNeedInput = 601;
+    public const uint EventTransformHaveOutput = 602;
+    public const uint EventTransformDrainComplete = 603;
+
+    public const uint EnumFlagSyncMft = 0x00000001;
+    public const uint EnumFlagAsyncMft = 0x00000002;
+    public const uint EnumFlagHardware = 0x00000004;
+    public const uint EnumFlagTranscodeOnly = 0x00000010;
+    public const uint EnumFlagSortAndFilter = 0x00000040;
+
+    public const uint OutputStreamProvidesSamples = 0x00000100;
+    public const uint InterlaceModeProgressive = 2;
+
+    public const int ErrorTransformNeedMoreInput = unchecked((int)0xC00D6D72);
+    public const int ErrorTransformStreamChange = unchecked((int)0xC00D6D61);
+    public const int ErrorNoMoreTypes = unchecked((int)0xC00D36B9);
+    public const int ErrorAttributeNotFound = unchecked((int)0xC00D36E6);
+
+    [DllImport("mfplat.dll", ExactSpelling = true)]
+    public static extern int MFStartup(uint version, uint flags);
+
+    [DllImport("mfplat.dll", ExactSpelling = true)]
+    public static extern int MFShutdown();
+
+    [DllImport("mfplat.dll", ExactSpelling = true)]
+    public static extern int MFCreateMediaType(out IMFMediaType type);
+
+    [DllImport("mfplat.dll", ExactSpelling = true)]
+    public static extern int MFCreateSample(out IMFSample sample);
+
+    [DllImport("mfplat.dll", ExactSpelling = true)]
+    public static extern int MFCreateMemoryBuffer(uint maxLength, out IMFMediaBuffer buffer);
+
+    [DllImport("mfplat.dll", ExactSpelling = true)]
+    public static extern int MFTEnumEx(Guid category, uint flags, IntPtr inputType, IntPtr outputType,
+                                       out IntPtr activateArray, out uint count);
+
+    [DllImport("ole32.dll", ExactSpelling = true)]
+    public static extern void CoTaskMemFree(IntPtr memory);
+
+    /// <summary>Impacchetta due valori a 32 bit in un attributo UINT64 (dimensioni, frame rate).</summary>
+    public static ulong Pack(uint high, uint low) => ((ulong)high << 32) | low;
+
+    public static void Check(int hr, string what)
+    {
+        if (hr < 0) throw new VideoEncoderException($"{what} non riuscita (HRESULT 0x{hr:X8}).");
+    }
+}
+
+/// <summary>Errore riconducibile allo stack di codifica di sistema.</summary>
+public sealed class VideoEncoderException(string message) : Exception(message);
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct MftRegisterTypeInfo
+{
+    public Guid MajorType;
+    public Guid Subtype;
+}

Titano/Video/Mp4Muxer.cs

@@ -0,0 +1,488 @@
+using System.Buffers.Binary;
+using System.Text;
+
+namespace Titano.Video;
+
+public enum VideoCodec
+{
+    H264,
+    Hevc,
+}
+
+/// <summary>
+/// Multiplexer ISO Base Media File Format (MP4) scritto interamente in-house.
+///
+/// Struttura generata: ftyp → mdat (in streaming, con dimensione a 64 bit corretta a
+/// posteriori) → moov. I campioni vengono scritti sul file di uscita mentre arrivano
+/// dall'encoder: nessun file temporaneo, nessuna copia intermedia dell'intero flusso.
+///
+/// Il muxer accetta bitstream in formato Annex-B (quello prodotto dagli encoder di sistema),
+/// ne estrae i parameter set per la configurazione del codec e converte le NAL nel formato
+/// a lunghezza prefissata richiesto dal contenitore.
+/// </summary>
+public sealed class Mp4Muxer : IDisposable
+{
+    private readonly Stream _output;
+    private readonly VideoCodec _codec;
+    private readonly int _width;
+    private readonly int _height;
+    private readonly uint _timescale;
+
+    private readonly List<uint> _sampleSizes = [];
+    private readonly List<uint> _sampleDurations = [];
+    private readonly List<int> _syncSamples = [];
+
+    private readonly List<byte[]> _vps = [];
+    private readonly List<byte[]> _sps = [];
+    private readonly List<byte[]> _pps = [];
+
+    private long _mdatHeaderPosition;
+    private long _mdatPayloadStart;
+    private long _mediaDuration;
+    private bool _finished;
+
+    /// <summary>Buffer di lavoro riusato per la conversione Annex-B → lunghezza prefissata.</summary>
+    private byte[] _scratch = new byte[1 << 20];
+
+    public int SampleCount => _sampleSizes.Count;
+    public long BytesWritten { get; private set; }
+    public bool HasParameterSets => _sps.Count > 0;
+
+    public Mp4Muxer(Stream output, VideoCodec codec, int width, int height, uint timescale)
+    {
+        if (!output.CanSeek) throw new ArgumentException("Il flusso di uscita deve essere posizionabile.", nameof(output));
+        _output = output;
+        _codec = codec;
+        _width = width;
+        _height = height;
+        _timescale = timescale == 0 ? 90000u : timescale;
+
+        WriteFileTypeBox();
+        BeginMediaData();
+    }
+
+    /// <summary>
+    /// Registra parameter set forniti fuori banda dall'encoder (blob MF_MT_MPEG_SEQUENCE_HEADER).
+    /// </summary>
+    public void AddParameterSets(ReadOnlySpan<byte> annexB)
+    {
+        foreach (var nal in AnnexBParser.EnumerateNals(annexB))
+        {
+            ClassifyAndStore(annexB, nal);
+        }
+    }
+
+    /// <summary>
+    /// Scrive un campione codificato. <paramref name="duration"/> è espressa nella timescale
+    /// della traccia, così ogni fotogramma può avere durata propria (playback adattivo).
+    /// </summary>
+    public void WriteSample(ReadOnlySpan<byte> annexB, uint duration)
+    {
+        ObjectDisposedException.ThrowIf(_finished, this);
+
+        int written = 0;
+        bool keyframe = false;
+
+        foreach (var nal in AnnexBParser.EnumerateNals(annexB))
+        {
+            var payload = annexB.Slice(nal.Start, nal.Length);
+            if (payload.Length == 0) continue;
+
+            if (IsParameterSet(payload[0]))
+            {
+                ClassifyAndStore(annexB, nal);
+                continue;                                   // i parameter set vivono in stsd, non in mdat
+            }
+
+            if (IsKeyframeNal(payload[0])) keyframe = true;
+
+            EnsureScratch(written + payload.Length + 4);
+            BinaryPrimitives.WriteUInt32BigEndian(_scratch.AsSpan(written), (uint)payload.Length);
+            payload.CopyTo(_scratch.AsSpan(written + 4));
+            written += payload.Length + 4;
+        }
+
+        if (written == 0) return;
+
+        _output.Write(_scratch, 0, written);
+        BytesWritten += written;
+
+        if (keyframe) _syncSamples.Add(_sampleSizes.Count + 1);   // gli indici in stss partono da 1
+        _sampleSizes.Add((uint)written);
+        _sampleDurations.Add(duration);
+        _mediaDuration += duration;
+    }
+
+    /// <summary>Chiude mdat, scrive moov e finalizza il file.</summary>
+    public void Finish()
+    {
+        if (_finished) return;
+        _finished = true;
+
+        long mdatEnd = _output.Position;
+        long mdatSize = mdatEnd - _mdatHeaderPosition;
+
+        // Correzione della dimensione a 64 bit riservata all'apertura del box.
+        _output.Position = _mdatHeaderPosition + 8;
+        Span<byte> size = stackalloc byte[8];
+        BinaryPrimitives.WriteInt64BigEndian(size, mdatSize);
+        _output.Write(size);
+
+        _output.Position = mdatEnd;
+        WriteMovieBox();
+        _output.Flush();
+    }
+
+    public void Dispose() => Finish();
+
+    // ------------------------------------------------------------------ box di apertura
+
+    private void WriteFileTypeBox()
+    {
+        using var box = new BoxWriter(_output, "ftyp");
+        box.WriteFourCc("isom");
+        box.WriteUInt32(0x200);
+        box.WriteFourCc("isom");
+        box.WriteFourCc("iso2");
+        box.WriteFourCc(_codec == VideoCodec.H264 ? "avc1" : "hvc1");
+        box.WriteFourCc("mp41");
+    }
+
+    private void BeginMediaData()
+    {
+        _mdatHeaderPosition = _output.Position;
+        Span<byte> header = stackalloc byte[16];
+        BinaryPrimitives.WriteUInt32BigEndian(header, 1);              // size = 1 → largesize a 64 bit
+        Encoding.ASCII.GetBytes("mdat", header[4..]);
+        BinaryPrimitives.WriteInt64BigEndian(header[8..], 16);         // valore provvisorio
+        _output.Write(header);
+        _mdatPayloadStart = _output.Position;
+    }
+
+    // ------------------------------------------------------------------ moov
+
+    private void WriteMovieBox()
+    {
+        uint movieTimescale = 1000;
+        long movieDuration = _timescale == 0 ? 0 : _mediaDuration * movieTimescale / _timescale;
+
+        using var moov = new BoxWriter(_output, "moov");
+
+        using (var mvhd = moov.Child("mvhd"))
+        {
+            mvhd.WriteFullBoxHeader(0, 0);
+            mvhd.WriteUInt32(0);                       // creation_time
+            mvhd.WriteUInt32(0);                       // modification_time
+            mvhd.WriteUInt32(movieTimescale);
+            mvhd.WriteUInt32((uint)movieDuration);
+            mvhd.WriteUInt32(0x00010000);              // rate 1.0
+            mvhd.WriteUInt16(0x0100);                  // volume 1.0
+            mvhd.WriteUInt16(0);                       // reserved
+            mvhd.WriteUInt32(0);
+            mvhd.WriteUInt32(0);
+            mvhd.WriteMatrix();
+            for (int i = 0; i < 6; i++) mvhd.WriteUInt32(0);  // pre_defined
+            mvhd.WriteUInt32(2);                       // next_track_ID
+        }
+
+        using (var trak = moov.Child("trak"))
+        {
+            using (var tkhd = trak.Child("tkhd"))
+            {
+                tkhd.WriteFullBoxHeader(0, 0x000007);  // enabled | in movie | in preview
+                tkhd.WriteUInt32(0);
+                tkhd.WriteUInt32(0);
+                tkhd.WriteUInt32(1);                   // track_ID
+                tkhd.WriteUInt32(0);                   // reserved
+                tkhd.WriteUInt32((uint)movieDuration);
+                tkhd.WriteUInt32(0);
+                tkhd.WriteUInt32(0);
+                tkhd.WriteUInt16(0);                   // layer
+                tkhd.WriteUInt16(0);                   // alternate_group
+                tkhd.WriteUInt16(0);                   // volume (0 per il video)
+                tkhd.WriteUInt16(0);
+                tkhd.WriteMatrix();
+                tkhd.WriteUInt32((uint)_width << 16);
+                tkhd.WriteUInt32((uint)_height << 16);
+            }
+
+            using var mdia = trak.Child("mdia");
+
+            using (var mdhd = mdia.Child("mdhd"))
+            {
+                mdhd.WriteFullBoxHeader(0, 0);
+                mdhd.WriteUInt32(0);
+                mdhd.WriteUInt32(0);
+                mdhd.WriteUInt32(_timescale);
+                mdhd.WriteUInt32((uint)_mediaDuration);
+                mdhd.WriteUInt16(0x55C4);              // lingua "und" impacchettata a 5 bit
+                mdhd.WriteUInt16(0);
+            }
+
+            using (var hdlr = mdia.Child("hdlr"))
+            {
+                hdlr.WriteFullBoxHeader(0, 0);
+                hdlr.WriteUInt32(0);                   // pre_defined
+                hdlr.WriteFourCc("vide");
+                hdlr.WriteUInt32(0);
+                hdlr.WriteUInt32(0);
+                hdlr.WriteUInt32(0);
+                hdlr.WriteCString("Titano Video Handler");
+            }
+
+            using var minf = mdia.Child("minf");
+
+            using (var vmhd = minf.Child("vmhd"))
+            {
+                vmhd.WriteFullBoxHeader(0, 1);
+                vmhd.WriteUInt16(0);                   // graphicsmode
+                vmhd.WriteUInt16(0);                   // opcolor
+                vmhd.WriteUInt16(0);
+                vmhd.WriteUInt16(0);
+            }
+
+            using (var dinf = minf.Child("dinf"))
+            using (var dref = dinf.Child("dref"))
+            {
+                dref.WriteFullBoxHeader(0, 0);
+                dref.WriteUInt32(1);                   // entry_count
+                using var url = dref.Child("url ");
+                url.WriteFullBoxHeader(0, 1);          // flag 1 = dati nello stesso file
+            }
+
+            using var stbl = minf.Child("stbl");
+            WriteSampleDescription(stbl);
+            WriteTimeToSample(stbl);
+            WriteSyncSamples(stbl);
+            WriteSampleToChunk(stbl);
+            WriteSampleSizes(stbl);
+            WriteChunkOffsets(stbl);
+        }
+    }
+
+    private void WriteSampleDescription(BoxWriter stbl)
+    {
+        using var stsd = stbl.Child("stsd");
+        stsd.WriteFullBoxHeader(0, 0);
+        stsd.WriteUInt32(1);                           // entry_count
+
+        string entryName = _codec == VideoCodec.H264 ? "avc1" : "hvc1";
+        using var entry = stsd.Child(entryName);
+
+        for (int i = 0; i < 6; i++) entry.WriteByte(0); // reserved
+        entry.WriteUInt16(1);                           // data_reference_index
+        entry.WriteUInt16(0);                           // pre_defined
+        entry.WriteUInt16(0);                           // reserved
+        for (int i = 0; i < 3; i++) entry.WriteUInt32(0);
+        entry.WriteUInt16((ushort)_width);
+        entry.WriteUInt16((ushort)_height);
+        entry.WriteUInt32(0x00480000);                  // 72 dpi orizzontali
+        entry.WriteUInt32(0x00480000);                  // 72 dpi verticali
+        entry.WriteUInt32(0);                           // reserved
+        entry.WriteUInt16(1);                           // frame_count
+        entry.WritePascalString32("Titano");            // compressorname
+        entry.WriteUInt16(0x0018);                      // profondità 24 bit
+        entry.WriteUInt16(0xFFFF);                      // pre_defined = -1
+
+        if (_codec == VideoCodec.H264) WriteAvcConfiguration(entry);
+        else WriteHevcConfiguration(entry);
+
+        using (var colr = entry.Child("colr"))
+        {
+            colr.WriteFourCc("nclx");
+            colr.WriteUInt16(1);                        // primarie BT.709
+            colr.WriteUInt16(1);                        // funzione di trasferimento BT.709
+            colr.WriteUInt16(1);                        // matrice BT.709
+            colr.WriteByte(0);                          // range televisivo (16-235)
+        }
+
+        using var pasp = entry.Child("pasp");
+        pasp.WriteUInt32(1);                            // pixel quadrati
+        pasp.WriteUInt32(1);
+    }
+
+    private void WriteAvcConfiguration(BoxWriter entry)
+    {
+        using var avcc = entry.Child("avcC");
+        byte[] sps = _sps.Count > 0 ? _sps[0] : [];
+
+        avcc.WriteByte(1);                                              // configurationVersion
+        avcc.WriteByte(sps.Length > 1 ? sps[1] : (byte)0x64);           // AVCProfileIndication
+        avcc.WriteByte(sps.Length > 2 ? sps[2] : (byte)0x00);           // profile_compatibility
+        avcc.WriteByte(sps.Length > 3 ? sps[3] : (byte)0x28);           // AVCLevelIndication
+        avcc.WriteByte(0xFF);                                           // 6 bit riservati + lengthSizeMinusOne = 3
+        avcc.WriteByte((byte)(0xE0 | Math.Min(_sps.Count, 31)));        // 3 bit riservati + numOfSPS
+
+        foreach (var set in _sps)
+        {
+            avcc.WriteUInt16((ushort)set.Length);
+            avcc.WriteBytes(set);
+        }
+
+        avcc.WriteByte((byte)Math.Min(_pps.Count, 255));
+        foreach (var set in _pps)
+        {
+            avcc.WriteUInt16((ushort)set.Length);
+            avcc.WriteBytes(set);
+        }
+    }
+
+    private void WriteHevcConfiguration(BoxWriter entry)
+    {
+        using var hvcc = entry.Child("hvcC");
+        byte[] sps = _sps.Count > 0 ? _sps[0] : [];
+
+        // profile_tier_level occupa 12 byte subito dopo i due byte di header NAL e il byte
+        // che contiene sps_video_parameter_set_id / sps_max_sub_layers_minus1.
+        Span<byte> ptl = stackalloc byte[12];
+        if (sps.Length >= 15) sps.AsSpan(3, 12).CopyTo(ptl);
+        else ptl[0] = 0x01;                                             // Main profile come ripiego
+
+        hvcc.WriteByte(1);                                              // configurationVersion
+        hvcc.WriteByte(ptl[0]);                                         // profile_space/tier/profile_idc
+        hvcc.WriteBytes(ptl[1..5]);                                     // general_profile_compatibility_flags
+        hvcc.WriteBytes(ptl[5..11]);                                    // general_constraint_indicator_flags
+        hvcc.WriteByte(ptl[11]);                                        // general_level_idc
+        hvcc.WriteUInt16(0xF000);                                       // min_spatial_segmentation = 0
+        hvcc.WriteByte(0xFC);                                           // parallelismType sconosciuto
+        hvcc.WriteByte(0xFD);                                           // chromaFormat 4:2:0
+        hvcc.WriteByte(0xF8);                                           // bitDepthLumaMinus8 = 0
+        hvcc.WriteByte(0xF8);                                           // bitDepthChromaMinus8 = 0
+        hvcc.WriteUInt16(0);                                            // avgFrameRate (non dichiarato)
+        hvcc.WriteByte(0x0F);                                           // costantFrameRate/temporalId + lengthSizeMinusOne
+        hvcc.WriteByte((byte)((_vps.Count > 0 ? 1 : 0) + (_sps.Count > 0 ? 1 : 0) + (_pps.Count > 0 ? 1 : 0)));
+
+        WriteHevcArray(hvcc, 32, _vps);
+        WriteHevcArray(hvcc, 33, _sps);
+        WriteHevcArray(hvcc, 34, _pps);
+    }
+
+    private static void WriteHevcArray(BoxWriter hvcc, byte nalType, List<byte[]> sets)
+    {
+        if (sets.Count == 0) return;
+        hvcc.WriteByte((byte)(0x80 | nalType));                         // array_completeness + NAL_unit_type
+        hvcc.WriteUInt16((ushort)sets.Count);
+        foreach (var set in sets)
+        {
+            hvcc.WriteUInt16((ushort)set.Length);
+            hvcc.WriteBytes(set);
+        }
+    }
+
+    private void WriteTimeToSample(BoxWriter stbl)
+    {
+        // Codifica a corse: le durate uguali consecutive occupano una sola voce.
+        var runs = new List<(uint Count, uint Delta)>();
+        foreach (uint delta in _sampleDurations)
+        {
+            if (runs.Count > 0 && runs[^1].Delta == delta) runs[^1] = (runs[^1].Count + 1, delta);
+            else runs.Add((1, delta));
+        }
+
+        using var stts = stbl.Child("stts");
+        stts.WriteFullBoxHeader(0, 0);
+        stts.WriteUInt32((uint)runs.Count);
+        foreach (var (count, delta) in runs)
+        {
+            stts.WriteUInt32(count);
+            stts.WriteUInt32(delta);
+        }
+    }
+
+    private void WriteSyncSamples(BoxWriter stbl)
+    {
+        // Se ogni campione è un punto di sincronizzazione la tabella si omette per convenzione.
+        if (_syncSamples.Count == _sampleSizes.Count || _syncSamples.Count == 0) return;
+
+        using var stss = stbl.Child("stss");
+        stss.WriteFullBoxHeader(0, 0);
+        stss.WriteUInt32((uint)_syncSamples.Count);
+        foreach (int index in _syncSamples) stss.WriteUInt32((uint)index);
+    }
+
+    private void WriteSampleToChunk(BoxWriter stbl)
+    {
+        using var stsc = stbl.Child("stsc");
+        stsc.WriteFullBoxHeader(0, 0);
+        stsc.WriteUInt32(1);                            // una sola voce: tutti i campioni in un chunk
+        stsc.WriteUInt32(1);                            // first_chunk
+        stsc.WriteUInt32((uint)Math.Max(1, _sampleSizes.Count));
+        stsc.WriteUInt32(1);                            // sample_description_index
+    }
+
+    private void WriteSampleSizes(BoxWriter stbl)
+    {
+        using var stsz = stbl.Child("stsz");
+        stsz.WriteFullBoxHeader(0, 0);
+        stsz.WriteUInt32(0);                            // dimensione variabile
+        stsz.WriteUInt32((uint)_sampleSizes.Count);
+        foreach (uint size in _sampleSizes) stsz.WriteUInt32(size);
+    }
+
+    private void WriteChunkOffsets(BoxWriter stbl)
+    {
+        using var co64 = stbl.Child("co64");
+        co64.WriteFullBoxHeader(0, 0);
+        co64.WriteUInt32(1);
+        co64.WriteUInt64((ulong)_mdatPayloadStart);
+    }
+
+    // ------------------------------------------------------------------ NAL
+
+    private bool IsParameterSet(byte header)
+    {
+        if (_codec == VideoCodec.H264)
+        {
+            int type = header & 0x1F;
+            return type is 7 or 8;                      // SPS, PPS
+        }
+        int hevcType = (header >> 1) & 0x3F;
+        return hevcType is 32 or 33 or 34;              // VPS, SPS, PPS
+    }
+
+    private bool IsKeyframeNal(byte header)
+    {
+        if (_codec == VideoCodec.H264) return (header & 0x1F) == 5;     // IDR
+        int type = (header >> 1) & 0x3F;
+        return type is >= 16 and <= 21;                 // BLA/IDR/CRA
+    }
+
+    private void ClassifyAndStore(ReadOnlySpan<byte> source, AnnexBParser.NalRange nal)
+    {
+        if (nal.Length <= 0) return;
+        var payload = source.Slice(nal.Start, nal.Length);
+        byte header = payload[0];
+
+        List<byte[]> target;
+        if (_codec == VideoCodec.H264)
+        {
+            int type = header & 0x1F;
+            if (type == 7) target = _sps;
+            else if (type == 8) target = _pps;
+            else return;
+        }
+        else
+        {
+            int type = (header >> 1) & 0x3F;
+            if (type == 32) target = _vps;
+            else if (type == 33) target = _sps;
+            else if (type == 34) target = _pps;
+            else return;
+        }
+
+        var copy = payload.ToArray();
+        foreach (var existing in target)
+        {
+            if (existing.AsSpan().SequenceEqual(copy)) return;
+        }
+        target.Add(copy);
+    }
+
+    private void EnsureScratch(int required)
+    {
+        if (_scratch.Length >= required) return;
+        int size = _scratch.Length;
+        while (size < required) size *= 2;
+        _scratch = new byte[size];
+    }
+}

Titano/Video/Nv12Converter.cs

@@ -0,0 +1,81 @@
+using Titano.Imaging;
+
+namespace Titano.Video;
+
+/// <summary>
+/// Conversione da RGB lineare a NV12 (Y a piena risoluzione + CbCr interlacciato a metà
+/// risoluzione), il formato d'ingresso atteso dagli encoder hardware.
+///
+/// La matrice è quella BT.709 in range televisivo (Y 16-235, C 16-240): è la convenzione
+/// dichiarata nel box "colr" del contenitore, quindi il colore resta coerente in riproduzione.
+/// La codifica di gamma viene riapplicata qui, all'ultimo passaggio utile: tutta l'elaborazione
+/// a monte è avvenuta in luce lineare.
+/// </summary>
+public static class Nv12Converter
+{
+    public static int RequiredSize(int width, int height) => width * height * 3 / 2;
+
+    public static unsafe void Convert(ImageBuffer source, byte* destination)
+    {
+        int width = source.Width;
+        int height = source.Height;
+        var data = source.Data;
+
+        byte* yPlane = destination;
+        byte* uvPlane = destination + (long)width * height;
+        int chromaRows = height / 2;
+
+        Parallel.For(0, chromaRows, cy =>
+        {
+            int y0 = cy * 2;
+            int y1 = Math.Min(y0 + 1, height - 1);
+
+            for (int cx = 0; cx < width / 2; cx++)
+            {
+                int x0 = cx * 2;
+                int x1 = Math.Min(x0 + 1, width - 1);
+
+                double cbSum = 0, crSum = 0;
+
+                cbSum += Encode(data, width, x0, y0, yPlane, out double cr00); crSum += cr00;
+                cbSum += Encode(data, width, x1, y0, yPlane, out double cr10); crSum += cr10;
+                cbSum += Encode(data, width, x0, y1, yPlane, out double cr01); crSum += cr01;
+                cbSum += Encode(data, width, x1, y1, yPlane, out double cr11); crSum += cr11;
+
+                long uvIndex = (long)cy * width + cx * 2;
+                uvPlane[uvIndex] = Quantize(128.0 + 224.0 * (cbSum * 0.25));
+                uvPlane[uvIndex + 1] = Quantize(128.0 + 224.0 * (crSum * 0.25));
+            }
+        });
+
+        // Riga o colonna dispari residua: la luma va comunque scritta.
+        if ((height & 1) != 0)
+        {
+            int y = height - 1;
+            for (int x = 0; x < width; x++) Encode(data, width, x, y, yPlane, out _);
+        }
+        if ((width & 1) != 0)
+        {
+            int x = width - 1;
+            for (int y = 0; y < height; y++) Encode(data, width, x, y, yPlane, out _);
+        }
+    }
+
+    /// <summary>Scrive la luma del pixel indicato e restituisce le due crominanze normalizzate.</summary>
+    private static unsafe double Encode(float[] data, int width, int x, int y, byte* yPlane, out double cr)
+    {
+        int index = (y * width + x) * ImageBuffer.Channels;
+        float r = ColorSpace.ToSrgb(data[index]);
+        float g = ColorSpace.ToSrgb(data[index + 1]);
+        float b = ColorSpace.ToSrgb(data[index + 2]);
+
+        double luma = ColorSpace.LumaR * r + ColorSpace.LumaG * g + ColorSpace.LumaB * b;
+        yPlane[(long)y * width + x] = Quantize(16.0 + 219.0 * luma);
+
+        cr = (r - luma) / 1.5748;
+        return (b - luma) / 1.8556;
+    }
+
+    private static byte Quantize(double value)
+        => (byte)Math.Clamp((int)(value + 0.5), 0, 255);
+}

Titano/Video/VideoEncoderSession.cs

@@ -0,0 +1,638 @@
+using System.Runtime.InteropServices;
+using System.Text;
+using Titano.Imaging;
+
+namespace Titano.Video;
+
+/// <summary>
+/// Sessione di codifica: pilota direttamente la Media Foundation Transform dell'encoder di
+/// sistema (hardware se disponibile) e riversa le NAL prodotte nel multiplexer MP4 in-house.
+///
+/// I fotogrammi entrano come buffer in memoria, escono come pacchetti compressi e finiscono
+/// nel file di destinazione: nessun passaggio intermedio su disco.
+/// </summary>
+public sealed class VideoEncoderSession : IDisposable
+{
+    private readonly ExportSettings _settings;
+    private readonly int _width;
+    private readonly int _height;
+    private readonly Stream _output;
+    private readonly Mp4Muxer _muxer;
+
+    private IMFTransform? _transform;
+    private IMFMediaEventGenerator? _events;
+    private uint _inputStreamId;
+    private uint _outputStreamId;
+    private bool _async;
+    private MftOutputStreamInfo _outputInfo;
+
+    private readonly Queue<uint> _pendingDurations = new();
+    private long _presentationTime;
+    private byte[] _packetBuffer = new byte[1 << 20];
+    private int _pendingNeedInput;
+    private bool _finished;
+
+    public string EncoderName { get; private set; } = "sconosciuto";
+    public bool IsHardware { get; private set; }
+    public int EncodedFrames { get; private set; }
+    public long OutputBytes => _muxer.BytesWritten;
+
+    public VideoEncoderSession(ExportSettings settings, int width, int height)
+    {
+        if ((width & 1) != 0 || (height & 1) != 0)
+            throw new ArgumentException("La codifica 4:2:0 richiede dimensioni pari.");
+
+        _settings = settings;
+        _width = width;
+        _height = height;
+
+        MediaFoundationRuntime.Startup();
+
+        _output = new FileStream(settings.OutputPath, FileMode.Create, FileAccess.ReadWrite,
+                                 FileShare.Read, 1 << 20, FileOptions.SequentialScan);
+        try
+        {
+            _muxer = new Mp4Muxer(_output, settings.Codec, width, height, settings.Timescale);
+            CreateTransform();
+            ConfigureTypes();
+            StartStreaming();
+        }
+        catch
+        {
+            _output.Dispose();
+            TryDeletePartialFile();
+            throw;
+        }
+    }
+
+    // ------------------------------------------------------------------ configurazione
+
+    private void CreateTransform()
+    {
+        Guid subtype = _settings.Codec == VideoCodec.H264
+            ? MediaFoundation.VideoFormatH264
+            : MediaFoundation.VideoFormatHevc;
+
+        var outputInfo = new MftRegisterTypeInfo
+        {
+            MajorType = MediaFoundation.MajorTypeVideo,
+            Subtype = subtype,
+        };
+
+        // Prima gli encoder hardware, poi quelli software: stessa interfaccia, stesso codice.
+        if (_settings.PreferHardware &&
+            TryActivate(outputInfo, MediaFoundation.EnumFlagHardware | MediaFoundation.EnumFlagSortAndFilter, true))
+            return;
+
+        if (TryActivate(outputInfo, MediaFoundation.EnumFlagSyncMft | MediaFoundation.EnumFlagAsyncMft |
+                                    MediaFoundation.EnumFlagSortAndFilter, false))
+            return;
+
+        throw new VideoEncoderException(
+            $"Nessun encoder {( _settings.Codec == VideoCodec.H264 ? "H.264" : "HEVC")} disponibile nel sistema. " +
+            "Su alcune edizioni di Windows occorre installare il Media Feature Pack.");
+    }
+
+    private unsafe bool TryActivate(MftRegisterTypeInfo outputInfo, uint flags, bool hardware)
+    {
+        IntPtr array = IntPtr.Zero;
+        try
+        {
+            // I parametri sono già su stack: se ne può prendere l'indirizzo senza "fixed".
+            MftRegisterTypeInfo* pOutput = &outputInfo;
+            int hr = MediaFoundation.MFTEnumEx(MediaFoundation.CategoryVideoEncoder, flags,
+                                               IntPtr.Zero, (IntPtr)pOutput, out array, out uint count);
+            if (hr < 0 || count == 0 || array == IntPtr.Zero) return false;
+
+            for (uint i = 0; i < count; i++)
+            {
+                IntPtr activatePtr = Marshal.ReadIntPtr(array, (int)i * IntPtr.Size);
+                if (activatePtr == IntPtr.Zero) continue;
+
+                var activate = (IMFActivate)Marshal.GetObjectForIUnknown(activatePtr);
+                try
+                {
+                    if (_transform is null && TryActivateOne(activate, hardware)) { /* trovato */ }
+                }
+                finally
+                {
+                    Marshal.ReleaseComObject(activate);
+                    Marshal.Release(activatePtr);
+                }
+
+                if (_transform is not null) return true;
+            }
+            return false;
+        }
+        finally
+        {
+            if (array != IntPtr.Zero) MediaFoundation.CoTaskMemFree(array);
+        }
+    }
+
+    private bool TryActivateOne(IMFActivate activate, bool hardware)
+    {
+        var iid = typeof(IMFTransform).GUID;
+        if (activate.ActivateObject(ref iid, out IntPtr instance) < 0 || instance == IntPtr.Zero) return false;
+
+        IMFTransform transform;
+        try
+        {
+            transform = (IMFTransform)Marshal.GetObjectForIUnknown(instance);
+        }
+        finally
+        {
+            Marshal.Release(instance);
+        }
+
+        try
+        {
+            string name = ReadFriendlyName(activate);
+
+            // Le trasformazioni hardware sono asincrone e vanno sbloccate esplicitamente.
+            bool isAsync = false;
+            if (transform.GetAttributes(out var attributes) >= 0 && attributes is not null)
+            {
+                try
+                {
+                    var asyncKey = MediaFoundation.TransformAsync;
+                    if (attributes.GetUINT32(ref asyncKey, out uint asyncFlag) >= 0 && asyncFlag != 0)
+                    {
+                        isAsync = true;
+                        var unlockKey = MediaFoundation.TransformAsyncUnlock;
+                        attributes.SetUINT32(ref unlockKey, 1);
+                    }
+                }
+                finally
+                {
+                    Marshal.ReleaseComObject(attributes);
+                }
+            }
+
+            _transform = transform;
+            _async = isAsync;
+            IsHardware = hardware;
+            EncoderName = name;
+            return true;
+        }
+        catch
+        {
+            Marshal.ReleaseComObject(transform);
+            return false;
+        }
+    }
+
+    private static string ReadFriendlyName(IMFActivate activate)
+    {
+        var key = MediaFoundation.MftFriendlyName;
+        if (activate.GetStringLength(ref key, out uint length) < 0 || length == 0) return "encoder di sistema";
+
+        var builder = new StringBuilder((int)length + 1);
+        uint written = 0;
+        return activate.GetString(ref key, builder, length + 1, ref written) < 0
+            ? "encoder di sistema"
+            : builder.ToString();
+    }
+
+    private void ConfigureTypes()
+    {
+        var transform = _transform!;
+
+        transform.GetStreamCount(out uint inputs, out uint outputs);
+        var inputIds = new uint[Math.Max(1, inputs)];
+        var outputIds = new uint[Math.Max(1, outputs)];
+        if (transform.GetStreamIDs((uint)inputIds.Length, inputIds, (uint)outputIds.Length, outputIds) >= 0)
+        {
+            _inputStreamId = inputIds[0];
+            _outputStreamId = outputIds[0];
+        }
+
+        uint fpsNumerator = (uint)Math.Round(_settings.FrameRate * 1000.0);
+        const uint fpsDenominator = 1000;
+
+        // L'ordine è vincolante: prima il tipo di uscita (compresso), poi quello d'ingresso.
+        MediaFoundation.Check(MediaFoundation.MFCreateMediaType(out IMFMediaType outputType), "Creazione del tipo di uscita");
+        try
+        {
+            SetGuid(outputType, MediaFoundation.MtMajorType, MediaFoundation.MajorTypeVideo);
+            SetGuid(outputType, MediaFoundation.MtSubtype,
+                    _settings.Codec == VideoCodec.H264 ? MediaFoundation.VideoFormatH264 : MediaFoundation.VideoFormatHevc);
+            SetUInt32(outputType, MediaFoundation.MtAvgBitrate, _settings.AverageBitrate);
+            SetUInt32(outputType, MediaFoundation.MtInterlaceMode, MediaFoundation.InterlaceModeProgressive);
+            SetUInt64(outputType, MediaFoundation.MtFrameSize, MediaFoundation.Pack((uint)_width, (uint)_height));
+            SetUInt64(outputType, MediaFoundation.MtFrameRate, MediaFoundation.Pack(fpsNumerator, fpsDenominator));
+            SetUInt64(outputType, MediaFoundation.MtPixelAspectRatio, MediaFoundation.Pack(1, 1));
+            if (_settings.Codec == VideoCodec.H264)
+                SetUInt32(outputType, MediaFoundation.MtMpeg2Profile, (uint)_settings.Profile);
+
+            int hr = transform.SetOutputType(_outputStreamId, outputType, 0);
+            MediaFoundation.Check(hr, "Impostazione del formato compresso");
+        }
+        finally
+        {
+            Marshal.ReleaseComObject(outputType);
+        }
+
+        MediaFoundation.Check(MediaFoundation.MFCreateMediaType(out IMFMediaType inputType), "Creazione del tipo d'ingresso");
+        try
+        {
+            SetGuid(inputType, MediaFoundation.MtMajorType, MediaFoundation.MajorTypeVideo);
+            SetGuid(inputType, MediaFoundation.MtSubtype, MediaFoundation.VideoFormatNv12);
+            SetUInt32(inputType, MediaFoundation.MtInterlaceMode, MediaFoundation.InterlaceModeProgressive);
+            SetUInt64(inputType, MediaFoundation.MtFrameSize, MediaFoundation.Pack((uint)_width, (uint)_height));
+            SetUInt64(inputType, MediaFoundation.MtFrameRate, MediaFoundation.Pack(fpsNumerator, fpsDenominator));
+            SetUInt64(inputType, MediaFoundation.MtPixelAspectRatio, MediaFoundation.Pack(1, 1));
+            SetUInt32(inputType, MediaFoundation.MtYuvMatrix, 2);            // BT.709
+            SetUInt32(inputType, MediaFoundation.MtVideoPrimaries, 3);       // BT.709
+            SetUInt32(inputType, MediaFoundation.MtTransferFunction, 5);     // BT.709
+            SetUInt32(inputType, MediaFoundation.MtVideoNominalRange, 2);    // 16-235
+
+            int hr = transform.SetInputType(_inputStreamId, inputType, 0);
+            MediaFoundation.Check(hr, "Impostazione del formato d'ingresso NV12");
+        }
+        finally
+        {
+            Marshal.ReleaseComObject(inputType);
+        }
+
+        ConfigureCodecApi();
+
+        transform.GetOutputStreamInfo(_outputStreamId, out _outputInfo);
+        ReadSequenceHeader();
+    }
+
+    /// <summary>
+    /// Configurazione fine dell'encoder. Le B-frame vengono azzerate: senza riordino,
+    /// l'ordine di decodifica coincide con quello di presentazione e il muxer può usare
+    /// direttamente le durate della sequenza, comprese quelle variabili.
+    /// </summary>
+    private void ConfigureCodecApi()
+    {
+        if (_transform is not ICodecAPI codec) return;
+
+        TrySet(codec, MediaFoundation.AvEncMpvDefaultBPictureCount, 0);
+        TrySet(codec, MediaFoundation.AvEncCommonRateControlMode, 0);        // bitrate costante
+        TrySet(codec, MediaFoundation.AvEncCommonMeanBitRate, _settings.AverageBitrate);
+
+        uint gop = (uint)Math.Clamp(_settings.KeyframeIntervalSeconds * _settings.FrameRate, 1, 600);
+        TrySet(codec, MediaFoundation.AvEncMpvgopSize, gop);
+
+        static void TrySet(ICodecAPI codec, Guid parameter, uint value)
+        {
+            try
+            {
+                var variant = PropVariant.FromUInt32(value);
+                codec.SetValue(ref parameter, ref variant);
+            }
+            catch (COMException)
+            {
+                // Parametro non supportato dall'encoder: si prosegue con il valore predefinito.
+            }
+        }
+    }
+
+    /// <summary>Preleva i parameter set fuori banda, se l'encoder li espone già.</summary>
+    private void ReadSequenceHeader()
+    {
+        if (_transform!.GetOutputCurrentType(_outputStreamId, out IMFMediaType current) < 0) return;
+        try
+        {
+            var key = MediaFoundation.MtMpegSequenceHeader;
+            if (current.GetBlobSize(ref key, out uint size) < 0 || size == 0) return;
+
+            var blob = new byte[size];
+            uint actual = 0;
+            if (current.GetBlob(ref key, blob, size, ref actual) < 0) return;
+            _muxer.AddParameterSets(blob.AsSpan(0, (int)Math.Min(actual == 0 ? size : actual, size)));
+        }
+        finally
+        {
+            Marshal.ReleaseComObject(current);
+        }
+    }
+
+    private void StartStreaming()
+    {
+        var transform = _transform!;
+
+        if (_async)
+        {
+            var generator = transform as IMFMediaEventGenerator
+                ?? throw new VideoEncoderException("L'encoder asincrono non espone la coda eventi.");
+            _events = generator;
+        }
+
+        MediaFoundation.Check(transform.ProcessMessage(MediaFoundation.MessageNotifyBeginStreaming, IntPtr.Zero),
+                              "Avvio dello streaming");
+        MediaFoundation.Check(transform.ProcessMessage(MediaFoundation.MessageNotifyStartOfStream, IntPtr.Zero),
+                              "Notifica di inizio flusso");
+    }
+
+    // ------------------------------------------------------------------ codifica
+
+    /// <summary>
+    /// Codifica un fotogramma. <paramref name="durationUnits"/> è la durata nella timescale
+    /// della traccia, quindi ogni fotogramma può restare a schermo per un tempo diverso.
+    /// </summary>
+    public unsafe void EncodeFrame(ImageBuffer frame, uint durationUnits)
+    {
+        ObjectDisposedException.ThrowIf(_finished, this);
+        if (frame.Width != _width || frame.Height != _height)
+            throw new ArgumentException("Il fotogramma non corrisponde alla risoluzione della sessione.");
+
+        long durationHns = durationUnits * 10_000_000L / _settings.Timescale;
+
+        if (_async) WaitForInputSlot();
+
+        int size = Nv12Converter.RequiredSize(_width, _height);
+        MediaFoundation.Check(MediaFoundation.MFCreateMemoryBuffer((uint)size, out IMFMediaBuffer buffer),
+                              "Allocazione del buffer d'ingresso");
+        IMFSample? sample = null;
+        try
+        {
+            buffer.Lock(out IntPtr pointer, out _, out _);
+            try
+            {
+                Nv12Converter.Convert(frame, (byte*)pointer);
+            }
+            finally
+            {
+                buffer.Unlock();
+            }
+            buffer.SetCurrentLength((uint)size);
+
+            MediaFoundation.Check(MediaFoundation.MFCreateSample(out sample), "Creazione del campione");
+            sample.AddBuffer(buffer);
+            sample.SetSampleTime(_presentationTime);
+            sample.SetSampleDuration(durationHns);
+
+            _pendingDurations.Enqueue(durationUnits);
+            int hr = _transform!.ProcessInput(_inputStreamId, sample, 0);
+            if (hr < 0)
+            {
+                _pendingDurations.Dequeue();
+                MediaFoundation.Check(hr, "Invio del fotogramma all'encoder");
+            }
+
+            _presentationTime += durationHns;
+        }
+        finally
+        {
+            if (sample is not null) Marshal.ReleaseComObject(sample);
+            Marshal.ReleaseComObject(buffer);
+        }
+
+        if (!_async)
+        {
+            while (TryDrainOutput()) { }
+        }
+    }
+
+    /// <summary>Chiude il flusso, svuota l'encoder e finalizza il contenitore.</summary>
+    public void Finish()
+    {
+        if (_finished) return;
+        _finished = true;
+
+        try
+        {
+            var transform = _transform;
+            if (transform is not null)
+            {
+                transform.ProcessMessage(MediaFoundation.MessageNotifyEndOfStream, IntPtr.Zero);
+                transform.ProcessMessage(MediaFoundation.MessageCommandDrain, IntPtr.Zero);
+
+                if (_async) PumpUntilDrained();
+                else
+                {
+                    while (TryDrainOutput()) { }
+                }
+
+                transform.ProcessMessage(MediaFoundation.MessageNotifyEndStreaming, IntPtr.Zero);
+            }
+        }
+        finally
+        {
+            _muxer.Finish();
+            _output.Dispose();
+            ReleaseTransform();
+        }
+    }
+
+    // ------------------------------------------------------------------ pompa eventi (MFT asincrone)
+
+    private void WaitForInputSlot()
+    {
+        while (_pendingNeedInput == 0)
+        {
+            if (!ProcessNextEvent()) throw new VideoEncoderException("L'encoder ha chiuso la coda eventi.");
+        }
+        _pendingNeedInput--;
+    }
+
+    private void PumpUntilDrained()
+    {
+        int guard = 0;
+        while (guard++ < 1_000_000)
+        {
+            if (!ProcessNextEvent()) return;
+            if (_drainComplete) return;
+        }
+    }
+
+    private bool _drainComplete;
+
+    private bool ProcessNextEvent()
+    {
+        var generator = _events;
+        if (generator is null) return false;
+
+        int hr = generator.GetEvent(0, out IMFMediaEvent mediaEvent);
+        if (hr < 0 || mediaEvent is null) return false;
+
+        try
+        {
+            if (mediaEvent.GetEventType(out uint type) < 0) return true;
+
+            switch (type)
+            {
+                case MediaFoundation.EventTransformNeedInput:
+                    _pendingNeedInput++;
+                    break;
+                case MediaFoundation.EventTransformHaveOutput:
+                    TryDrainOutput();
+                    break;
+                case MediaFoundation.EventTransformDrainComplete:
+                    _drainComplete = true;
+                    break;
+            }
+            return true;
+        }
+        finally
+        {
+            Marshal.ReleaseComObject(mediaEvent);
+        }
+    }
+
+    /// <summary>Estrae un pacchetto compresso dall'encoder e lo consegna al multiplexer.</summary>
+    private bool TryDrainOutput()
+    {
+        var transform = _transform;
+        if (transform is null) return false;
+
+        bool providesSamples = (_outputInfo.Flags & MediaFoundation.OutputStreamProvidesSamples) != 0;
+
+        IMFSample? ownSample = null;
+        IMFMediaBuffer? ownBuffer = null;
+        IntPtr providedPointer = IntPtr.Zero;
+
+        var descriptor = new MftOutputDataBuffer { StreamId = _outputStreamId };
+
+        try
+        {
+            if (!providesSamples)
+            {
+                uint size = Math.Max(_outputInfo.Size, (uint)(_width * _height));
+                MediaFoundation.Check(MediaFoundation.MFCreateMemoryBuffer(size, out ownBuffer),
+                                      "Allocazione del buffer di uscita");
+                MediaFoundation.Check(MediaFoundation.MFCreateSample(out ownSample), "Creazione del campione di uscita");
+                ownSample.AddBuffer(ownBuffer);
+                providedPointer = Marshal.GetIUnknownForObject(ownSample);
+                descriptor.Sample = providedPointer;
+            }
+
+            int hr = transform.ProcessOutput(0, 1, ref descriptor, out _);
+
+            if (hr == MediaFoundation.ErrorTransformNeedMoreInput) return false;
+            if (hr == MediaFoundation.ErrorTransformStreamChange)
+            {
+                RenegotiateOutputType();
+                return true;
+            }
+            MediaFoundation.Check(hr, "Estrazione del pacchetto compresso");
+
+            IMFSample? produced = providesSamples
+                ? (descriptor.Sample != IntPtr.Zero ? (IMFSample)Marshal.GetObjectForIUnknown(descriptor.Sample) : null)
+                : ownSample;
+
+            if (produced is null) return false;
+
+            try
+            {
+                ConsumeSample(produced);
+            }
+            finally
+            {
+                if (providesSamples) Marshal.ReleaseComObject(produced);
+            }
+            return true;
+        }
+        finally
+        {
+            if (descriptor.Events != IntPtr.Zero) Marshal.Release(descriptor.Events);
+            if (providesSamples && descriptor.Sample != IntPtr.Zero) Marshal.Release(descriptor.Sample);
+            if (providedPointer != IntPtr.Zero) Marshal.Release(providedPointer);
+            if (ownSample is not null) Marshal.ReleaseComObject(ownSample);
+            if (ownBuffer is not null) Marshal.ReleaseComObject(ownBuffer);
+        }
+    }
+
+    private unsafe void ConsumeSample(IMFSample sample)
+    {
+        sample.ConvertToContiguousBuffer(out IMFMediaBuffer buffer);
+        try
+        {
+            uint length;
+            buffer.Lock(out IntPtr pointer, out _, out length);
+            try
+            {
+                if (length == 0) return;
+                if (_packetBuffer.Length < length) _packetBuffer = new byte[Math.Max(length, (uint)_packetBuffer.Length * 2)];
+                Marshal.Copy(pointer, _packetBuffer, 0, (int)length);
+            }
+            finally
+            {
+                buffer.Unlock();
+            }
+
+            uint duration = _pendingDurations.Count > 0
+                ? _pendingDurations.Dequeue()
+                : (uint)Math.Max(1, _settings.Timescale / Math.Max(1.0, _settings.FrameRate));
+
+            _muxer.WriteSample(_packetBuffer.AsSpan(0, (int)length), duration);
+            EncodedFrames++;
+        }
+        finally
+        {
+            Marshal.ReleaseComObject(buffer);
+        }
+    }
+
+    /// <summary>L'encoder può richiedere di riconfermare il tipo di uscita dopo la negoziazione iniziale.</summary>
+    private void RenegotiateOutputType()
+    {
+        var transform = _transform!;
+        if (transform.GetOutputAvailableType(_outputStreamId, 0, out IMFMediaType type) < 0) return;
+        try
+        {
+            transform.SetOutputType(_outputStreamId, type, 0);
+            transform.GetOutputStreamInfo(_outputStreamId, out _outputInfo);
+            ReadSequenceHeader();
+        }
+        finally
+        {
+            Marshal.ReleaseComObject(type);
+        }
+    }
+
+    // ------------------------------------------------------------------ utilità
+
+    private static void SetGuid(IMFMediaType type, Guid key, Guid value) => type.SetGUID(ref key, ref value);
+    private static void SetUInt32(IMFMediaType type, Guid key, uint value) => type.SetUINT32(ref key, value);
+    private static void SetUInt64(IMFMediaType type, Guid key, ulong value) => type.SetUINT64(ref key, value);
+
+    private void ReleaseTransform()
+    {
+        if (_events is not null && !ReferenceEquals(_events, _transform))
+        {
+            Marshal.ReleaseComObject(_events);
+        }
+        _events = null;
+
+        if (_transform is not null)
+        {
+            Marshal.ReleaseComObject(_transform);
+            _transform = null;
+        }
+    }
+
+    private void TryDeletePartialFile()
+    {
+        try
+        {
+            if (File.Exists(_settings.OutputPath)) File.Delete(_settings.OutputPath);
+        }
+        catch (IOException) { /* il file resta, verrà sovrascritto al tentativo successivo */ }
+        catch (UnauthorizedAccessException) { }
+    }
+
+    public void Dispose() => Finish();
+}
+
+/// <summary>Inizializzazione una tantum della piattaforma Media Foundation.</summary>
+internal static class MediaFoundationRuntime
+{
+    private static int _started;
+
+    public static void Startup()
+    {
+        if (Interlocked.Exchange(ref _started, 1) != 0) return;
+        int hr = MediaFoundation.MFStartup(MediaFoundation.Version, MediaFoundation.StartupLite);
+        if (hr < 0)
+        {
+            Interlocked.Exchange(ref _started, 0);
+            throw new VideoEncoderException($"Inizializzazione di Media Foundation non riuscita (HRESULT 0x{hr:X8}).");
+        }
+        AppDomain.CurrentDomain.ProcessExit += (_, _) => MediaFoundation.MFShutdown();
+    }
+}