Initial commit

Infra/Encoders/Crc32.cs

@@ -0,0 +1,33 @@
+namespace StitchATon2.Infra.Encoders;
+
+public static class Crc32
+{
+    private static readonly Lazy<uint[]> LazyTable = new(GenerateTable);
+    private static uint[] Table => LazyTable.Value;
+
+    public static uint Compute(Span<byte> buffer, uint initial = 0xFFFFFFFF)
+    {
+        uint crc = initial;
+        foreach (var b in buffer)
+        {
+            crc = Table[(crc ^ b) & 0xFF] ^ (crc >> 8);
+        }
+        return ~crc;
+    }
+
+    private static uint[] GenerateTable()
+    {
+        const uint poly = 0xEDB88320;
+        var table = new uint[256];
+        for (uint i = 0; i < 256; i++)
+        {
+            uint c = i;
+            for (int j = 0; j < 8; j++)
+            {
+                c = (c & 1) != 0 ? (poly ^ (c >> 1)) : (c >> 1);
+            }
+            table[i] = c;
+        }
+        return table;
+    }
+}

Infra/Encoders/PngStreamEncoder.cs

@@ -0,0 +1,143 @@
+using System.Buffers.Binary;
+using System.IO.Compression;
+
+namespace StitchATon2.Infra.Encoders;
+
+public class PngStreamEncoder : IDisposable, IAsyncDisposable
+{
+    private const int BufferSize = 8 * 1024;
+    private const int FlushThreshold = 1024;
+    
+    private readonly Stream _stream;
+    private readonly MemoryStream _memoryStream;
+    private readonly int _width;
+    private readonly int _height;
+
+    private readonly ZLibStream _zlibStream;
+    private bool _disposed;
+    private bool _shouldFlush;
+    
+    public PngStreamEncoder(Stream writableStream, int width, int height)
+    {
+        _stream = writableStream;
+        _width = width;
+        _height = height;
+        _memoryStream = new MemoryStream(BufferSize * 2);
+        _zlibStream = new ZLibStream(_memoryStream, CompressionLevel.Optimal, leaveOpen: true);
+        _memoryStream.SetLength(8);
+        _memoryStream.Position = 8;
+    }
+
+    ~PngStreamEncoder() => Dispose();
+
+    public async Task WriteHeader()
+    {
+        byte[] headerBytes = [
+            0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG Signature
+            0x00, 0x00, 0x00, 0x0D, // Length
+            
+            // IHDR chunk
+            0x49, 0x48, 0x44, 0x52, // IHDR
+            0x00, 0x00, 0x00, 0x00, // Reserve to write Width
+            0x00, 0x00, 0x00, 0x00, // Reserve to write Height
+            0x08, // Bit depth
+            0x02, // Color type
+            0x00, // Compression method
+            0x00, // Filter method
+            0x00, // Interlace method
+            0x00, 0x00, 0x00, 0x00, // Reserve to write CRC-32
+        ];
+        
+        BinaryPrimitives.WriteInt32BigEndian(headerBytes.AsSpan(16), _width);
+        BinaryPrimitives.WriteInt32BigEndian(headerBytes.AsSpan(20), _height);
+        var crc = Crc32.Compute(headerBytes.AsSpan(12, 17));
+        
+        BinaryPrimitives.WriteUInt32BigEndian(headerBytes.AsSpan(29), crc);
+        
+        await _stream.WriteAsync(headerBytes);
+    }
+
+    public async Task WriteData(Memory<byte> data)
+    {
+        _zlibStream.Write([0]);
+        
+        var dataSlice = data;
+        while (dataSlice.Length > FlushThreshold)
+        {
+            await _zlibStream.WriteAsync(dataSlice[..FlushThreshold]);
+            await _zlibStream.FlushAsync();
+            dataSlice = dataSlice[FlushThreshold..];
+            if(_memoryStream.Length >= BufferSize)
+                await Flush();
+        }
+        
+        if (dataSlice.Length > 0)
+        {
+            await _zlibStream.WriteAsync(dataSlice);
+            await _zlibStream.FlushAsync();
+            _shouldFlush = true;
+        }
+    }
+
+    private async Task Flush()
+    {
+        await _zlibStream.FlushAsync();
+        var dataSize = (int)(_memoryStream.Length - 8);
+
+        _memoryStream.Write("\0\0\0\0"u8);
+
+        _memoryStream.Position = 4;
+        _memoryStream.Write("IDAT"u8);
+
+        var buffer = _memoryStream.GetBuffer();
+        BinaryPrimitives.WriteInt32BigEndian(buffer, dataSize);
+
+        // write Crc
+        var crc = Crc32.Compute(buffer.AsSpan(4, dataSize + 4));
+        BinaryPrimitives.WriteUInt32BigEndian(buffer.AsSpan(dataSize + 8), crc);
+            
+        await _stream.WriteAsync(buffer.AsMemory(0, dataSize + 12));
+        _memoryStream.SetLength(8);
+        _memoryStream.Position = 8;
+        _shouldFlush = false;
+    }
+
+    public async ValueTask WriteEndOfFile()
+    {
+        if(_shouldFlush)
+            await Flush();
+        
+        var endChunk = new byte[] {
+            0x00, 0x00, 0x00, 0x00, // Length
+            0x49, 0x45, 0x4E, 0x44, // IEND
+            0xAE, 0x42, 0x60, 0x82, // Crc
+        };
+        
+        await _stream.WriteAsync(endChunk);
+        await DisposeAsync();
+    }
+
+    public void Dispose()
+    {
+        if (!_disposed)
+        {
+            _zlibStream.Dispose();
+            _memoryStream.Dispose();
+            _disposed = true;
+        }
+        
+        GC.SuppressFinalize(this);
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        if (!_disposed)
+        {
+            await _zlibStream.DisposeAsync();
+            await _memoryStream.DisposeAsync();
+            _disposed = true;
+        }
+        
+        GC.SuppressFinalize(this);
+    }
+}