lzokay.hpp

#pragma once
#include <cstddef>
#include <cstdint>
#include <memory>

//origin is at https://github.com/jackoalan/lzokay

namespace lzokay
{

    enum class EResult
    {
        LookbehindOverrun = -4,
        OutputOverrun = -3,
        InputOverrun = -2,
        Error = -1,
        Success = 0,
        InputNotConsumed = 1,
    };

    class DictBase
    {
    protected:
        static constexpr uint32_t HashSize = 0x4000;
        static constexpr uint32_t MaxDist = 0xbfff;
        static constexpr uint32_t MaxMatchLen = 0x800;
        static constexpr uint32_t BufSize = MaxDist + MaxMatchLen;

        /* List encoding of previous 3-byte data matches */
        struct Match3
        {
            uint16_t head[HashSize]; /* key -> chain-head-pos */
            uint16_t chain_sz[HashSize]; /* key -> chain-size */
            uint16_t chain[BufSize]; /* chain-pos -> next-chain-pos */
            uint16_t best_len[BufSize]; /* chain-pos -> best-match-length */
        };
        /* Encoding of 2-byte data matches */
        struct Match2
        {
            uint16_t head[1 << 16]; /* 2-byte-data -> head-pos */
        };

        struct Data
        {
            Match3 match3;
            Match2 match2;

            /* Circular buffer caching enough data to access the maximum lookback
             * distance of 48K + maximum match length of 2K. An additional 2K is
             * allocated so the start of the buffer may be replicated at the end,
             * therefore providing efficient circular access.
             */
            uint8_t buffer[BufSize + MaxMatchLen];
        };
        using storage_type = Data;
        storage_type* _storage;
        DictBase() = default;
        friend struct State;
        friend EResult compress(const uint8_t* src, std::size_t src_size,
                                uint8_t* dst, std::size_t& dst_size, DictBase& dict);
    };
    template <template<typename> class _Alloc = std::allocator>
    class Dict : public DictBase
    {
        _Alloc<DictBase::storage_type> _allocator;
    public:
        Dict()
        {
            _storage = _allocator.allocate(1);
        }
        ~Dict()
        {
            _allocator.deallocate(_storage, 1);
        }
    };

    EResult decompress(const uint8_t* src, std::size_t src_size,
                       uint8_t* dst, std::size_t dst_size,
                       std::size_t& out_size);
    EResult compress(const uint8_t* src, std::size_t src_size,
                     uint8_t* dst, std::size_t dst_size,
                     std::size_t& out_size, DictBase& dict);
    inline EResult compress(const uint8_t* src, std::size_t src_size,
                            uint8_t* dst, std::size_t dst_size,
                            std::size_t& out_size)
    {
        Dict<> dict;
        return compress(src, src_size, dst, dst_size, out_size, dict);
    }

    constexpr std::size_t compress_worst_size(std::size_t s)
    {
        return s + s / 16 + 64 + 3;
    }

}