Support for JPEG XL (JXL) images - #3153

Is size limited to some maximum value?
If so, there should be an assert here to make it clear.

For the stackalloc it's better to use a constant value, then slice it if needed. Thus produces most of the time better code. E.g. stackalloc uint[128].Slice(0, size).

Although neither the reference implementation nor this implementation explicitly bounds size here, it is constrained by the JPEG XL bitstream syntax. size is derived from the transform strategy and can only take one of the specification-defined coefficient counts (64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, or 65536). The maximum possible value is therefore 65536.

I'll add an assert.

I do not think that this custom Vector512 path belongs here yet. It adds unsafe memory access, architecture-dependent behavior, and a hidden padding requirement.
As I read it the MTF table contains only 256 entries. A simple overlapping copy is easier to prove correct and lets the runtime select an appropriate implementation.

public static void MoveToFront(Span<byte> values, byte index)
{
    byte value = values[index];

    // CopyTo supports overlapping source and destination regions.
    values[..index].CopyTo(values[1..]);
    values[0] = value;
}

InverseMoveToFrontTransform can use the span length as its input length. This removes the separate vLength contract.
The method also needs only a 256-byte table after removal of the custom vector path:

public static void InverseMoveToFrontTransform(Span<byte> values)
{
    Span<byte> table = stackalloc byte[256];

    for (int i = 0; i < table.Length; i++)
    {
        table[i] = (byte)i;
    }

    for (int i = 0; i < values.Length; i++)
    {
        byte index = values[i];
        byte value = table[index];
        values[i] = value;

        if (index != 0)
        {
            // CopyTo handles the overlap and shifts the preceding entries.
            table[..index].CopyTo(table[1..]);
            table[0] = value;
        }
    }
}

If the source buffer contains extra data, the caller can pass the required slice:
JxlInverseMtf.InverseMoveToFrontTransform(values[..valueCount]);
This version has no unsafe access, hidden padding, or architecture-specific behaviour.