Titano/Titano/Diagnostics/Mp4Inspector.cs

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,
        string? SampleProblem);

    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>();
        var sampleSizes = new List<uint>();
        long firstChunkOffset = -1;
        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? sampleProblem = VerifySampleData(stream, sampleSizes, firstChunkOffset);
        if (sampleProblem is not null) problems.Add(sampleProblem);

        string summary = problems.Count == 0
            ? "struttura conforme"
            : string.Join(", ", problems);

        return new Report(problems.Count == 0, summary, sampleCount, width, height,
                          timescale, mediaDuration, configBytes, boxes, sampleProblem);

        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);
                        for (int s = 0; s < sampleCount && s < 100_000; s++) sampleSizes.Add(ReadUInt32(file));
                        break;
                    }
                    case "co64":
                        file.Position = payload + 8;                 // versione/flag + entry_count
                        firstChunkOffset = (long)ReadUInt64(file);
                        break;
                    case "stco":
                        file.Position = payload + 8;
                        firstChunkOffset = 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 ulong ReadUInt64(FileStream file)
        {
            Span<byte> buffer = stackalloc byte[8];
            return file.Read(buffer) == 8 ? BinaryPrimitives.ReadUInt64BigEndian(buffer) : 0;
        }

        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;
        }
    }

    /// <summary>
    /// Verifica che ogni campione sia una successione esatta di NAL con lunghezza prefissata.
    /// Un prefisso nullo o che sborda dal campione significa dati corrotti dal multiplexer:
    /// il contenitore resterebbe formalmente valido ma il flusso sarebbe indecodificabile.
    /// </summary>
    private static string? VerifySampleData(FileStream stream, List<uint> sizes, long firstChunkOffset)
    {
        if (sizes.Count == 0 || firstChunkOffset < 0) return null;

        long position = firstChunkOffset;
        Span<byte> prefix = stackalloc byte[4];

        for (int index = 0; index < sizes.Count; index++)
        {
            long end = position + sizes[index];
            if (end > stream.Length) return $"campione {index + 1} oltre la fine del file";

            long cursor = position;
            while (cursor + 4 <= end)
            {
                stream.Position = cursor;
                if (stream.Read(prefix) != 4) return $"campione {index + 1} troncato";

                uint length = BinaryPrimitives.ReadUInt32BigEndian(prefix);
                if (length == 0) return $"campione {index + 1}: NAL di lunghezza nulla";
                if (cursor + 4 + length > end) return $"campione {index + 1}: NAL che sborda dal campione";
                cursor += 4 + length;
            }

            if (cursor != end) return $"campione {index + 1}: {end - cursor} byte residui non allineati";
            position = end;
        }
        return null;
    }
}