using System.Text;
using Titano.Testing;
namespace Titano.Core.Tests.Video;
/// Minimal GIF89a decoder used to verify GifEncoder output (composition with disposal 0–3).
internal sealed class GifTestDecoder
{
public sealed record Frame(byte[] Canvas, int DelayCs, int Left, int Top, int Width, int Height, int Disposal, bool Transparent, bool LocalTable);
public int Width { get; private set; }
public int Height { get; private set; }
public bool GlobalTable { get; private set; }
public int? LoopCount { get; private set; }
public List Frames { get; } = [];
public static GifTestDecoder Decode(byte[] data)
{
var gif = new GifTestDecoder();
Assert.Equal("GIF89a", Encoding.ASCII.GetString(data, 0, 6));
gif.Width = data[6] | data[7] << 8;
gif.Height = data[8] | data[9] << 8;
var pos = 13;
byte[]? global = null;
if ((data[10] & 0x80) != 0)
{
gif.GlobalTable = true;
var size = 3 << ((data[10] & 7) + 1);
global = data.AsSpan(pos, size).ToArray();
pos += size;
}
var canvas = new byte[gif.Width * gif.Height * 4];
int delay = 0, disposal = 0, transparentIndex = -1;
while (true)
{
var block = data[pos++];
if (block == 0x3B) break;
if (block == 0x21)
{
var label = data[pos++];
if (label == 0xF9)
{
Assert.Equal((byte)4, data[pos]);
disposal = (data[pos + 1] >> 2) & 7;
transparentIndex = (data[pos + 1] & 1) != 0 ? data[pos + 4] : -1;
delay = data[pos + 2] | data[pos + 3] << 8;
pos += 6;
}
else if (label == 0xFF && Encoding.ASCII.GetString(data, pos + 1, 11) == "NETSCAPE2.0")
{
gif.LoopCount = data[pos + 14] | data[pos + 15] << 8;
pos += 12;
pos = SkipSubBlocks(data, pos);
}
else
{
pos = SkipSubBlocks(data, pos);
}
continue;
}
Assert.Equal((byte)0x2C, block);
var left = data[pos] | data[pos + 1] << 8;
var top = data[pos + 2] | data[pos + 3] << 8;
var w = data[pos + 4] | data[pos + 5] << 8;
var h = data[pos + 6] | data[pos + 7] << 8;
var packed = data[pos + 8];
pos += 9;
var table = global;
var local = (packed & 0x80) != 0;
if (local)
{
var size = 3 << ((packed & 7) + 1);
table = data.AsSpan(pos, size).ToArray();
pos += size;
}
Assert.False((packed & 0x40) != 0, "interlaced frames are not produced");
Assert.True(left + w <= gif.Width && top + h <= gif.Height, "frame inside the logical screen");
var minCode = data[pos++];
using var lzw = new MemoryStream();
while (data[pos] != 0)
{
lzw.Write(data, pos + 1, data[pos]);
pos += data[pos] + 1;
}
pos++;
var indices = DecodeLzw(lzw.ToArray(), minCode, w * h);
var saved = disposal == 3 ? (byte[])canvas.Clone() : null;
for (var y = 0; y < h; y++)
{
for (var x = 0; x < w; x++)
{
var index = indices[y * w + x];
if (index == transparentIndex) continue;
var o = ((top + y) * gif.Width + left + x) * 4;
canvas[o] = table![index * 3];
canvas[o + 1] = table[index * 3 + 1];
canvas[o + 2] = table[index * 3 + 2];
canvas[o + 3] = 255;
}
}
gif.Frames.Add(new Frame((byte[])canvas.Clone(), delay, left, top, w, h, disposal, transparentIndex >= 0, local));
if (disposal == 2)
{
for (var y = 0; y < h; y++) canvas.AsSpan(((top + y) * gif.Width + left) * 4, w * 4).Clear();
}
else if (disposal == 3)
{
canvas = saved!;
}
delay = 0;
disposal = 0;
transparentIndex = -1;
}
return gif;
}
private static int SkipSubBlocks(byte[] data, int pos)
{
while (data[pos] != 0) pos += data[pos] + 1;
return pos + 1;
}
private static byte[] DecodeLzw(byte[] data, int minCode, int pixels)
{
var output = new List(pixels);
var prefix = new short[4096];
var suffix = new byte[4096];
var stack = new byte[4097];
var clear = 1 << minCode;
var end = clear + 1;
var codeSize = minCode + 1;
var next = end + 1;
var old = -1;
long bits = 0;
var count = 0;
var pos = 0;
while (true)
{
while (count < codeSize && pos < data.Length)
{
bits |= (long)data[pos++] << count;
count += 8;
}
Assert.True(count >= codeSize, "LZW data ended before the end code");
var code = (int)(bits & ((1 << codeSize) - 1));
bits >>= codeSize;
count -= codeSize;
if (code == clear)
{
codeSize = minCode + 1;
next = end + 1;
old = -1;
continue;
}
if (code == end) break;
if (old == -1)
{
Assert.True(code < clear, "first code after clear is a literal");
output.Add((byte)code);
old = code;
continue;
}
Assert.True(code <= next, $"LZW code {code} beyond the table ({next})");
var depth = 0;
var c = code;
if (code == next)
{
stack[depth++] = First(old, prefix, suffix, clear);
c = old;
}
while (c >= clear)
{
stack[depth++] = suffix[c];
c = prefix[c];
}
stack[depth++] = (byte)c;
var firstByte = (byte)c;
for (var i = depth - 1; i >= 0; i--) output.Add(stack[i]);
if (next < 4096)
{
prefix[next] = (short)old;
suffix[next] = firstByte;
next++;
if (next == 1 << codeSize && codeSize < 12) codeSize++;
}
old = code;
}
Assert.Equal(pixels, output.Count);
return [.. output];
}
private static byte First(int code, short[] prefix, byte[] suffix, int clear)
{
while (code >= clear) code = prefix[code];
return (byte)code;
}
}