FFmpeg/libavcodec/vulkan/common.comp

/*
 * Copyright (c) 2024 Lynne <dev@lynne.ee>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

layout(buffer_reference, buffer_reference_align = 1) buffer u8buf {
    uint8_t v;
};

layout(buffer_reference, buffer_reference_align = 1) buffer u8vec2buf {
    u8vec2 v;
};

layout(buffer_reference, buffer_reference_align = 1) buffer u8vec4buf {
    u8vec4 v;
};

layout(buffer_reference, buffer_reference_align = 2) buffer u16buf {
    uint16_t v;
};

layout(buffer_reference, buffer_reference_align = 4) buffer u32buf {
    uint32_t v;
};

layout(buffer_reference, buffer_reference_align = 4) buffer u32vec2buf {
    u32vec2 v;
};

layout(buffer_reference, buffer_reference_align = 8) buffer u64buf {
    uint64_t v;
};

#define OFFBUF(type, b, l) \
    type(uint64_t(b) + uint64_t(l))

#define zero_extend(a, p) \
    ((a) & ((1 << (p)) - 1))

#define sign_extend(val, bits) \
    bitfieldExtract(val, 0, bits)

#define fold(diff, bits) \
    sign_extend(diff, bits)

#define mid_pred(a, b, c) \
    max(min((a), (b)), min(max((a), (b)), (c)))

/* TODO: optimize */
uint align(uint src, uint a)
{
    uint res = src % a;
    if (res == 0)
        return src;
    return src + a - res;
}

/* TODO: optimize */
uint64_t align64(uint64_t src, uint64_t a)
{
    uint64_t res = src % a;
    if (res == 0)
        return src;
    return src + a - res;
}

#define reverse4(src) \
    (pack32(unpack8(uint32_t(src)).wzyx))

u32vec2 reverse8(uint64_t src)
{
    u32vec2 tmp = unpack32(src);
    tmp.x = reverse4(tmp.x);
    tmp.y = reverse4(tmp.y);
    return tmp.yx;
}

#ifdef PB_32
#define BIT_BUF_TYPE uint32_t
#define BUF_TYPE u32buf
#define BUF_REVERSE(src) reverse4(src)
#define BUF_BITS uint8_t(32)
#define BUF_BYTES uint8_t(4)
#define BYTE_EXTRACT(src, byte_off) \
    (uint8_t(bitfieldExtract((src), ((byte_off) << 3), 8)))
#else
#define BIT_BUF_TYPE uint64_t
#define BUF_TYPE u32vec2buf
#define BUF_REVERSE(src) reverse8(src)
#define BUF_BITS uint8_t(64)
#define BUF_BYTES uint8_t(8)
#define BYTE_EXTRACT(src, byte_off) \
    (uint8_t(((src) >> ((byte_off) << 3)) & 0xFF))
#endif

struct PutBitContext {
    uint64_t buf_start;
    uint64_t buf;

    BIT_BUF_TYPE bit_buf;
    uint8_t bit_left;
};

void put_bits(inout PutBitContext pb, const uint32_t n, uint32_t value)
{
    if (n < pb.bit_left) {
        pb.bit_buf = (pb.bit_buf << n) | value;
        pb.bit_left -= uint8_t(n);
    } else {
        pb.bit_buf <<= pb.bit_left;
        pb.bit_buf |= (value >> (n - pb.bit_left));

#ifdef PB_UNALIGNED
        u8buf bs = u8buf(pb.buf);
        [[unroll]]
        for (uint8_t i = uint8_t(0); i < BUF_BYTES; i++)
            bs[i].v = BYTE_EXTRACT(pb.bit_buf, BUF_BYTES - uint8_t(1) - i);
#else
#ifdef DEBUG
        if ((pb.buf % BUF_BYTES) != 0)
            debugPrintfEXT("put_bits buffer is not aligned!");
#endif

        BUF_TYPE bs = BUF_TYPE(pb.buf);
        bs.v = BUF_REVERSE(pb.bit_buf);
#endif
        pb.buf = uint64_t(bs) + BUF_BYTES;

        pb.bit_left += BUF_BITS - uint8_t(n);
        pb.bit_buf = value;
    }
}

uint32_t flush_put_bits(inout PutBitContext pb)
{
    /* Align bits to MSBs */
    if (pb.bit_left < BUF_BITS)
        pb.bit_buf <<= pb.bit_left;

    if (pb.bit_left < BUF_BITS) {
        uint to_write = ((BUF_BITS - pb.bit_left - 1) >> 3) + 1;

        u8buf bs = u8buf(pb.buf);
        for (int i = 0; i < to_write; i++)
            bs[i].v = BYTE_EXTRACT(pb.bit_buf, BUF_BYTES - uint8_t(1) - i);
        pb.buf = uint64_t(bs) + to_write;
    }

    pb.bit_left = BUF_BITS;
    pb.bit_buf = 0x0;

    return uint32_t(pb.buf - pb.buf_start);
}

void init_put_bits(out PutBitContext pb, u8buf data, uint64_t len)
{
    pb.buf_start = uint64_t(data);
    pb.buf = uint64_t(data);

    pb.bit_buf = 0;
    pb.bit_left = BUF_BITS;
}

uint64_t put_bits_count(in PutBitContext pb)
{
    return (pb.buf - pb.buf_start)*8 + BUF_BITS - pb.bit_left;
}

uint32_t put_bytes_count(in PutBitContext pb)
{
    uint64_t num_bytes = (pb.buf - pb.buf_start) + ((BUF_BITS - pb.bit_left) >> 3);
    return uint32_t(num_bytes);
}

struct GetBitContext {
    uint64_t buf_start;
    uint64_t buf;
    uint64_t buf_end;

    uint64_t bits;
    uint bits_valid;
    uint size_in_bits;
};

#define LOAD64()                                       \
    {                                                  \
        u8vec4buf ptr = u8vec4buf(gb.buf);             \
        uint32_t rf1 = pack32((ptr[0].v).wzyx);        \
        uint32_t rf2 = pack32((ptr[1].v).wzyx);        \
        gb.buf += 8;                                   \
        gb.bits = uint64_t(rf1) << 32 | uint64_t(rf2); \
        gb.bits_valid = 64;                            \
    }

#define RELOAD32()                                                \
    {                                                             \
        u8vec4buf ptr = u8vec4buf(gb.buf);                        \
        uint32_t rf = pack32((ptr[0].v).wzyx);                    \
        gb.buf += 4;                                              \
        gb.bits = uint64_t(rf) << (32 - gb.bits_valid) | gb.bits; \
        gb.bits_valid += 32;                                      \
    }

void init_get_bits(inout GetBitContext gb, u8buf data, uint64_t len)
{
    gb.buf = gb.buf_start = uint64_t(data);
    gb.buf_end = uint64_t(data) + len;
    gb.size_in_bits = uint(len) * 8;

    /* Preload */
    LOAD64()
}

bool get_bit(inout GetBitContext gb)
{
    if (gb.bits_valid == 0)
        LOAD64()

    bool val = bool(gb.bits >> (64 - 1));
    gb.bits <<= 1;
    gb.bits_valid--;
    return val;
}

uint get_bits(inout GetBitContext gb, uint n)
{
    if (n == 0)
        return 0;

    if (n > gb.bits_valid)
        RELOAD32()

    uint val = uint(gb.bits >> (64 - n));
    gb.bits <<= n;
    gb.bits_valid -= n;
    return val;
}

uint show_bits(inout GetBitContext gb, uint n)
{
    if (n > gb.bits_valid)
        RELOAD32()

    return uint(gb.bits >> (64 - n));
}

void skip_bits(inout GetBitContext gb, uint n)
{
    if (n > gb.bits_valid)
        RELOAD32()

    gb.bits <<= n;
    gb.bits_valid -= n;
}

uint tell_bits(in GetBitContext gb)
{
    return uint(gb.buf - gb.buf_start) * 8 - gb.bits_valid;
}

uint left_bits(in GetBitContext gb)
{
    return gb.size_in_bits - uint(gb.buf - gb.buf_start) * 8 + gb.bits_valid;
}