Play clips as one continuous stream to remove chunk-boundary stalls (#46)

Author: danielchalmers

SentryReplay.Data/Playback/ClipMediaSource.cs

@@ -0,0 +1,18 @@
+namespace SentryReplay;
+
+/// <summary>
+/// Per-camera ffconcat playlists covering an entire clip, so playback can flow continuously
+/// across chunk boundaries without reopening media.
+/// </summary>
+public sealed record class ClipMediaSource(
+    TimeSpan Duration,
+    IReadOnlyList<TimeSpan> ChunkStarts,
+    IReadOnlyDictionary<string, string> CameraPlaylistPaths);
+
+/// <summary>
+/// Builds a <see cref="ClipMediaSource"/> for a clip.
+/// </summary>
+public interface IClipMediaSourceBuilder
+{
+    ClipMediaSource Build(CamClip clip);
+}

SentryReplay.Data/Playback/FfconcatMediaSourceBuilder.cs

@@ -0,0 +1,116 @@
+using System.Globalization;
+using System.Text;
+using System.Text.RegularExpressions;
+using Serilog;
+
+namespace SentryReplay;
+
+/// <summary>
+/// Builds per-camera ffconcat playlists on disk so a whole clip can be opened by FFmpeg's
+/// concat demuxer in one go.
+/// </summary>
+public partial class FfconcatMediaSourceBuilder : IClipMediaSourceBuilder
+{
+    private const double FallbackChunkSeconds = 60;
+
+    private static readonly string PlaylistDirectory =
+        Path.Combine(Path.GetTempPath(), "SentryReplay", "playlists");
+
+    public ClipMediaSource Build(CamClip clip)
+    {
+        ArgumentNullException.ThrowIfNull(clip);
+
+        Directory.CreateDirectory(PlaylistDirectory);
+
+        var chunkDurations = clip.Chunks
+            .Select(chunk => ProbeChunkDuration(chunk))
+            .ToList();
+
+        var chunkStarts = new List<TimeSpan>(chunkDurations.Count);
+        var runningStart = TimeSpan.Zero;
+        foreach (var chunkDuration in chunkDurations)
+        {
+            chunkStarts.Add(runningStart);
+            runningStart += chunkDuration;
+        }
+
+        var playlistPaths = new Dictionary<string, string>();
+        var clipToken = SanitizeForFileName(clip.Name);
+
+        foreach (var camera in CameraNames.All)
+        {
+            if (clip.Chunks.Count == 0 || !clip.Chunks[0].Files.ContainsKey(camera))
+            {
+                continue;
+            }
+
+            var entries = new List<(string FilePath, TimeSpan Duration)>();
+            for (var i = 0; i < clip.Chunks.Count; i++)
+            {
+                if (!clip.Chunks[i].Files.TryGetValue(camera, out var file))
+                {
+                    break;
+                }
+
+                entries.Add((file.FullPath, chunkDurations[i]));
+            }
+
+            var playlistPath = Path.Combine(PlaylistDirectory, $"{clipToken}-{camera}.ffconcat");
+            WritePlaylist(playlistPath, entries);
+            playlistPaths[camera] = playlistPath;
+        }
+
+        var duration = chunkStarts.Count == 0
+            ? TimeSpan.Zero
+            : chunkStarts[^1] + chunkDurations[^1];
+
+        return new ClipMediaSource(duration, chunkStarts, playlistPaths);
+    }
+
+    private static TimeSpan ProbeChunkDuration(CamChunk chunk)
+    {
+        if (chunk.Files.TryGetValue(CameraNames.Front, out var frontFile))
+        {
+            var probed = Mp4DurationReader.TryReadDuration(frontFile.FullPath);
+            if (probed is { } duration && duration > TimeSpan.Zero)
+            {
+                return duration;
+            }
+
+            Log.Debug(
+                "Falling back to estimated chunk duration. ChunkTimestamp={ChunkTimestamp}; File={File}",
+                chunk.Timestamp,
+                frontFile.FullPath);
+        }
+
+        return TimeSpan.FromSeconds(FallbackChunkSeconds);
+    }
+
+    private static void WritePlaylist(string path, IReadOnlyList<(string FilePath, TimeSpan Duration)> entries)
+    {
+        var builder = new StringBuilder();
+        builder.AppendLine("ffconcat version 1.0");
+
+        foreach (var (filePath, duration) in entries)
+        {
+            builder.Append("file '").Append(EscapeConcatPath(filePath)).AppendLine("'");
+            builder.Append("duration ").AppendLine(duration.TotalSeconds.ToString("F6", CultureInfo.InvariantCulture));
+        }
+
+        File.WriteAllText(path, builder.ToString());
+    }
+
+    private static string EscapeConcatPath(string path)
+    {
+        return path.Replace('\\', '/').Replace("'", "'\\''");
+    }
+
+    private static string SanitizeForFileName(string name)
+    {
+        var sanitized = InvalidFileNameCharsRegex().Replace(name ?? string.Empty, "_");
+        return string.IsNullOrEmpty(sanitized) ? "clip" : sanitized;
+    }
+
+    [GeneratedRegex(@"[^a-zA-Z0-9_-]+")]
+    private static partial Regex InvalidFileNameCharsRegex();
+}

SentryReplay.Data/Playback/Mp4DurationReader.cs

@@ -0,0 +1,149 @@
+using System.Buffers.Binary;
+
+namespace SentryReplay;
+
+/// <summary>
+/// Reads an mp4 file's duration by parsing its box structure, without decoding any media.
+/// </summary>
+public static class Mp4DurationReader
+{
+    private const int BoxHeaderSize = 8;
+    private const int LargeSizeFieldSize = 8;
+
+    /// <summary>
+    /// Returns the duration encoded in the file's "moov/mvhd" box, or null if it cannot be
+    /// determined (missing boxes, malformed data, or any IO error).
+    /// </summary>
+    public static TimeSpan? TryReadDuration(string path)
+    {
+        try
+        {
+            using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            var moovBox = FindBox(stream, "moov", stream.Length);
+            if (moovBox is null)
+                return null;
+
+            var (moovStart, moovEnd) = moovBox.Value;
+            var mvhdBox = FindBox(stream, "mvhd", moovEnd, moovStart);
+            if (mvhdBox is null)
+                return null;
+
+            var (mvhdStart, mvhdEnd) = mvhdBox.Value;
+            return ReadMvhdDuration(stream, mvhdStart, mvhdEnd);
+        }
+        catch (IOException)
+        {
+            return null;
+        }
+        catch (UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Scans sibling boxes starting at <paramref name="start"/> until <paramref name="end"/> for
+    /// one matching <paramref name="type"/>, returning its (contentStart, contentEnd) range.
+    /// </summary>
+    private static (long ContentStart, long ContentEnd)? FindBox(FileStream stream, string type, long end, long start = 0)
+    {
+        Span<byte> header = stackalloc byte[BoxHeaderSize];
+        Span<byte> largeSize = stackalloc byte[LargeSizeFieldSize];
+        var position = start;
+
+        while (position + BoxHeaderSize <= end)
+        {
+            stream.Position = position;
+            if (!ReadFully(stream, header))
+                return null;
+
+            var size = (long)BinaryPrimitives.ReadUInt32BigEndian(header);
+            var boxType = System.Text.Encoding.ASCII.GetString(header[4..8]);
+            var headerSize = BoxHeaderSize;
+
+            if (size == 1)
+            {
+                if (!ReadFully(stream, largeSize))
+                    return null;
+
+                size = (long)BinaryPrimitives.ReadUInt64BigEndian(largeSize);
+                headerSize += LargeSizeFieldSize;
+            }
+            else if (size == 0)
+            {
+                size = end - position;
+            }
+
+            if (size < headerSize)
+                return null;
+
+            var contentStart = position + headerSize;
+            var contentEnd = position + size;
+
+            if (boxType == type)
+                return (contentStart, contentEnd);
+
+            position += size;
+        }
+
+        return null;
+    }
+
+    private static TimeSpan? ReadMvhdDuration(FileStream stream, long contentStart, long contentEnd)
+    {
+        // version (1 byte) + flags (3 bytes)
+        if (contentEnd - contentStart < 4)
+            return null;
+
+        stream.Position = contentStart;
+        var version = stream.ReadByte();
+        if (version < 0)
+            return null;
+
+        stream.Position = contentStart + 4;
+
+        uint timescale;
+        ulong duration;
+
+        if (version == 1)
+        {
+            // 8 (ctime) + 8 (mtime) = 16 bytes to skip, then timescale (4) + duration (8)
+            Span<byte> buffer = stackalloc byte[16 + 4 + 8];
+            if (contentEnd - stream.Position < buffer.Length || !ReadFully(stream, buffer))
+                return null;
+
+            timescale = BinaryPrimitives.ReadUInt32BigEndian(buffer[16..20]);
+            duration = BinaryPrimitives.ReadUInt64BigEndian(buffer[20..28]);
+        }
+        else
+        {
+            // 4 (ctime) + 4 (mtime) = 8 bytes to skip, then timescale (4) + duration (4)
+            Span<byte> buffer = stackalloc byte[8 + 4 + 4];
+            if (contentEnd - stream.Position < buffer.Length || !ReadFully(stream, buffer))
+                return null;
+
+            timescale = BinaryPrimitives.ReadUInt32BigEndian(buffer[8..12]);
+            duration = BinaryPrimitives.ReadUInt32BigEndian(buffer[12..16]);
+        }
+
+        if (timescale == 0)
+            return null;
+
+        return TimeSpan.FromSeconds((double)duration / timescale);
+    }
+
+    private static bool ReadFully(FileStream stream, Span<byte> buffer)
+    {
+        var totalRead = 0;
+        while (totalRead < buffer.Length)
+        {
+            var read = stream.Read(buffer[totalRead..]);
+            if (read == 0)
+                return false;
+
+            totalRead += read;
+        }
+
+        return true;
+    }
+}