NdsLegacyCrc32.cs

using System.Buffers.Binary;
 
namespace NdsForge;

internal static class NdsLegacyCrc32
{
    private static readonly uint[] Table = CreateTable();

    public static uint Calculate(ReadOnlySpan<byte> data) => ~Update(data, uint.MaxValue);

    public static void ReplacePreservingCrc(
        Span<byte> data,
        ref int logicalLength,
        int patchOffset,
        ReadOnlySpan<byte> patch,
        int? fixOffset = null)
    {
        int correctionOffset = fixOffset ?? checked(patchOffset + patch.Length);
        if (patchOffset < 0 || correctionOffset < patchOffset + patch.Length ||
            patch.Length > data.Length - patchOffset || 4 > data.Length - correctionOffset)
        {
            throw new ArgumentOutOfRangeException(nameof(patchOffset), "The legacy CRC patch or correction word is outside the image buffer.");
        }
 
        Span<byte> state = stackalloc byte[8];
        uint before = UpdateVirtual(data, patchOffset, correctionOffset - patchOffset, logicalLength, uint.MaxValue);
        BinaryPrimitives.WriteUInt32LittleEndian(state, before);
        patch.CopyTo(data[patchOffset..]);
        logicalLength = Math.Max(logicalLength, checked(patchOffset + patch.Length));
        uint after = UpdateVirtual(data, patchOffset, correctionOffset - patchOffset + 4, logicalLength, uint.MaxValue);
        BinaryPrimitives.WriteUInt32LittleEndian(state[4..], after);
        for (int index = 4; index >= 1; index--)
        {
            byte tableIndex = FindHighByte(state[index + 3], out uint tableValue);
            uint word = BinaryPrimitives.ReadUInt32LittleEndian(state[index..]);
            BinaryPrimitives.WriteUInt32LittleEndian(state[index..], word ^ tableValue);
            state[index - 1] ^= tableIndex;
        }
 
        state[..4].CopyTo(data[correctionOffset..]);
        logicalLength = Math.Max(logicalLength, checked(correctionOffset + 4));
    }

    private static uint Update(ReadOnlySpan<byte> data, uint state)
    {
        foreach (byte value in data)
        {
            state = (state >> 8) ^ Table[(state ^ value) & 0xFF];
        }
 
        return state;
    }

    private static uint UpdateVirtual(ReadOnlySpan<byte> data, int offset, int length, int logicalLength, uint state)
    {
        for (int index = 0; index < length; index++)
        {
            int position = offset + index;
            byte value = position < logicalLength ? data[position] : byte.MaxValue;
            state = (state >> 8) ^ Table[(state ^ value) & 0xFF];
        }
 
        return state;
    }

    private static byte FindHighByte(byte highByte, out uint value)
    {
        for (int index = 0; index < Table.Length; index++)
        {
            if ((byte)(Table[index] >> 24) == highByte)
            {
                value = Table[index];
                return (byte)index;
            }
        }
 
        throw new InvalidOperationException("The CRC32 reverse table is incomplete.");
    }

    private static uint[] CreateTable()
    {
        var table = new uint[256];
        for (uint index = 0; index < table.Length; index++)
        {
            uint value = index;
            for (int bit = 0; bit < 8; bit++)
            {
                value = (value >> 1) ^ ((value & 1) != 0 ? 0xEDB8_8320u : 0u);
            }
 
            table[index] = value;
        }
 
        return table;
    }
}