From 12b971746cd18a55e637b63d02ccf23e85c86e40 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 Jul 2024 22:42:29 +0100 Subject: [PATCH] `vendor:compress/lz4` Bindings to lz4 library --- vendor/compress/lz4/lib/liblz4_static.lib | Bin 0 -> 239998 bytes vendor/compress/lz4/lz4.odin | 541 +++++++++++++ vendor/compress/lz4/src/lz4.h | 884 ++++++++++++++++++++++ vendor/compress/lz4/src/lz4frame.h | 751 ++++++++++++++++++ vendor/compress/lz4/src/lz4hc.h | 414 ++++++++++ 5 files changed, 2590 insertions(+) create mode 100644 vendor/compress/lz4/lib/liblz4_static.lib create mode 100644 vendor/compress/lz4/lz4.odin create mode 100644 vendor/compress/lz4/src/lz4.h create mode 100644 vendor/compress/lz4/src/lz4frame.h create mode 100644 vendor/compress/lz4/src/lz4hc.h diff --git a/vendor/compress/lz4/lib/liblz4_static.lib b/vendor/compress/lz4/lib/liblz4_static.lib new file mode 100644 index 0000000000000000000000000000000000000000..dc7610303da2eedc8bb0df37b3686d479b097ed6 GIT binary patch literal 239998 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 PCOO97^^CEjeER=iP>pp! literal 0 HcmV?d00001 diff --git a/vendor/compress/lz4/lz4.odin b/vendor/compress/lz4/lz4.odin new file mode 100644 index 000000000..62027d9d9 --- /dev/null +++ b/vendor/compress/lz4/lz4.odin @@ -0,0 +1,541 @@ +package vendor_compress_lz4 + +when ODIN_OS == .Windows { + foreign import lib "lib/libz4_static.lib" +} + +import "core:c" + +VERSION_MAJOR :: 1 /* for breaking interface changes */ +VERSION_MINOR :: 10 /* for new (non-breaking) interface capabilities */ +VERSION_RELEASE :: 0 /* for tweaks, bug-fixes, or development */ + +VERSION_NUMBER :: VERSION_MAJOR *100*100 + VERSION_MINOR *100 + VERSION_RELEASE + +MEMORY_USAGE_MIN :: 10 +MEMORY_USAGE_DEFAULT :: 14 +MEMORY_USAGE_MAX :: 20 + +MEMORY_USAGE :: MEMORY_USAGE_DEFAULT + +MAX_INPUT_SIZE :: 0x7E000000 /* 2_113_929_216 bytes */ + + +COMPRESSBOUND :: #force_inline proc "c" (isize: c.int) -> c.int { + return u32(isize) > MAX_INPUT_SIZE ? 0 : isize + (isize/255) + 16 +} + + +DECODER_RING_BUFFER_SIZE :: #force_inline proc "c" (maxBlockSize: c.int) -> c.int { + return 65536 + 14 + maxBlockSize /* for static allocation; maxBlockSize presumed valid */ +} + +@(default_calling_convention="c", link_prefix="LZ4_") +foreign lib { + versionNumber :: proc() -> c.int --- /**< library version number; useful to check dll version; requires v1.3.0+ */ + versionString :: proc() -> cstring --- /**< library version string; useful to check dll version; requires v1.7.5+ */ + + /*! LZ4_compress_default() : + * Compresses 'srcSize' bytes from buffer 'src' + * into already allocated 'dst' buffer of size 'dstCapacity'. + * Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize). + * It also runs faster, so it's a recommended setting. + * If the function cannot compress 'src' into a more limited 'dst' budget, + * compression stops *immediately*, and the function result is zero. + * In which case, 'dst' content is undefined (invalid). + * srcSize : max supported value is LZ4_MAX_INPUT_SIZE. + * dstCapacity : size of buffer 'dst' (which must be already allocated) + * @return : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity) + * or 0 if compression fails + * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer). + */ + compress_default :: proc(src, dst: [^]byte, srcSize, dstCapacity: c.int) -> c.int --- + + /*! LZ4_decompress_safe() : + * @compressedSize : is the exact complete size of the compressed block. + * @dstCapacity : is the size of destination buffer (which must be already allocated), + * presumed an upper bound of decompressed size. + * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity) + * If destination buffer is not large enough, decoding will stop and output an error code (negative value). + * If the source stream is detected malformed, the function will stop decoding and return a negative result. + * Note 1 : This function is protected against malicious data packets : + * it will never writes outside 'dst' buffer, nor read outside 'source' buffer, + * even if the compressed block is maliciously modified to order the decoder to do these actions. + * In such case, the decoder stops immediately, and considers the compressed block malformed. + * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them. + * The implementation is free to send / store / derive this information in whichever way is most beneficial. + * If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead. + */ + decompress_safe :: proc(src, dst: [^]byte, compressedSize, dstCapacity: c.int) -> c.int --- + + + /*! LZ4_compressBound() : + Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible) + This function is primarily useful for memory allocation purposes (destination buffer size). + Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example). + Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize) + inputSize : max supported value is LZ4_MAX_INPUT_SIZE + return : maximum output size in a "worst case" scenario + or 0, if input size is incorrect (too large or negative) + */ + compressBound :: proc(inputSize: c.int) -> c.int --- + + /*! LZ4_compress_fast() : + Same as LZ4_compress_default(), but allows selection of "acceleration" factor. + The larger the acceleration value, the faster the algorithm, but also the lesser the compression. + It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed. + An acceleration value of "1" is the same as regular LZ4_compress_default() + Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c). + Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c). + */ + compress_fast :: proc(src, dst: [^]byte, srcSize, dstCapacity: c.int, acceleration: c.int) -> c.int --- + + + /*! LZ4_compress_fast_extState() : + * Same as LZ4_compress_fast(), using an externally allocated memory space for its state. + * Use LZ4_sizeofState() to know how much memory must be allocated, + * and allocate it on 8-bytes boundaries (using `malloc()` typically). + * Then, provide this buffer as `void* state` to compression function. + */ + sizeofState :: proc() -> c.int --- + compress_fast_extState :: proc (state: rawptr, src, dst: [^]byte, srcSize, dstCapacity: c.int, acceleration: c.int) -> c.int --- + + + /*! LZ4_compress_destSize() : + * Reverse the logic : compresses as much data as possible from 'src' buffer + * into already allocated buffer 'dst', of size >= 'dstCapacity'. + * This function either compresses the entire 'src' content into 'dst' if it's large enough, + * or fill 'dst' buffer completely with as much data as possible from 'src'. + * note: acceleration parameter is fixed to "default". + * + * *srcSizePtr : in+out parameter. Initially contains size of input. + * Will be modified to indicate how many bytes where read from 'src' to fill 'dst'. + * New value is necessarily <= input value. + * @return : Nb bytes written into 'dst' (necessarily <= dstCapacity) + * or 0 if compression fails. + * + * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed in v1.9.2+): + * the produced compressed content could, in specific circumstances, + * require to be decompressed into a destination buffer larger + * by at least 1 byte than the content to decompress. + * If an application uses `LZ4_compress_destSize()`, + * it's highly recommended to update liblz4 to v1.9.2 or better. + * If this can't be done or ensured, + * the receiving decompression function should provide + * a dstCapacity which is > decompressedSize, by at least 1 byte. + * See https://github.com/lz4/lz4/issues/859 for details + */ + compress_destSize :: proc(src, dst: [^]byte, srcSizePtr: ^c.int, targetDstSize: c.int) -> c.int --- + + + /*! LZ4_decompress_safe_partial() : + * Decompress an LZ4 compressed block, of size 'srcSize' at position 'src', + * into destination buffer 'dst' of size 'dstCapacity'. + * Up to 'targetOutputSize' bytes will be decoded. + * The function stops decoding on reaching this objective. + * This can be useful to boost performance + * whenever only the beginning of a block is required. + * + * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize) + * If source stream is detected malformed, function returns a negative result. + * + * Note 1 : @return can be < targetOutputSize, if compressed block contains less data. + * + * Note 2 : targetOutputSize must be <= dstCapacity + * + * Note 3 : this function effectively stops decoding on reaching targetOutputSize, + * so dstCapacity is kind of redundant. + * This is because in older versions of this function, + * decoding operation would still write complete sequences. + * Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize, + * it could write more bytes, though only up to dstCapacity. + * Some "margin" used to be required for this operation to work properly. + * Thankfully, this is no longer necessary. + * The function nonetheless keeps the same signature, in an effort to preserve API compatibility. + * + * Note 4 : If srcSize is the exact size of the block, + * then targetOutputSize can be any value, + * including larger than the block's decompressed size. + * The function will, at most, generate block's decompressed size. + * + * Note 5 : If srcSize is _larger_ than block's compressed size, + * then targetOutputSize **MUST** be <= block's decompressed size. + * Otherwise, *silent corruption will occur*. + */ + decompress_safe_partial :: proc (src, dst: [^]byte, srcSize, targetOutputSize, dstCapacity: c.int) -> c.int --- + + + createStream :: proc() -> ^stream_t --- + freeStream :: proc(streamPtr: ^stream_t) -> c.int --- + + /*! LZ4_resetStream_fast() : v1.9.0+ + * Use this to prepare an LZ4_stream_t for a new chain of dependent blocks + * (e.g., LZ4_compress_fast_continue()). + * + * An LZ4_stream_t must be initialized once before usage. + * This is automatically done when created by LZ4_createStream(). + * However, should the LZ4_stream_t be simply declared on stack (for example), + * it's necessary to initialize it first, using LZ4_initStream(). + * + * After init, start any new stream with LZ4_resetStream_fast(). + * A same LZ4_stream_t can be re-used multiple times consecutively + * and compress multiple streams, + * provided that it starts each new stream with LZ4_resetStream_fast(). + * + * LZ4_resetStream_fast() is much faster than LZ4_initStream(), + * but is not compatible with memory regions containing garbage data. + * + * Note: it's only useful to call LZ4_resetStream_fast() + * in the context of streaming compression. + * The *extState* functions perform their own resets. + * Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive. + */ + resetStream_fast :: proc(streamPtr: ^stream_t) --- + + + /*! LZ4_loadDict() : + * Use this function to reference a static dictionary into LZ4_stream_t. + * The dictionary must remain available during compression. + * LZ4_loadDict() triggers a reset, so any previous data will be forgotten. + * The same dictionary will have to be loaded on decompression side for successful decoding. + * Dictionary are useful for better compression of small data (KB range). + * While LZ4 itself accepts any input as dictionary, dictionary efficiency is also a topic. + * When in doubt, employ the Zstandard's Dictionary Builder. + * Loading a size of 0 is allowed, and is the same as reset. + * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded) + */ + loadDict :: proc(streamPtr: ^stream_t, dictionary: [^]byte, dictSize: c.int) -> c.int --- + + /*! LZ4_loadDictSlow() : v1.10.0+ + * Same as LZ4_loadDict(), + * but uses a bit more cpu to reference the dictionary content more thoroughly. + * This is expected to slightly improve compression ratio. + * The extra-cpu cost is likely worth it if the dictionary is re-used across multiple sessions. + * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded) + */ + loadDictSlow :: proc(streamPtr: ^stream_t, dictionary: [^]byte, dictSize: c.int) -> c.int --- + + /*! LZ4_attach_dictionary() : stable since v1.10.0 + * + * This allows efficient re-use of a static dictionary multiple times. + * + * Rather than re-loading the dictionary buffer into a working context before + * each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a + * working LZ4_stream_t, this function introduces a no-copy setup mechanism, + * in which the working stream references @dictionaryStream in-place. + * + * Several assumptions are made about the state of @dictionaryStream. + * Currently, only states which have been prepared by LZ4_loadDict() or + * LZ4_loadDictSlow() should be expected to work. + * + * Alternatively, the provided @dictionaryStream may be NULL, + * in which case any existing dictionary stream is unset. + * + * If a dictionary is provided, it replaces any pre-existing stream history. + * The dictionary contents are the only history that can be referenced and + * logically immediately precede the data compressed in the first subsequent + * compression call. + * + * The dictionary will only remain attached to the working stream through the + * first compression call, at the end of which it is cleared. + * @dictionaryStream stream (and source buffer) must remain in-place / accessible / unchanged + * through the completion of the compression session. + * + * Note: there is no equivalent LZ4_attach_*() method on the decompression side + * because there is no initialization cost, hence no need to share the cost across multiple sessions. + * To decompress LZ4 blocks using dictionary, attached or not, + * just employ the regular LZ4_setStreamDecode() for streaming, + * or the stateless LZ4_decompress_safe_usingDict() for one-shot decompression. + */ + attach_dictionary :: proc(workingStream, dictionaryStream: ^stream_t) --- + + /*! LZ4_compress_fast_continue() : + * Compress 'src' content using data from previously compressed blocks, for better compression ratio. + * 'dst' buffer must be already allocated. + * If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster. + * + * @return : size of compressed block + * or 0 if there is an error (typically, cannot fit into 'dst'). + * + * Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block. + * Each block has precise boundaries. + * Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata. + * It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together. + * + * Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory ! + * + * Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB. + * Make sure that buffers are separated, by at least one byte. + * This construction ensures that each block only depends on previous block. + * + * Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB. + * + * Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed. + */ + compress_fast_continue :: proc(streamPtr: ^stream_t, src, dst: [^]byte, srcSize, dstCapacity: c.int, acceleration: c.int) -> c.int --- + + /*! LZ4_saveDict() : + * If last 64KB data cannot be guaranteed to remain available at its current memory location, + * save it into a safer place (char* safeBuffer). + * This is schematically equivalent to a memcpy() followed by LZ4_loadDict(), + * but is much faster, because LZ4_saveDict() doesn't need to rebuild tables. + * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error. + */ + saveDict :: proc(streamPtr: ^stream_t, safeBuffer: [^]byte, maxDictSize: c.int) -> c.int --- + + + createStreamDecode :: proc() -> ^streamDecode_t --- + freeStreamDecode :: proc(LZ4_stream: ^streamDecode_t) -> c.int --- + + /*! LZ4_setStreamDecode() : + * An LZ4_streamDecode_t context can be allocated once and re-used multiple times. + * Use this function to start decompression of a new stream of blocks. + * A dictionary can optionally be set. Use NULL or size 0 for a reset order. + * Dictionary is presumed stable : it must remain accessible and unmodified during next decompression. + * @return : 1 if OK, 0 if error + */ + setStreamDecode :: proc(LZ4_streamDecode: ^streamDecode_t, dictionary: [^]byte, dictSize: c.int) -> c.int --- + + /*! LZ4_decoderRingBufferSize() : v1.8.2+ + * Note : in a ring buffer scenario (optional), + * blocks are presumed decompressed next to each other + * up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize), + * at which stage it resumes from beginning of ring buffer. + * When setting such a ring buffer for streaming decompression, + * provides the minimum size of this ring buffer + * to be compatible with any source respecting maxBlockSize condition. + * @return : minimum ring buffer size, + * or 0 if there is an error (invalid maxBlockSize). + */ + decoderRingBufferSize :: proc(maxBlockSize: c.int) -> c.int --- + + /*! LZ4_decompress_safe_continue() : + * This decoding function allows decompression of consecutive blocks in "streaming" mode. + * The difference with the usual independent blocks is that + * new blocks are allowed to find references into former blocks. + * A block is an unsplittable entity, and must be presented entirely to the decompression function. + * LZ4_decompress_safe_continue() only accepts one block at a time. + * It's modeled after `LZ4_decompress_safe()` and behaves similarly. + * + * @LZ4_streamDecode : decompression state, tracking the position in memory of past data + * @compressedSize : exact complete size of one compressed block. + * @dstCapacity : size of destination buffer (which must be already allocated), + * must be an upper bound of decompressed size. + * @return : number of bytes decompressed into destination buffer (necessarily <= dstCapacity) + * If destination buffer is not large enough, decoding will stop and output an error code (negative value). + * If the source stream is detected malformed, the function will stop decoding and return a negative result. + * + * The last 64KB of previously decoded data *must* remain available and unmodified + * at the memory position where they were previously decoded. + * If less than 64KB of data has been decoded, all the data must be present. + * + * Special : if decompression side sets a ring buffer, it must respect one of the following conditions : + * - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize). + * maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes. + * In which case, encoding and decoding buffers do not need to be synchronized. + * Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize. + * - Synchronized mode : + * Decompression buffer size is _exactly_ the same as compression buffer size, + * and follows exactly same update rule (block boundaries at same positions), + * and decoding function is provided with exact decompressed size of each block (exception for last block of the stream), + * _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB). + * - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes. + * In which case, encoding and decoding buffers do not need to be synchronized, + * and encoding ring buffer can have any size, including small ones ( < 64 KB). + * + * Whenever these conditions are not possible, + * save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression, + * then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block. + */ + decompress_safe_continue :: proc(LZ4_streamDecode: ^streamDecode_t, src, dst: [^]byte, srcSize, dstCapacity: c.int) -> c.int --- + + + /*! LZ4_decompress_safe_usingDict() : + * Works the same as + * a combination of LZ4_setStreamDecode() followed by LZ4_decompress_safe_continue() + * However, it's stateless: it doesn't need any LZ4_streamDecode_t state. + * Dictionary is presumed stable : it must remain accessible and unmodified during decompression. + * Performance tip : Decompression speed can be substantially increased + * when dst == dictStart + dictSize. + */ + decompress_safe_usingDict :: proc(src, dst: [^]byte, srcSize, dstCapacity: c.int, dictStart: [^]byte, dictSize: c.int) -> c.int --- + + /*! LZ4_decompress_safe_partial_usingDict() : + * Behaves the same as LZ4_decompress_safe_partial() + * with the added ability to specify a memory segment for past data. + * Performance tip : Decompression speed can be substantially increased + * when dst == dictStart + dictSize. + */ + decompress_safe_partial_usingDict :: proc(src, dst: [^]byte, compressedSize, targetOutputSize, maxOutputSize: c.int, dictStart: [^]byte, dictSize: c.int) -> c.int --- + +} + + +STREAM_MINSIZE :: (1 << MEMORY_USAGE) + 32 /* static size, for inter-version compatibility */ + +stream_t :: struct #raw_union { + minStateSize: [STREAM_MINSIZE]byte, + internal_donotuse: stream_t_internal, +} + + +HASHLOG :: MEMORY_USAGE-2 +HASHTABLESIZE :: 1 << MEMORY_USAGE +HASH_SIZE_U32 :: 1 << HASHLOG /* required as macro for static allocation */ + +stream_t_internal :: struct { + hashTable: [HASH_SIZE_U32]u32, + dictionary: [^]byte, + dictCtx: ^stream_t_internal, + currentOffset: u32, + tableType: u32, + dictSize: u32, + /* Implicit padding to ensure structure is aligned */ +} + + +STREAMDECODE_MINSIZE :: 32 +streamDecode_t :: struct #raw_union { + minStateSize: [STREAMDECODE_MINSIZE]byte, + internal_donotuse: streamDecode_t_internal, +} + +streamDecode_t_internal :: struct { + externalDict: [^]byte, + prefixEnd: [^]byte, + extDictSize: c.size_t, + prefixSize: c.size_t, +} + + + +/////////////////// +// lz4hc + +CLEVEL_MIN :: 2 +CLEVEL_DEFAULT :: 9 +CLEVEL_OPT_MIN :: 10 +CLEVEL_MAX :: 12 + + +@(default_calling_convention="c", link_prefix="LZ4_") +foreign lib { + /*! LZ4_compress_HC() : + * Compress data from `src` into `dst`, using the powerful but slower "HC" algorithm. + * `dst` must be already allocated. + * Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)` (see "lz4.h") + * Max supported `srcSize` value is LZ4_MAX_INPUT_SIZE (see "lz4.h") + * `compressionLevel` : any value between 1 and LZ4HC_CLEVEL_MAX will work. + * Values > LZ4HC_CLEVEL_MAX behave the same as LZ4HC_CLEVEL_MAX. + * @return : the number of bytes written into 'dst' + * or 0 if compression fails. + */ + compress_HC :: proc(src, dst: [^]byte, srcSize, dstCapacity, compressionLevel: c.int) -> c.int --- + + + /*! LZ4_compress_HC_extStateHC() : + * Same as LZ4_compress_HC(), but using an externally allocated memory segment for `state`. + * `state` size is provided by LZ4_sizeofStateHC(). + * Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() should do properly). + */ + sizeofStateHC :: proc() -> c.int --- + compress_HC_extStateHC :: proc(stateHC: rawptr, src, dst: [^]byte, srcSize, maxDstSize: c.int, compressionLevel: c.int) -> c.int --- + + + /*! LZ4_compress_HC_destSize() : v1.9.0+ + * Will compress as much data as possible from `src` + * to fit into `targetDstSize` budget. + * Result is provided in 2 parts : + * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize) + * or 0 if compression fails. + * `srcSizePtr` : on success, *srcSizePtr is updated to indicate how much bytes were read from `src` + */ + compress_HC_destSize :: proc(stateHC: rawptr, src, dst: [^]byte, srcSizePtr: ^c.int, targetDstSize: c.int, compressionLevel: c.int) -> c.int --- + + /*! LZ4_createStreamHC() and LZ4_freeStreamHC() : + * These functions create and release memory for LZ4 HC streaming state. + * Newly created states are automatically initialized. + * A same state can be used multiple times consecutively, + * starting with LZ4_resetStreamHC_fast() to start a new stream of blocks. + */ + createStreamHC :: proc() -> ^streamHC_t --- + freeStreamHC :: proc(streamHCPtr: ^streamHC_t) -> c.int --- + + resetStreamHC_fast :: proc(streamHCPtr: ^streamHC_t, compressionLevel: c.int) --- /* v1.9.0+ */ + loadDictHC :: proc(streamHCPtr: ^streamHC_t, dictionary: [^]byte, dictSize: c.int) -> c.int --- + + compress_HC_continue :: proc(streamHCPtr: ^streamHC_t, src, dst: [^]byte, srcSize, maxDstSize: c.int) -> c.int --- + + /*! LZ4_compress_HC_continue_destSize() : v1.9.0+ + * Similar to LZ4_compress_HC_continue(), + * but will read as much data as possible from `src` + * to fit into `targetDstSize` budget. + * Result is provided into 2 parts : + * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize) + * or 0 if compression fails. + * `srcSizePtr` : on success, *srcSizePtr will be updated to indicate how much bytes were read from `src`. + * Note that this function may not consume the entire input. + */ + compress_HC_continue_destSize:: proc(LZ4_streamHCPtr: ^streamHC_t, src, dst: [^]byte, srcSizePtr: ^c.int, targetDstSize: c.int) -> c.int --- + + saveDictHC :: proc(streamHCPtr: ^streamHC_t, safeBuffer: [^]byte, maxDictSize: c.int) -> c.int --- + + /*! LZ4_attach_HC_dictionary() : stable since v1.10.0 + * This API allows for the efficient re-use of a static dictionary many times. + * + * Rather than re-loading the dictionary buffer into a working context before + * each compression, or copying a pre-loaded dictionary's LZ4_streamHC_t into a + * working LZ4_streamHC_t, this function introduces a no-copy setup mechanism, + * in which the working stream references the dictionary stream in-place. + * + * Several assumptions are made about the state of the dictionary stream. + * Currently, only streams which have been prepared by LZ4_loadDictHC() should + * be expected to work. + * + * Alternatively, the provided dictionary stream pointer may be NULL, in which + * case any existing dictionary stream is unset. + * + * A dictionary should only be attached to a stream without any history (i.e., + * a stream that has just been reset). + * + * The dictionary will remain attached to the working stream only for the + * current stream session. Calls to LZ4_resetStreamHC(_fast) will remove the + * dictionary context association from the working stream. The dictionary + * stream (and source buffer) must remain in-place / accessible / unchanged + * through the lifetime of the stream session. + */ + attach_HC_dictionary :: proc(working_stream, dictionary_stream: ^streamHC_t) --- +} + + +HC_DICTIONARY_LOGSIZE :: 16 +HC_MAXD :: 1< /* size_t */ + + +/** + Introduction + + LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core, + scalable with multi-cores CPU. It features an extremely fast decoder, with speed in + multiple GB/s per core, typically reaching RAM speed limits on multi-core systems. + + The LZ4 compression library provides in-memory compression and decompression functions. + It gives full buffer control to user. + Compression can be done in: + - a single step (described as Simple Functions) + - a single step, reusing a context (described in Advanced Functions) + - unbounded multiple steps (described as Streaming compression) + + lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md). + Decompressing such a compressed block requires additional metadata. + Exact metadata depends on exact decompression function. + For the typical case of LZ4_decompress_safe(), + metadata includes block's compressed size, and maximum bound of decompressed size. + Each application is free to encode and pass such metadata in whichever way it wants. + + lz4.h only handle blocks, it can not generate Frames. + + Blocks are different from Frames (doc/lz4_Frame_format.md). + Frames bundle both blocks and metadata in a specified manner. + Embedding metadata is required for compressed data to be self-contained and portable. + Frame format is delivered through a companion API, declared in lz4frame.h. + The `lz4` CLI can only manage frames. +*/ + +/*^*************************************************************** +* Export parameters +*****************************************************************/ +/* +* LZ4_DLL_EXPORT : +* Enable exporting of functions when building a Windows DLL +* LZ4LIB_VISIBILITY : +* Control library symbols visibility. +*/ +#ifndef LZ4LIB_VISIBILITY +# if defined(__GNUC__) && (__GNUC__ >= 4) +# define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default"))) +# else +# define LZ4LIB_VISIBILITY +# endif +#endif +#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1) +# define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY +#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1) +# define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/ +#else +# define LZ4LIB_API LZ4LIB_VISIBILITY +#endif + +/*! LZ4_FREESTANDING : + * When this macro is set to 1, it enables "freestanding mode" that is + * suitable for typical freestanding environment which doesn't support + * standard C library. + * + * - LZ4_FREESTANDING is a compile-time switch. + * - It requires the following macros to be defined: + * LZ4_memcpy, LZ4_memmove, LZ4_memset. + * - It only enables LZ4/HC functions which don't use heap. + * All LZ4F_* functions are not supported. + * - See tests/freestanding.c to check its basic setup. + */ +#if defined(LZ4_FREESTANDING) && (LZ4_FREESTANDING == 1) +# define LZ4_HEAPMODE 0 +# define LZ4HC_HEAPMODE 0 +# define LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION 1 +# if !defined(LZ4_memcpy) +# error "LZ4_FREESTANDING requires macro 'LZ4_memcpy'." +# endif +# if !defined(LZ4_memset) +# error "LZ4_FREESTANDING requires macro 'LZ4_memset'." +# endif +# if !defined(LZ4_memmove) +# error "LZ4_FREESTANDING requires macro 'LZ4_memmove'." +# endif +#elif ! defined(LZ4_FREESTANDING) +# define LZ4_FREESTANDING 0 +#endif + + +/*------ Version ------*/ +#define LZ4_VERSION_MAJOR 1 /* for breaking interface changes */ +#define LZ4_VERSION_MINOR 10 /* for new (non-breaking) interface capabilities */ +#define LZ4_VERSION_RELEASE 0 /* for tweaks, bug-fixes, or development */ + +#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE) + +#define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE +#define LZ4_QUOTE(str) #str +#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str) +#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION) /* requires v1.7.3+ */ + +LZ4LIB_API int LZ4_versionNumber (void); /**< library version number; useful to check dll version; requires v1.3.0+ */ +LZ4LIB_API const char* LZ4_versionString (void); /**< library version string; useful to check dll version; requires v1.7.5+ */ + + +/*-************************************ +* Tuning memory usage +**************************************/ +/*! + * LZ4_MEMORY_USAGE : + * Can be selected at compile time, by setting LZ4_MEMORY_USAGE. + * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB) + * Increasing memory usage improves compression ratio, generally at the cost of speed. + * Reduced memory usage may improve speed at the cost of ratio, thanks to better cache locality. + * Default value is 14, for 16KB, which nicely fits into most L1 caches. + */ +#ifndef LZ4_MEMORY_USAGE +# define LZ4_MEMORY_USAGE LZ4_MEMORY_USAGE_DEFAULT +#endif + +/* These are absolute limits, they should not be changed by users */ +#define LZ4_MEMORY_USAGE_MIN 10 +#define LZ4_MEMORY_USAGE_DEFAULT 14 +#define LZ4_MEMORY_USAGE_MAX 20 + +#if (LZ4_MEMORY_USAGE < LZ4_MEMORY_USAGE_MIN) +# error "LZ4_MEMORY_USAGE is too small !" +#endif + +#if (LZ4_MEMORY_USAGE > LZ4_MEMORY_USAGE_MAX) +# error "LZ4_MEMORY_USAGE is too large !" +#endif + +/*-************************************ +* Simple Functions +**************************************/ +/*! LZ4_compress_default() : + * Compresses 'srcSize' bytes from buffer 'src' + * into already allocated 'dst' buffer of size 'dstCapacity'. + * Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize). + * It also runs faster, so it's a recommended setting. + * If the function cannot compress 'src' into a more limited 'dst' budget, + * compression stops *immediately*, and the function result is zero. + * In which case, 'dst' content is undefined (invalid). + * srcSize : max supported value is LZ4_MAX_INPUT_SIZE. + * dstCapacity : size of buffer 'dst' (which must be already allocated) + * @return : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity) + * or 0 if compression fails + * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer). + */ +LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity); + +/*! LZ4_decompress_safe() : + * @compressedSize : is the exact complete size of the compressed block. + * @dstCapacity : is the size of destination buffer (which must be already allocated), + * presumed an upper bound of decompressed size. + * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity) + * If destination buffer is not large enough, decoding will stop and output an error code (negative value). + * If the source stream is detected malformed, the function will stop decoding and return a negative result. + * Note 1 : This function is protected against malicious data packets : + * it will never writes outside 'dst' buffer, nor read outside 'source' buffer, + * even if the compressed block is maliciously modified to order the decoder to do these actions. + * In such case, the decoder stops immediately, and considers the compressed block malformed. + * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them. + * The implementation is free to send / store / derive this information in whichever way is most beneficial. + * If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead. + */ +LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity); + + +/*-************************************ +* Advanced Functions +**************************************/ +#define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */ +#define LZ4_COMPRESSBOUND(isize) ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16) + +/*! LZ4_compressBound() : + Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible) + This function is primarily useful for memory allocation purposes (destination buffer size). + Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example). + Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize) + inputSize : max supported value is LZ4_MAX_INPUT_SIZE + return : maximum output size in a "worst case" scenario + or 0, if input size is incorrect (too large or negative) +*/ +LZ4LIB_API int LZ4_compressBound(int inputSize); + +/*! LZ4_compress_fast() : + Same as LZ4_compress_default(), but allows selection of "acceleration" factor. + The larger the acceleration value, the faster the algorithm, but also the lesser the compression. + It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed. + An acceleration value of "1" is the same as regular LZ4_compress_default() + Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c). + Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c). +*/ +LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); + + +/*! LZ4_compress_fast_extState() : + * Same as LZ4_compress_fast(), using an externally allocated memory space for its state. + * Use LZ4_sizeofState() to know how much memory must be allocated, + * and allocate it on 8-bytes boundaries (using `malloc()` typically). + * Then, provide this buffer as `void* state` to compression function. + */ +LZ4LIB_API int LZ4_sizeofState(void); +LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); + +/*! LZ4_compress_destSize() : + * Reverse the logic : compresses as much data as possible from 'src' buffer + * into already allocated buffer 'dst', of size >= 'dstCapacity'. + * This function either compresses the entire 'src' content into 'dst' if it's large enough, + * or fill 'dst' buffer completely with as much data as possible from 'src'. + * note: acceleration parameter is fixed to "default". + * + * *srcSizePtr : in+out parameter. Initially contains size of input. + * Will be modified to indicate how many bytes where read from 'src' to fill 'dst'. + * New value is necessarily <= input value. + * @return : Nb bytes written into 'dst' (necessarily <= dstCapacity) + * or 0 if compression fails. + * + * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed in v1.9.2+): + * the produced compressed content could, in specific circumstances, + * require to be decompressed into a destination buffer larger + * by at least 1 byte than the content to decompress. + * If an application uses `LZ4_compress_destSize()`, + * it's highly recommended to update liblz4 to v1.9.2 or better. + * If this can't be done or ensured, + * the receiving decompression function should provide + * a dstCapacity which is > decompressedSize, by at least 1 byte. + * See https://github.com/lz4/lz4/issues/859 for details + */ +LZ4LIB_API int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize); + +/*! LZ4_decompress_safe_partial() : + * Decompress an LZ4 compressed block, of size 'srcSize' at position 'src', + * into destination buffer 'dst' of size 'dstCapacity'. + * Up to 'targetOutputSize' bytes will be decoded. + * The function stops decoding on reaching this objective. + * This can be useful to boost performance + * whenever only the beginning of a block is required. + * + * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize) + * If source stream is detected malformed, function returns a negative result. + * + * Note 1 : @return can be < targetOutputSize, if compressed block contains less data. + * + * Note 2 : targetOutputSize must be <= dstCapacity + * + * Note 3 : this function effectively stops decoding on reaching targetOutputSize, + * so dstCapacity is kind of redundant. + * This is because in older versions of this function, + * decoding operation would still write complete sequences. + * Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize, + * it could write more bytes, though only up to dstCapacity. + * Some "margin" used to be required for this operation to work properly. + * Thankfully, this is no longer necessary. + * The function nonetheless keeps the same signature, in an effort to preserve API compatibility. + * + * Note 4 : If srcSize is the exact size of the block, + * then targetOutputSize can be any value, + * including larger than the block's decompressed size. + * The function will, at most, generate block's decompressed size. + * + * Note 5 : If srcSize is _larger_ than block's compressed size, + * then targetOutputSize **MUST** be <= block's decompressed size. + * Otherwise, *silent corruption will occur*. + */ +LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity); + + +/*-********************************************* +* Streaming Compression Functions +***********************************************/ +typedef union LZ4_stream_u LZ4_stream_t; /* incomplete type (defined later) */ + +/*! + Note about RC_INVOKED + + - RC_INVOKED is predefined symbol of rc.exe (the resource compiler which is part of MSVC/Visual Studio). + https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros + + - Since rc.exe is a legacy compiler, it truncates long symbol (> 30 chars) + and reports warning "RC4011: identifier truncated". + + - To eliminate the warning, we surround long preprocessor symbol with + "#if !defined(RC_INVOKED) ... #endif" block that means + "skip this block when rc.exe is trying to read it". +*/ +#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +LZ4LIB_API LZ4_stream_t* LZ4_createStream(void); +LZ4LIB_API int LZ4_freeStream (LZ4_stream_t* streamPtr); +#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */ +#endif + +/*! LZ4_resetStream_fast() : v1.9.0+ + * Use this to prepare an LZ4_stream_t for a new chain of dependent blocks + * (e.g., LZ4_compress_fast_continue()). + * + * An LZ4_stream_t must be initialized once before usage. + * This is automatically done when created by LZ4_createStream(). + * However, should the LZ4_stream_t be simply declared on stack (for example), + * it's necessary to initialize it first, using LZ4_initStream(). + * + * After init, start any new stream with LZ4_resetStream_fast(). + * A same LZ4_stream_t can be re-used multiple times consecutively + * and compress multiple streams, + * provided that it starts each new stream with LZ4_resetStream_fast(). + * + * LZ4_resetStream_fast() is much faster than LZ4_initStream(), + * but is not compatible with memory regions containing garbage data. + * + * Note: it's only useful to call LZ4_resetStream_fast() + * in the context of streaming compression. + * The *extState* functions perform their own resets. + * Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive. + */ +LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr); + +/*! LZ4_loadDict() : + * Use this function to reference a static dictionary into LZ4_stream_t. + * The dictionary must remain available during compression. + * LZ4_loadDict() triggers a reset, so any previous data will be forgotten. + * The same dictionary will have to be loaded on decompression side for successful decoding. + * Dictionary are useful for better compression of small data (KB range). + * While LZ4 itself accepts any input as dictionary, dictionary efficiency is also a topic. + * When in doubt, employ the Zstandard's Dictionary Builder. + * Loading a size of 0 is allowed, and is the same as reset. + * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded) + */ +LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize); + +/*! LZ4_loadDictSlow() : v1.10.0+ + * Same as LZ4_loadDict(), + * but uses a bit more cpu to reference the dictionary content more thoroughly. + * This is expected to slightly improve compression ratio. + * The extra-cpu cost is likely worth it if the dictionary is re-used across multiple sessions. + * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded) + */ +LZ4LIB_API int LZ4_loadDictSlow(LZ4_stream_t* streamPtr, const char* dictionary, int dictSize); + +/*! LZ4_attach_dictionary() : stable since v1.10.0 + * + * This allows efficient re-use of a static dictionary multiple times. + * + * Rather than re-loading the dictionary buffer into a working context before + * each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a + * working LZ4_stream_t, this function introduces a no-copy setup mechanism, + * in which the working stream references @dictionaryStream in-place. + * + * Several assumptions are made about the state of @dictionaryStream. + * Currently, only states which have been prepared by LZ4_loadDict() or + * LZ4_loadDictSlow() should be expected to work. + * + * Alternatively, the provided @dictionaryStream may be NULL, + * in which case any existing dictionary stream is unset. + * + * If a dictionary is provided, it replaces any pre-existing stream history. + * The dictionary contents are the only history that can be referenced and + * logically immediately precede the data compressed in the first subsequent + * compression call. + * + * The dictionary will only remain attached to the working stream through the + * first compression call, at the end of which it is cleared. + * @dictionaryStream stream (and source buffer) must remain in-place / accessible / unchanged + * through the completion of the compression session. + * + * Note: there is no equivalent LZ4_attach_*() method on the decompression side + * because there is no initialization cost, hence no need to share the cost across multiple sessions. + * To decompress LZ4 blocks using dictionary, attached or not, + * just employ the regular LZ4_setStreamDecode() for streaming, + * or the stateless LZ4_decompress_safe_usingDict() for one-shot decompression. + */ +LZ4LIB_API void +LZ4_attach_dictionary(LZ4_stream_t* workingStream, + const LZ4_stream_t* dictionaryStream); + +/*! LZ4_compress_fast_continue() : + * Compress 'src' content using data from previously compressed blocks, for better compression ratio. + * 'dst' buffer must be already allocated. + * If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster. + * + * @return : size of compressed block + * or 0 if there is an error (typically, cannot fit into 'dst'). + * + * Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block. + * Each block has precise boundaries. + * Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata. + * It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together. + * + * Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory ! + * + * Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB. + * Make sure that buffers are separated, by at least one byte. + * This construction ensures that each block only depends on previous block. + * + * Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB. + * + * Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed. + */ +LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); + +/*! LZ4_saveDict() : + * If last 64KB data cannot be guaranteed to remain available at its current memory location, + * save it into a safer place (char* safeBuffer). + * This is schematically equivalent to a memcpy() followed by LZ4_loadDict(), + * but is much faster, because LZ4_saveDict() doesn't need to rebuild tables. + * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error. + */ +LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize); + + +/*-********************************************** +* Streaming Decompression Functions +* Bufferless synchronous API +************************************************/ +typedef union LZ4_streamDecode_u LZ4_streamDecode_t; /* tracking context */ + +/*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() : + * creation / destruction of streaming decompression tracking context. + * A tracking context can be re-used multiple times. + */ +#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void); +LZ4LIB_API int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream); +#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */ +#endif + +/*! LZ4_setStreamDecode() : + * An LZ4_streamDecode_t context can be allocated once and re-used multiple times. + * Use this function to start decompression of a new stream of blocks. + * A dictionary can optionally be set. Use NULL or size 0 for a reset order. + * Dictionary is presumed stable : it must remain accessible and unmodified during next decompression. + * @return : 1 if OK, 0 if error + */ +LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize); + +/*! LZ4_decoderRingBufferSize() : v1.8.2+ + * Note : in a ring buffer scenario (optional), + * blocks are presumed decompressed next to each other + * up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize), + * at which stage it resumes from beginning of ring buffer. + * When setting such a ring buffer for streaming decompression, + * provides the minimum size of this ring buffer + * to be compatible with any source respecting maxBlockSize condition. + * @return : minimum ring buffer size, + * or 0 if there is an error (invalid maxBlockSize). + */ +LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize); +#define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize)) /* for static allocation; maxBlockSize presumed valid */ + +/*! LZ4_decompress_safe_continue() : + * This decoding function allows decompression of consecutive blocks in "streaming" mode. + * The difference with the usual independent blocks is that + * new blocks are allowed to find references into former blocks. + * A block is an unsplittable entity, and must be presented entirely to the decompression function. + * LZ4_decompress_safe_continue() only accepts one block at a time. + * It's modeled after `LZ4_decompress_safe()` and behaves similarly. + * + * @LZ4_streamDecode : decompression state, tracking the position in memory of past data + * @compressedSize : exact complete size of one compressed block. + * @dstCapacity : size of destination buffer (which must be already allocated), + * must be an upper bound of decompressed size. + * @return : number of bytes decompressed into destination buffer (necessarily <= dstCapacity) + * If destination buffer is not large enough, decoding will stop and output an error code (negative value). + * If the source stream is detected malformed, the function will stop decoding and return a negative result. + * + * The last 64KB of previously decoded data *must* remain available and unmodified + * at the memory position where they were previously decoded. + * If less than 64KB of data has been decoded, all the data must be present. + * + * Special : if decompression side sets a ring buffer, it must respect one of the following conditions : + * - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize). + * maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes. + * In which case, encoding and decoding buffers do not need to be synchronized. + * Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize. + * - Synchronized mode : + * Decompression buffer size is _exactly_ the same as compression buffer size, + * and follows exactly same update rule (block boundaries at same positions), + * and decoding function is provided with exact decompressed size of each block (exception for last block of the stream), + * _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB). + * - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes. + * In which case, encoding and decoding buffers do not need to be synchronized, + * and encoding ring buffer can have any size, including small ones ( < 64 KB). + * + * Whenever these conditions are not possible, + * save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression, + * then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block. +*/ +LZ4LIB_API int +LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, + const char* src, char* dst, + int srcSize, int dstCapacity); + + +/*! LZ4_decompress_safe_usingDict() : + * Works the same as + * a combination of LZ4_setStreamDecode() followed by LZ4_decompress_safe_continue() + * However, it's stateless: it doesn't need any LZ4_streamDecode_t state. + * Dictionary is presumed stable : it must remain accessible and unmodified during decompression. + * Performance tip : Decompression speed can be substantially increased + * when dst == dictStart + dictSize. + */ +LZ4LIB_API int +LZ4_decompress_safe_usingDict(const char* src, char* dst, + int srcSize, int dstCapacity, + const char* dictStart, int dictSize); + +/*! LZ4_decompress_safe_partial_usingDict() : + * Behaves the same as LZ4_decompress_safe_partial() + * with the added ability to specify a memory segment for past data. + * Performance tip : Decompression speed can be substantially increased + * when dst == dictStart + dictSize. + */ +LZ4LIB_API int +LZ4_decompress_safe_partial_usingDict(const char* src, char* dst, + int compressedSize, + int targetOutputSize, int maxOutputSize, + const char* dictStart, int dictSize); + +#endif /* LZ4_H_2983827168210 */ + + +/*^************************************* + * !!!!!! STATIC LINKING ONLY !!!!!! + ***************************************/ + +/*-**************************************************************************** + * Experimental section + * + * Symbols declared in this section must be considered unstable. Their + * signatures or semantics may change, or they may be removed altogether in the + * future. They are therefore only safe to depend on when the caller is + * statically linked against the library. + * + * To protect against unsafe usage, not only are the declarations guarded, + * the definitions are hidden by default + * when building LZ4 as a shared/dynamic library. + * + * In order to access these declarations, + * define LZ4_STATIC_LINKING_ONLY in your application + * before including LZ4's headers. + * + * In order to make their implementations accessible dynamically, you must + * define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library. + ******************************************************************************/ + +#ifdef LZ4_STATIC_LINKING_ONLY + +#ifndef LZ4_STATIC_3504398509 +#define LZ4_STATIC_3504398509 + +#ifdef LZ4_PUBLISH_STATIC_FUNCTIONS +# define LZ4LIB_STATIC_API LZ4LIB_API +#else +# define LZ4LIB_STATIC_API +#endif + + +/*! LZ4_compress_fast_extState_fastReset() : + * A variant of LZ4_compress_fast_extState(). + * + * Using this variant avoids an expensive initialization step. + * It is only safe to call if the state buffer is known to be correctly initialized already + * (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized"). + * From a high level, the difference is that + * this function initializes the provided state with a call to something like LZ4_resetStream_fast() + * while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream(). + */ +LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); + +/*! LZ4_compress_destSize_extState() : introduced in v1.10.0 + * Same as LZ4_compress_destSize(), but using an externally allocated state. + * Also: exposes @acceleration + */ +int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration); + +/*! In-place compression and decompression + * + * It's possible to have input and output sharing the same buffer, + * for highly constrained memory environments. + * In both cases, it requires input to lay at the end of the buffer, + * and decompression to start at beginning of the buffer. + * Buffer size must feature some margin, hence be larger than final size. + * + * |<------------------------buffer--------------------------------->| + * |<-----------compressed data--------->| + * |<-----------decompressed size------------------>| + * |<----margin---->| + * + * This technique is more useful for decompression, + * since decompressed size is typically larger, + * and margin is short. + * + * In-place decompression will work inside any buffer + * which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize). + * This presumes that decompressedSize > compressedSize. + * Otherwise, it means compression actually expanded data, + * and it would be more efficient to store such data with a flag indicating it's not compressed. + * This can happen when data is not compressible (already compressed, or encrypted). + * + * For in-place compression, margin is larger, as it must be able to cope with both + * history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX, + * and data expansion, which can happen when input is not compressible. + * As a consequence, buffer size requirements are much higher, + * and memory savings offered by in-place compression are more limited. + * + * There are ways to limit this cost for compression : + * - Reduce history size, by modifying LZ4_DISTANCE_MAX. + * Note that it is a compile-time constant, so all compressions will apply this limit. + * Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX, + * so it's a reasonable trick when inputs are known to be small. + * - Require the compressor to deliver a "maximum compressed size". + * This is the `dstCapacity` parameter in `LZ4_compress*()`. + * When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail, + * in which case, the return code will be 0 (zero). + * The caller must be ready for these cases to happen, + * and typically design a backup scheme to send data uncompressed. + * The combination of both techniques can significantly reduce + * the amount of margin required for in-place compression. + * + * In-place compression can work in any buffer + * which size is >= (maxCompressedSize) + * with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success. + * LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX, + * so it's possible to reduce memory requirements by playing with them. + */ + +#define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize) (((compressedSize) >> 8) + 32) +#define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize) ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize)) /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */ + +#ifndef LZ4_DISTANCE_MAX /* history window size; can be user-defined at compile time */ +# define LZ4_DISTANCE_MAX 65535 /* set to maximum value by default */ +#endif + +#define LZ4_COMPRESS_INPLACE_MARGIN (LZ4_DISTANCE_MAX + 32) /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */ +#define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize) ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN) /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */ + +#endif /* LZ4_STATIC_3504398509 */ +#endif /* LZ4_STATIC_LINKING_ONLY */ + + + +#ifndef LZ4_H_98237428734687 +#define LZ4_H_98237428734687 + +/*-************************************************************ + * Private Definitions + ************************************************************** + * Do not use these definitions directly. + * They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`. + * Accessing members will expose user code to API and/or ABI break in future versions of the library. + **************************************************************/ +#define LZ4_HASHLOG (LZ4_MEMORY_USAGE-2) +#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE) +#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG) /* required as macro for static allocation */ + +#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) +# include + typedef int8_t LZ4_i8; + typedef uint8_t LZ4_byte; + typedef uint16_t LZ4_u16; + typedef uint32_t LZ4_u32; +#else + typedef signed char LZ4_i8; + typedef unsigned char LZ4_byte; + typedef unsigned short LZ4_u16; + typedef unsigned int LZ4_u32; +#endif + +/*! LZ4_stream_t : + * Never ever use below internal definitions directly ! + * These definitions are not API/ABI safe, and may change in future versions. + * If you need static allocation, declare or allocate an LZ4_stream_t object. +**/ + +typedef struct LZ4_stream_t_internal LZ4_stream_t_internal; +struct LZ4_stream_t_internal { + LZ4_u32 hashTable[LZ4_HASH_SIZE_U32]; + const LZ4_byte* dictionary; + const LZ4_stream_t_internal* dictCtx; + LZ4_u32 currentOffset; + LZ4_u32 tableType; + LZ4_u32 dictSize; + /* Implicit padding to ensure structure is aligned */ +}; + +#define LZ4_STREAM_MINSIZE ((1UL << (LZ4_MEMORY_USAGE)) + 32) /* static size, for inter-version compatibility */ +union LZ4_stream_u { + char minStateSize[LZ4_STREAM_MINSIZE]; + LZ4_stream_t_internal internal_donotuse; +}; /* previously typedef'd to LZ4_stream_t */ + + +/*! LZ4_initStream() : v1.9.0+ + * An LZ4_stream_t structure must be initialized at least once. + * This is automatically done when invoking LZ4_createStream(), + * but it's not when the structure is simply declared on stack (for example). + * + * Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t. + * It can also initialize any arbitrary buffer of sufficient size, + * and will @return a pointer of proper type upon initialization. + * + * Note : initialization fails if size and alignment conditions are not respected. + * In which case, the function will @return NULL. + * Note2: An LZ4_stream_t structure guarantees correct alignment and size. + * Note3: Before v1.9.0, use LZ4_resetStream() instead +**/ +LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* stateBuffer, size_t size); + + +/*! LZ4_streamDecode_t : + * Never ever use below internal definitions directly ! + * These definitions are not API/ABI safe, and may change in future versions. + * If you need static allocation, declare or allocate an LZ4_streamDecode_t object. +**/ +typedef struct { + const LZ4_byte* externalDict; + const LZ4_byte* prefixEnd; + size_t extDictSize; + size_t prefixSize; +} LZ4_streamDecode_t_internal; + +#define LZ4_STREAMDECODE_MINSIZE 32 +union LZ4_streamDecode_u { + char minStateSize[LZ4_STREAMDECODE_MINSIZE]; + LZ4_streamDecode_t_internal internal_donotuse; +} ; /* previously typedef'd to LZ4_streamDecode_t */ + + + +/*-************************************ +* Obsolete Functions +**************************************/ + +/*! Deprecation warnings + * + * Deprecated functions make the compiler generate a warning when invoked. + * This is meant to invite users to update their source code. + * Should deprecation warnings be a problem, it is generally possible to disable them, + * typically with -Wno-deprecated-declarations for gcc + * or _CRT_SECURE_NO_WARNINGS in Visual. + * + * Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS + * before including the header file. + */ +#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS +# define LZ4_DEPRECATED(message) /* disable deprecation warnings */ +#else +# if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */ +# define LZ4_DEPRECATED(message) [[deprecated(message)]] +# elif defined(_MSC_VER) +# define LZ4_DEPRECATED(message) __declspec(deprecated(message)) +# elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45)) +# define LZ4_DEPRECATED(message) __attribute__((deprecated(message))) +# elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31) +# define LZ4_DEPRECATED(message) __attribute__((deprecated)) +# else +# pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler") +# define LZ4_DEPRECATED(message) /* disabled */ +# endif +#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */ + +/*! Obsolete compression functions (since v1.7.3) */ +LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress (const char* src, char* dest, int srcSize); +LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress_limitedOutput (const char* src, char* dest, int srcSize, int maxOutputSize); +LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState (void* state, const char* source, char* dest, int inputSize); +LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize); +LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize); +LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize); + +/*! Obsolete decompression functions (since v1.8.0) */ +LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize); +LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); + +/* Obsolete streaming functions (since v1.7.0) + * degraded functionality; do not use! + * + * In order to perform streaming compression, these functions depended on data + * that is no longer tracked in the state. They have been preserved as well as + * possible: using them will still produce a correct output. However, they don't + * actually retain any history between compression calls. The compression ratio + * achieved will therefore be no better than compressing each chunk + * independently. + */ +LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer); +LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int LZ4_sizeofStreamState(void); +LZ4_DEPRECATED("Use LZ4_resetStream() instead") LZ4LIB_API int LZ4_resetStreamState(void* state, char* inputBuffer); +LZ4_DEPRECATED("Use LZ4_saveDict() instead") LZ4LIB_API char* LZ4_slideInputBuffer (void* state); + +/*! Obsolete streaming decoding functions (since v1.7.0) */ +LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize); +LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize); + +/*! Obsolete LZ4_decompress_fast variants (since v1.9.0) : + * These functions used to be faster than LZ4_decompress_safe(), + * but this is no longer the case. They are now slower. + * This is because LZ4_decompress_fast() doesn't know the input size, + * and therefore must progress more cautiously into the input buffer to not read beyond the end of block. + * On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability. + * As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated. + * + * The last remaining LZ4_decompress_fast() specificity is that + * it can decompress a block without knowing its compressed size. + * Such functionality can be achieved in a more secure manner + * by employing LZ4_decompress_safe_partial(). + * + * Parameters: + * originalSize : is the uncompressed size to regenerate. + * `dst` must be already allocated, its size must be >= 'originalSize' bytes. + * @return : number of bytes read from source buffer (== compressed size). + * The function expects to finish at block's end exactly. + * If the source stream is detected malformed, the function stops decoding and returns a negative result. + * note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer. + * However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds. + * Also, since match offsets are not validated, match reads from 'src' may underflow too. + * These issues never happen if input (compressed) data is correct. + * But they may happen if input data is invalid (error or intentional tampering). + * As a consequence, use these functions in trusted environments with trusted data **only**. + */ +LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_partial() instead") +LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize); +LZ4_DEPRECATED("This function is deprecated and unsafe. Consider migrating towards LZ4_decompress_safe_continue() instead. " + "Note that the contract will change (requires block's compressed size, instead of decompressed size)") +LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize); +LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_partial_usingDict() instead") +LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize); + +/*! LZ4_resetStream() : + * An LZ4_stream_t structure must be initialized at least once. + * This is done with LZ4_initStream(), or LZ4_resetStream(). + * Consider switching to LZ4_initStream(), + * invoking LZ4_resetStream() will trigger deprecation warnings in the future. + */ +LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr); + + +#endif /* LZ4_H_98237428734687 */ + + +#if defined (__cplusplus) +} +#endif diff --git a/vendor/compress/lz4/src/lz4frame.h b/vendor/compress/lz4/src/lz4frame.h new file mode 100644 index 000000000..b8ae32276 --- /dev/null +++ b/vendor/compress/lz4/src/lz4frame.h @@ -0,0 +1,751 @@ +/* + LZ4F - LZ4-Frame library + Header File + Copyright (C) 2011-2020, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 source repository : https://github.com/lz4/lz4 + - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c +*/ + +/* LZ4F is a stand-alone API able to create and decode LZ4 frames + * conformant with specification v1.6.1 in doc/lz4_Frame_format.md . + * Generated frames are compatible with `lz4` CLI. + * + * LZ4F also offers streaming capabilities. + * + * lz4.h is not required when using lz4frame.h, + * except to extract common constants such as LZ4_VERSION_NUMBER. + * */ + +#ifndef LZ4F_H_09782039843 +#define LZ4F_H_09782039843 + +#if defined (__cplusplus) +extern "C" { +#endif + +/* --- Dependency --- */ +#include /* size_t */ + + +/** + * Introduction + * + * lz4frame.h implements LZ4 frame specification: see doc/lz4_Frame_format.md . + * LZ4 Frames are compatible with `lz4` CLI, + * and designed to be interoperable with any system. +**/ + +/*-*************************************************************** + * Compiler specifics + *****************************************************************/ +/* LZ4_DLL_EXPORT : + * Enable exporting of functions when building a Windows DLL + * LZ4FLIB_VISIBILITY : + * Control library symbols visibility. + */ +#ifndef LZ4FLIB_VISIBILITY +# if defined(__GNUC__) && (__GNUC__ >= 4) +# define LZ4FLIB_VISIBILITY __attribute__ ((visibility ("default"))) +# else +# define LZ4FLIB_VISIBILITY +# endif +#endif +#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1) +# define LZ4FLIB_API __declspec(dllexport) LZ4FLIB_VISIBILITY +#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1) +# define LZ4FLIB_API __declspec(dllimport) LZ4FLIB_VISIBILITY +#else +# define LZ4FLIB_API LZ4FLIB_VISIBILITY +#endif + +#ifdef LZ4F_DISABLE_DEPRECATE_WARNINGS +# define LZ4F_DEPRECATE(x) x +#else +# if defined(_MSC_VER) +# define LZ4F_DEPRECATE(x) x /* __declspec(deprecated) x - only works with C++ */ +# elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6)) +# define LZ4F_DEPRECATE(x) x __attribute__((deprecated)) +# else +# define LZ4F_DEPRECATE(x) x /* no deprecation warning for this compiler */ +# endif +#endif + + +/*-************************************ + * Error management + **************************************/ +typedef size_t LZ4F_errorCode_t; + +LZ4FLIB_API unsigned LZ4F_isError(LZ4F_errorCode_t code); /**< tells when a function result is an error code */ +LZ4FLIB_API const char* LZ4F_getErrorName(LZ4F_errorCode_t code); /**< return error code string; for debugging */ + + +/*-************************************ + * Frame compression types + ************************************* */ +/* #define LZ4F_ENABLE_OBSOLETE_ENUMS // uncomment to enable obsolete enums */ +#ifdef LZ4F_ENABLE_OBSOLETE_ENUMS +# define LZ4F_OBSOLETE_ENUM(x) , LZ4F_DEPRECATE(x) = LZ4F_##x +#else +# define LZ4F_OBSOLETE_ENUM(x) +#endif + +/* The larger the block size, the (slightly) better the compression ratio, + * though there are diminishing returns. + * Larger blocks also increase memory usage on both compression and decompression sides. + */ +typedef enum { + LZ4F_default=0, + LZ4F_max64KB=4, + LZ4F_max256KB=5, + LZ4F_max1MB=6, + LZ4F_max4MB=7 + LZ4F_OBSOLETE_ENUM(max64KB) + LZ4F_OBSOLETE_ENUM(max256KB) + LZ4F_OBSOLETE_ENUM(max1MB) + LZ4F_OBSOLETE_ENUM(max4MB) +} LZ4F_blockSizeID_t; + +/* Linked blocks sharply reduce inefficiencies when using small blocks, + * they compress better. + * However, some LZ4 decoders are only compatible with independent blocks */ +typedef enum { + LZ4F_blockLinked=0, + LZ4F_blockIndependent + LZ4F_OBSOLETE_ENUM(blockLinked) + LZ4F_OBSOLETE_ENUM(blockIndependent) +} LZ4F_blockMode_t; + +typedef enum { + LZ4F_noContentChecksum=0, + LZ4F_contentChecksumEnabled + LZ4F_OBSOLETE_ENUM(noContentChecksum) + LZ4F_OBSOLETE_ENUM(contentChecksumEnabled) +} LZ4F_contentChecksum_t; + +typedef enum { + LZ4F_noBlockChecksum=0, + LZ4F_blockChecksumEnabled +} LZ4F_blockChecksum_t; + +typedef enum { + LZ4F_frame=0, + LZ4F_skippableFrame + LZ4F_OBSOLETE_ENUM(skippableFrame) +} LZ4F_frameType_t; + +#ifdef LZ4F_ENABLE_OBSOLETE_ENUMS +typedef LZ4F_blockSizeID_t blockSizeID_t; +typedef LZ4F_blockMode_t blockMode_t; +typedef LZ4F_frameType_t frameType_t; +typedef LZ4F_contentChecksum_t contentChecksum_t; +#endif + +/*! LZ4F_frameInfo_t : + * makes it possible to set or read frame parameters. + * Structure must be first init to 0, using memset() or LZ4F_INIT_FRAMEINFO, + * setting all parameters to default. + * It's then possible to update selectively some parameters */ +typedef struct { + LZ4F_blockSizeID_t blockSizeID; /* max64KB, max256KB, max1MB, max4MB; 0 == default (LZ4F_max64KB) */ + LZ4F_blockMode_t blockMode; /* LZ4F_blockLinked, LZ4F_blockIndependent; 0 == default (LZ4F_blockLinked) */ + LZ4F_contentChecksum_t contentChecksumFlag; /* 1: add a 32-bit checksum of frame's decompressed data; 0 == default (disabled) */ + LZ4F_frameType_t frameType; /* read-only field : LZ4F_frame or LZ4F_skippableFrame */ + unsigned long long contentSize; /* Size of uncompressed content ; 0 == unknown */ + unsigned dictID; /* Dictionary ID, sent by compressor to help decoder select correct dictionary; 0 == no dictID provided */ + LZ4F_blockChecksum_t blockChecksumFlag; /* 1: each block followed by a checksum of block's compressed data; 0 == default (disabled) */ +} LZ4F_frameInfo_t; + +#define LZ4F_INIT_FRAMEINFO { LZ4F_max64KB, LZ4F_blockLinked, LZ4F_noContentChecksum, LZ4F_frame, 0ULL, 0U, LZ4F_noBlockChecksum } /* v1.8.3+ */ + +/*! LZ4F_preferences_t : + * makes it possible to supply advanced compression instructions to streaming interface. + * Structure must be first init to 0, using memset() or LZ4F_INIT_PREFERENCES, + * setting all parameters to default. + * All reserved fields must be set to zero. */ +typedef struct { + LZ4F_frameInfo_t frameInfo; + int compressionLevel; /* 0: default (fast mode); values > LZ4HC_CLEVEL_MAX count as LZ4HC_CLEVEL_MAX; values < 0 trigger "fast acceleration" */ + unsigned autoFlush; /* 1: always flush; reduces usage of internal buffers */ + unsigned favorDecSpeed; /* 1: parser favors decompression speed vs compression ratio. Only works for high compression modes (>= LZ4HC_CLEVEL_OPT_MIN) */ /* v1.8.2+ */ + unsigned reserved[3]; /* must be zero for forward compatibility */ +} LZ4F_preferences_t; + +#define LZ4F_INIT_PREFERENCES { LZ4F_INIT_FRAMEINFO, 0, 0u, 0u, { 0u, 0u, 0u } } /* v1.8.3+ */ + + +/*-********************************* +* Simple compression function +***********************************/ + +/*! LZ4F_compressFrame() : + * Compress srcBuffer content into an LZ4-compressed frame. + * It's a one shot operation, all input content is consumed, and all output is generated. + * + * Note : it's a stateless operation (no LZ4F_cctx state needed). + * In order to reduce load on the allocator, LZ4F_compressFrame(), by default, + * uses the stack to allocate space for the compression state and some table. + * If this usage of the stack is too much for your application, + * consider compiling `lz4frame.c` with compile-time macro LZ4F_HEAPMODE set to 1 instead. + * All state allocations will use the Heap. + * It also means each invocation of LZ4F_compressFrame() will trigger several internal alloc/free invocations. + * + * @dstCapacity MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr). + * @preferencesPtr is optional : one can provide NULL, in which case all preferences are set to default. + * @return : number of bytes written into dstBuffer. + * or an error code if it fails (can be tested using LZ4F_isError()) + */ +LZ4FLIB_API size_t LZ4F_compressFrame(void* dstBuffer, size_t dstCapacity, + const void* srcBuffer, size_t srcSize, + const LZ4F_preferences_t* preferencesPtr); + +/*! LZ4F_compressFrameBound() : + * Returns the maximum possible compressed size with LZ4F_compressFrame() given srcSize and preferences. + * `preferencesPtr` is optional. It can be replaced by NULL, in which case, the function will assume default preferences. + * Note : this result is only usable with LZ4F_compressFrame(). + * It may also be relevant to LZ4F_compressUpdate() _only if_ no flush() operation is ever performed. + */ +LZ4FLIB_API size_t LZ4F_compressFrameBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr); + + +/*! LZ4F_compressionLevel_max() : + * @return maximum allowed compression level (currently: 12) + */ +LZ4FLIB_API int LZ4F_compressionLevel_max(void); /* v1.8.0+ */ + + +/*-*********************************** +* Advanced compression functions +*************************************/ +typedef struct LZ4F_cctx_s LZ4F_cctx; /* incomplete type */ +typedef LZ4F_cctx* LZ4F_compressionContext_t; /* for compatibility with older APIs, prefer using LZ4F_cctx */ + +typedef struct { + unsigned stableSrc; /* 1 == src content will remain present on future calls to LZ4F_compress(); skip copying src content within tmp buffer */ + unsigned reserved[3]; +} LZ4F_compressOptions_t; + +/*--- Resource Management ---*/ + +#define LZ4F_VERSION 100 /* This number can be used to check for an incompatible API breaking change */ +LZ4FLIB_API unsigned LZ4F_getVersion(void); + +/*! LZ4F_createCompressionContext() : + * The first thing to do is to create a compressionContext object, + * which will keep track of operation state during streaming compression. + * This is achieved using LZ4F_createCompressionContext(), which takes as argument a version, + * and a pointer to LZ4F_cctx*, to write the resulting pointer into. + * @version provided MUST be LZ4F_VERSION. It is intended to track potential version mismatch, notably when using DLL. + * The function provides a pointer to a fully allocated LZ4F_cctx object. + * @cctxPtr MUST be != NULL. + * If @return != zero, context creation failed. + * A created compression context can be employed multiple times for consecutive streaming operations. + * Once all streaming compression jobs are completed, + * the state object can be released using LZ4F_freeCompressionContext(). + * Note1 : LZ4F_freeCompressionContext() is always successful. Its return value can be ignored. + * Note2 : LZ4F_freeCompressionContext() works fine with NULL input pointers (do nothing). +**/ +LZ4FLIB_API LZ4F_errorCode_t LZ4F_createCompressionContext(LZ4F_cctx** cctxPtr, unsigned version); +LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctx); + + +/*---- Compression ----*/ + +#define LZ4F_HEADER_SIZE_MIN 7 /* LZ4 Frame header size can vary, depending on selected parameters */ +#define LZ4F_HEADER_SIZE_MAX 19 + +/* Size in bytes of a block header in little-endian format. Highest bit indicates if block data is uncompressed */ +#define LZ4F_BLOCK_HEADER_SIZE 4 + +/* Size in bytes of a block checksum footer in little-endian format. */ +#define LZ4F_BLOCK_CHECKSUM_SIZE 4 + +/* Size in bytes of the content checksum. */ +#define LZ4F_CONTENT_CHECKSUM_SIZE 4 + +/*! LZ4F_compressBegin() : + * will write the frame header into dstBuffer. + * dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes. + * `prefsPtr` is optional : NULL can be provided to set all preferences to default. + * @return : number of bytes written into dstBuffer for the header + * or an error code (which can be tested using LZ4F_isError()) + */ +LZ4FLIB_API size_t LZ4F_compressBegin(LZ4F_cctx* cctx, + void* dstBuffer, size_t dstCapacity, + const LZ4F_preferences_t* prefsPtr); + +/*! LZ4F_compressBound() : + * Provides minimum dstCapacity required to guarantee success of + * LZ4F_compressUpdate(), given a srcSize and preferences, for a worst case scenario. + * When srcSize==0, LZ4F_compressBound() provides an upper bound for LZ4F_flush() and LZ4F_compressEnd() instead. + * Note that the result is only valid for a single invocation of LZ4F_compressUpdate(). + * When invoking LZ4F_compressUpdate() multiple times, + * if the output buffer is gradually filled up instead of emptied and re-used from its start, + * one must check if there is enough remaining capacity before each invocation, using LZ4F_compressBound(). + * @return is always the same for a srcSize and prefsPtr. + * prefsPtr is optional : when NULL is provided, preferences will be set to cover worst case scenario. + * tech details : + * @return if automatic flushing is not enabled, includes the possibility that internal buffer might already be filled by up to (blockSize-1) bytes. + * It also includes frame footer (ending + checksum), since it might be generated by LZ4F_compressEnd(). + * @return doesn't include frame header, as it was already generated by LZ4F_compressBegin(). + */ +LZ4FLIB_API size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* prefsPtr); + +/*! LZ4F_compressUpdate() : + * LZ4F_compressUpdate() can be called repetitively to compress as much data as necessary. + * Important rule: dstCapacity MUST be large enough to ensure operation success even in worst case situations. + * This value is provided by LZ4F_compressBound(). + * If this condition is not respected, LZ4F_compress() will fail (result is an errorCode). + * After an error, the state is left in a UB state, and must be re-initialized or freed. + * If previously an uncompressed block was written, buffered data is flushed + * before appending compressed data is continued. + * `cOptPtr` is optional : NULL can be provided, in which case all options are set to default. + * @return : number of bytes written into `dstBuffer` (it can be zero, meaning input data was just buffered). + * or an error code if it fails (which can be tested using LZ4F_isError()) + */ +LZ4FLIB_API size_t LZ4F_compressUpdate(LZ4F_cctx* cctx, + void* dstBuffer, size_t dstCapacity, + const void* srcBuffer, size_t srcSize, + const LZ4F_compressOptions_t* cOptPtr); + +/*! LZ4F_flush() : + * When data must be generated and sent immediately, without waiting for a block to be completely filled, + * it's possible to call LZ4_flush(). It will immediately compress any data buffered within cctx. + * `dstCapacity` must be large enough to ensure the operation will be successful. + * `cOptPtr` is optional : it's possible to provide NULL, all options will be set to default. + * @return : nb of bytes written into dstBuffer (can be zero, when there is no data stored within cctx) + * or an error code if it fails (which can be tested using LZ4F_isError()) + * Note : LZ4F_flush() is guaranteed to be successful when dstCapacity >= LZ4F_compressBound(0, prefsPtr). + */ +LZ4FLIB_API size_t LZ4F_flush(LZ4F_cctx* cctx, + void* dstBuffer, size_t dstCapacity, + const LZ4F_compressOptions_t* cOptPtr); + +/*! LZ4F_compressEnd() : + * To properly finish an LZ4 frame, invoke LZ4F_compressEnd(). + * It will flush whatever data remained within `cctx` (like LZ4_flush()) + * and properly finalize the frame, with an endMark and a checksum. + * `cOptPtr` is optional : NULL can be provided, in which case all options will be set to default. + * @return : nb of bytes written into dstBuffer, necessarily >= 4 (endMark), + * or an error code if it fails (which can be tested using LZ4F_isError()) + * Note : LZ4F_compressEnd() is guaranteed to be successful when dstCapacity >= LZ4F_compressBound(0, prefsPtr). + * A successful call to LZ4F_compressEnd() makes `cctx` available again for another compression task. + */ +LZ4FLIB_API size_t LZ4F_compressEnd(LZ4F_cctx* cctx, + void* dstBuffer, size_t dstCapacity, + const LZ4F_compressOptions_t* cOptPtr); + + +/*-********************************* +* Decompression functions +***********************************/ +typedef struct LZ4F_dctx_s LZ4F_dctx; /* incomplete type */ +typedef LZ4F_dctx* LZ4F_decompressionContext_t; /* compatibility with previous API versions */ + +typedef struct { + unsigned stableDst; /* pledges that last 64KB decompressed data is present right before @dstBuffer pointer. + * This optimization skips internal storage operations. + * Once set, this pledge must remain valid up to the end of current frame. */ + unsigned skipChecksums; /* disable checksum calculation and verification, even when one is present in frame, to save CPU time. + * Setting this option to 1 once disables all checksums for the rest of the frame. */ + unsigned reserved1; /* must be set to zero for forward compatibility */ + unsigned reserved0; /* idem */ +} LZ4F_decompressOptions_t; + + +/* Resource management */ + +/*! LZ4F_createDecompressionContext() : + * Create an LZ4F_dctx object, to track all decompression operations. + * @version provided MUST be LZ4F_VERSION. + * @dctxPtr MUST be valid. + * The function fills @dctxPtr with the value of a pointer to an allocated and initialized LZ4F_dctx object. + * The @return is an errorCode, which can be tested using LZ4F_isError(). + * dctx memory can be released using LZ4F_freeDecompressionContext(); + * Result of LZ4F_freeDecompressionContext() indicates current state of decompressionContext when being released. + * That is, it should be == 0 if decompression has been completed fully and correctly. + */ +LZ4FLIB_API LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_dctx** dctxPtr, unsigned version); +LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_dctx* dctx); + + +/*-*********************************** +* Streaming decompression functions +*************************************/ + +#define LZ4F_MAGICNUMBER 0x184D2204U +#define LZ4F_MAGIC_SKIPPABLE_START 0x184D2A50U +#define LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH 5 + +/*! LZ4F_headerSize() : v1.9.0+ + * Provide the header size of a frame starting at `src`. + * `srcSize` must be >= LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH, + * which is enough to decode the header length. + * @return : size of frame header + * or an error code, which can be tested using LZ4F_isError() + * note : Frame header size is variable, but is guaranteed to be + * >= LZ4F_HEADER_SIZE_MIN bytes, and <= LZ4F_HEADER_SIZE_MAX bytes. + */ +LZ4FLIB_API size_t LZ4F_headerSize(const void* src, size_t srcSize); + +/*! LZ4F_getFrameInfo() : + * This function extracts frame parameters (max blockSize, dictID, etc.). + * Its usage is optional: user can also invoke LZ4F_decompress() directly. + * + * Extracted information will fill an existing LZ4F_frameInfo_t structure. + * This can be useful for allocation and dictionary identification purposes. + * + * LZ4F_getFrameInfo() can work in the following situations : + * + * 1) At the beginning of a new frame, before any invocation of LZ4F_decompress(). + * It will decode header from `srcBuffer`, + * consuming the header and starting the decoding process. + * + * Input size must be large enough to contain the full frame header. + * Frame header size can be known beforehand by LZ4F_headerSize(). + * Frame header size is variable, but is guaranteed to be >= LZ4F_HEADER_SIZE_MIN bytes, + * and not more than <= LZ4F_HEADER_SIZE_MAX bytes. + * Hence, blindly providing LZ4F_HEADER_SIZE_MAX bytes or more will always work. + * It's allowed to provide more input data than the header size, + * LZ4F_getFrameInfo() will only consume the header. + * + * If input size is not large enough, + * aka if it's smaller than header size, + * function will fail and return an error code. + * + * 2) After decoding has been started, + * it's possible to invoke LZ4F_getFrameInfo() anytime + * to extract already decoded frame parameters stored within dctx. + * + * Note that, if decoding has barely started, + * and not yet read enough information to decode the header, + * LZ4F_getFrameInfo() will fail. + * + * The number of bytes consumed from srcBuffer will be updated in *srcSizePtr (necessarily <= original value). + * LZ4F_getFrameInfo() only consumes bytes when decoding has not yet started, + * and when decoding the header has been successful. + * Decompression must then resume from (srcBuffer + *srcSizePtr). + * + * @return : a hint about how many srcSize bytes LZ4F_decompress() expects for next call, + * or an error code which can be tested using LZ4F_isError(). + * note 1 : in case of error, dctx is not modified. Decoding operation can resume from beginning safely. + * note 2 : frame parameters are *copied into* an already allocated LZ4F_frameInfo_t structure. + */ +LZ4FLIB_API size_t +LZ4F_getFrameInfo(LZ4F_dctx* dctx, + LZ4F_frameInfo_t* frameInfoPtr, + const void* srcBuffer, size_t* srcSizePtr); + +/*! LZ4F_decompress() : + * Call this function repetitively to regenerate data compressed in `srcBuffer`. + * + * The function requires a valid dctx state. + * It will read up to *srcSizePtr bytes from srcBuffer, + * and decompress data into dstBuffer, of capacity *dstSizePtr. + * + * The nb of bytes consumed from srcBuffer will be written into *srcSizePtr (necessarily <= original value). + * The nb of bytes decompressed into dstBuffer will be written into *dstSizePtr (necessarily <= original value). + * + * The function does not necessarily read all input bytes, so always check value in *srcSizePtr. + * Unconsumed source data must be presented again in subsequent invocations. + * + * `dstBuffer` can freely change between each consecutive function invocation. + * `dstBuffer` content will be overwritten. + * + * Note: if `LZ4F_getFrameInfo()` is called before `LZ4F_decompress()`, srcBuffer must be updated to reflect + * the number of bytes consumed after reading the frame header. Failure to update srcBuffer before calling + * `LZ4F_decompress()` will cause decompression failure or, even worse, successful but incorrect decompression. + * See the `LZ4F_getFrameInfo()` docs for details. + * + * @return : an hint of how many `srcSize` bytes LZ4F_decompress() expects for next call. + * Schematically, it's the size of the current (or remaining) compressed block + header of next block. + * Respecting the hint provides some small speed benefit, because it skips intermediate buffers. + * This is just a hint though, it's always possible to provide any srcSize. + * + * When a frame is fully decoded, @return will be 0 (no more data expected). + * When provided with more bytes than necessary to decode a frame, + * LZ4F_decompress() will stop reading exactly at end of current frame, and @return 0. + * + * If decompression failed, @return is an error code, which can be tested using LZ4F_isError(). + * After a decompression error, the `dctx` context is not resumable. + * Use LZ4F_resetDecompressionContext() to return to clean state. + * + * After a frame is fully decoded, dctx can be used again to decompress another frame. + */ +LZ4FLIB_API size_t +LZ4F_decompress(LZ4F_dctx* dctx, + void* dstBuffer, size_t* dstSizePtr, + const void* srcBuffer, size_t* srcSizePtr, + const LZ4F_decompressOptions_t* dOptPtr); + + +/*! LZ4F_resetDecompressionContext() : added in v1.8.0 + * In case of an error, the context is left in "undefined" state. + * In which case, it's necessary to reset it, before re-using it. + * This method can also be used to abruptly stop any unfinished decompression, + * and start a new one using same context resources. */ +LZ4FLIB_API void LZ4F_resetDecompressionContext(LZ4F_dctx* dctx); /* always successful */ + + +/********************************** + * Dictionary compression API + *********************************/ + +/* A Dictionary is useful for the compression of small messages (KB range). + * It dramatically improves compression efficiency. + * + * LZ4 can ingest any input as dictionary, though only the last 64 KB are useful. + * Better results are generally achieved by using Zstandard's Dictionary Builder + * to generate a high-quality dictionary from a set of samples. + * + * The same dictionary will have to be used on the decompression side + * for decoding to be successful. + * To help identify the correct dictionary at decoding stage, + * the frame header allows optional embedding of a dictID field. + */ + +/*! LZ4F_compressBegin_usingDict() : stable since v1.10 + * Inits dictionary compression streaming, and writes the frame header into dstBuffer. + * @dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes. + * @prefsPtr is optional : one may provide NULL as argument, + * however, it's the only way to provide dictID in the frame header. + * @dictBuffer must outlive the compression session. + * @return : number of bytes written into dstBuffer for the header, + * or an error code (which can be tested using LZ4F_isError()) + * NOTE: The LZ4Frame spec allows each independent block to be compressed with the dictionary, + * but this entry supports a more limited scenario, where only the first block uses the dictionary. + * This is still useful for small data, which only need one block anyway. + * For larger inputs, one may be more interested in LZ4F_compressFrame_usingCDict() below. + */ +LZ4FLIB_API size_t +LZ4F_compressBegin_usingDict(LZ4F_cctx* cctx, + void* dstBuffer, size_t dstCapacity, + const void* dictBuffer, size_t dictSize, + const LZ4F_preferences_t* prefsPtr); + +/*! LZ4F_decompress_usingDict() : stable since v1.10 + * Same as LZ4F_decompress(), using a predefined dictionary. + * Dictionary is used "in place", without any preprocessing. +** It must remain accessible throughout the entire frame decoding. */ +LZ4FLIB_API size_t +LZ4F_decompress_usingDict(LZ4F_dctx* dctxPtr, + void* dstBuffer, size_t* dstSizePtr, + const void* srcBuffer, size_t* srcSizePtr, + const void* dict, size_t dictSize, + const LZ4F_decompressOptions_t* decompressOptionsPtr); + +/***************************************** + * Bulk processing dictionary compression + *****************************************/ + +/* Loading a dictionary has a cost, since it involves construction of tables. + * The Bulk processing dictionary API makes it possible to share this cost + * over an arbitrary number of compression jobs, even concurrently, + * markedly improving compression latency for these cases. + * + * Note that there is no corresponding bulk API for the decompression side, + * because dictionary does not carry any initialization cost for decompression. + * Use the regular LZ4F_decompress_usingDict() there. + */ +typedef struct LZ4F_CDict_s LZ4F_CDict; + +/*! LZ4_createCDict() : stable since v1.10 + * When compressing multiple messages / blocks using the same dictionary, it's recommended to initialize it just once. + * LZ4_createCDict() will create a digested dictionary, ready to start future compression operations without startup delay. + * LZ4_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only. + * @dictBuffer can be released after LZ4_CDict creation, since its content is copied within CDict. */ +LZ4FLIB_API LZ4F_CDict* LZ4F_createCDict(const void* dictBuffer, size_t dictSize); +LZ4FLIB_API void LZ4F_freeCDict(LZ4F_CDict* CDict); + +/*! LZ4_compressFrame_usingCDict() : stable since v1.10 + * Compress an entire srcBuffer into a valid LZ4 frame using a digested Dictionary. + * @cctx must point to a context created by LZ4F_createCompressionContext(). + * If @cdict==NULL, compress without a dictionary. + * @dstBuffer MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr). + * If this condition is not respected, function will fail (@return an errorCode). + * The LZ4F_preferences_t structure is optional : one may provide NULL as argument, + * but it's not recommended, as it's the only way to provide @dictID in the frame header. + * @return : number of bytes written into dstBuffer. + * or an error code if it fails (can be tested using LZ4F_isError()) + * Note: for larger inputs generating multiple independent blocks, + * this entry point uses the dictionary for each block. */ +LZ4FLIB_API size_t +LZ4F_compressFrame_usingCDict(LZ4F_cctx* cctx, + void* dst, size_t dstCapacity, + const void* src, size_t srcSize, + const LZ4F_CDict* cdict, + const LZ4F_preferences_t* preferencesPtr); + +/*! LZ4F_compressBegin_usingCDict() : stable since v1.10 + * Inits streaming dictionary compression, and writes the frame header into dstBuffer. + * @dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes. + * @prefsPtr is optional : one may provide NULL as argument, + * note however that it's the only way to insert a @dictID in the frame header. + * @cdict must outlive the compression session. + * @return : number of bytes written into dstBuffer for the header, + * or an error code, which can be tested using LZ4F_isError(). */ +LZ4FLIB_API size_t +LZ4F_compressBegin_usingCDict(LZ4F_cctx* cctx, + void* dstBuffer, size_t dstCapacity, + const LZ4F_CDict* cdict, + const LZ4F_preferences_t* prefsPtr); + + +#if defined (__cplusplus) +} +#endif + +#endif /* LZ4F_H_09782039843 */ + +#if defined(LZ4F_STATIC_LINKING_ONLY) && !defined(LZ4F_H_STATIC_09782039843) +#define LZ4F_H_STATIC_09782039843 + +/* Note : + * The below declarations are not stable and may change in the future. + * They are therefore only safe to depend on + * when the caller is statically linked against the library. + * To access their declarations, define LZ4F_STATIC_LINKING_ONLY. + * + * By default, these symbols aren't published into shared/dynamic libraries. + * You can override this behavior and force them to be published + * by defining LZ4F_PUBLISH_STATIC_FUNCTIONS. + * Use at your own risk. + */ + +#if defined (__cplusplus) +extern "C" { +#endif + +#ifdef LZ4F_PUBLISH_STATIC_FUNCTIONS +# define LZ4FLIB_STATIC_API LZ4FLIB_API +#else +# define LZ4FLIB_STATIC_API +#endif + + +/* --- Error List --- */ +#define LZ4F_LIST_ERRORS(ITEM) \ + ITEM(OK_NoError) \ + ITEM(ERROR_GENERIC) \ + ITEM(ERROR_maxBlockSize_invalid) \ + ITEM(ERROR_blockMode_invalid) \ + ITEM(ERROR_parameter_invalid) \ + ITEM(ERROR_compressionLevel_invalid) \ + ITEM(ERROR_headerVersion_wrong) \ + ITEM(ERROR_blockChecksum_invalid) \ + ITEM(ERROR_reservedFlag_set) \ + ITEM(ERROR_allocation_failed) \ + ITEM(ERROR_srcSize_tooLarge) \ + ITEM(ERROR_dstMaxSize_tooSmall) \ + ITEM(ERROR_frameHeader_incomplete) \ + ITEM(ERROR_frameType_unknown) \ + ITEM(ERROR_frameSize_wrong) \ + ITEM(ERROR_srcPtr_wrong) \ + ITEM(ERROR_decompressionFailed) \ + ITEM(ERROR_headerChecksum_invalid) \ + ITEM(ERROR_contentChecksum_invalid) \ + ITEM(ERROR_frameDecoding_alreadyStarted) \ + ITEM(ERROR_compressionState_uninitialized) \ + ITEM(ERROR_parameter_null) \ + ITEM(ERROR_io_write) \ + ITEM(ERROR_io_read) \ + ITEM(ERROR_maxCode) + +#define LZ4F_GENERATE_ENUM(ENUM) LZ4F_##ENUM, + +/* enum list is exposed, to handle specific errors */ +typedef enum { LZ4F_LIST_ERRORS(LZ4F_GENERATE_ENUM) + _LZ4F_dummy_error_enum_for_c89_never_used } LZ4F_errorCodes; + +LZ4FLIB_STATIC_API LZ4F_errorCodes LZ4F_getErrorCode(size_t functionResult); + +/********************************** + * Advanced compression operations + *********************************/ + +/*! LZ4F_getBlockSize() : + * @return, in scalar format (size_t), + * the maximum block size associated with @blockSizeID, + * or an error code (can be tested using LZ4F_isError()) if @blockSizeID is invalid. +**/ +LZ4FLIB_STATIC_API size_t LZ4F_getBlockSize(LZ4F_blockSizeID_t blockSizeID); + +/*! LZ4F_uncompressedUpdate() : + * LZ4F_uncompressedUpdate() can be called repetitively to add data stored as uncompressed blocks. + * Important rule: dstCapacity MUST be large enough to store the entire source buffer as + * no compression is done for this operation + * If this condition is not respected, LZ4F_uncompressedUpdate() will fail (result is an errorCode). + * After an error, the state is left in a UB state, and must be re-initialized or freed. + * If previously a compressed block was written, buffered data is flushed first, + * before appending uncompressed data is continued. + * This operation is only supported when LZ4F_blockIndependent is used. + * `cOptPtr` is optional : NULL can be provided, in which case all options are set to default. + * @return : number of bytes written into `dstBuffer` (it can be zero, meaning input data was just buffered). + * or an error code if it fails (which can be tested using LZ4F_isError()) + */ +LZ4FLIB_STATIC_API size_t +LZ4F_uncompressedUpdate(LZ4F_cctx* cctx, + void* dstBuffer, size_t dstCapacity, + const void* srcBuffer, size_t srcSize, + const LZ4F_compressOptions_t* cOptPtr); + +/********************************** + * Custom memory allocation + *********************************/ + +/*! Custom memory allocation : v1.9.4+ + * These prototypes make it possible to pass custom allocation/free functions. + * LZ4F_customMem is provided at state creation time, using LZ4F_create*_advanced() listed below. + * All allocation/free operations will be completed using these custom variants instead of regular ones. + */ +typedef void* (*LZ4F_AllocFunction) (void* opaqueState, size_t size); +typedef void* (*LZ4F_CallocFunction) (void* opaqueState, size_t size); +typedef void (*LZ4F_FreeFunction) (void* opaqueState, void* address); +typedef struct { + LZ4F_AllocFunction customAlloc; + LZ4F_CallocFunction customCalloc; /* optional; when not defined, uses customAlloc + memset */ + LZ4F_FreeFunction customFree; + void* opaqueState; +} LZ4F_CustomMem; +static +#ifdef __GNUC__ +__attribute__((__unused__)) +#endif +LZ4F_CustomMem const LZ4F_defaultCMem = { NULL, NULL, NULL, NULL }; /**< this constant defers to stdlib's functions */ + +LZ4FLIB_STATIC_API LZ4F_cctx* LZ4F_createCompressionContext_advanced(LZ4F_CustomMem customMem, unsigned version); +LZ4FLIB_STATIC_API LZ4F_dctx* LZ4F_createDecompressionContext_advanced(LZ4F_CustomMem customMem, unsigned version); +LZ4FLIB_STATIC_API LZ4F_CDict* LZ4F_createCDict_advanced(LZ4F_CustomMem customMem, const void* dictBuffer, size_t dictSize); + + +#if defined (__cplusplus) +} +#endif + +#endif /* defined(LZ4F_STATIC_LINKING_ONLY) && !defined(LZ4F_H_STATIC_09782039843) */ diff --git a/vendor/compress/lz4/src/lz4hc.h b/vendor/compress/lz4/src/lz4hc.h new file mode 100644 index 000000000..992bc8cdd --- /dev/null +++ b/vendor/compress/lz4/src/lz4hc.h @@ -0,0 +1,414 @@ +/* + LZ4 HC - High Compression Mode of LZ4 + Header File + Copyright (C) 2011-2020, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 source repository : https://github.com/lz4/lz4 + - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c +*/ +#ifndef LZ4_HC_H_19834876238432 +#define LZ4_HC_H_19834876238432 + +#if defined (__cplusplus) +extern "C" { +#endif + +/* --- Dependency --- */ +/* note : lz4hc requires lz4.h/lz4.c for compilation */ +#include "lz4.h" /* stddef, LZ4LIB_API, LZ4_DEPRECATED */ + + +/* --- Useful constants --- */ +#define LZ4HC_CLEVEL_MIN 2 +#define LZ4HC_CLEVEL_DEFAULT 9 +#define LZ4HC_CLEVEL_OPT_MIN 10 +#define LZ4HC_CLEVEL_MAX 12 + + +/*-************************************ + * Block Compression + **************************************/ +/*! LZ4_compress_HC() : + * Compress data from `src` into `dst`, using the powerful but slower "HC" algorithm. + * `dst` must be already allocated. + * Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)` (see "lz4.h") + * Max supported `srcSize` value is LZ4_MAX_INPUT_SIZE (see "lz4.h") + * `compressionLevel` : any value between 1 and LZ4HC_CLEVEL_MAX will work. + * Values > LZ4HC_CLEVEL_MAX behave the same as LZ4HC_CLEVEL_MAX. + * @return : the number of bytes written into 'dst' + * or 0 if compression fails. + */ +LZ4LIB_API int LZ4_compress_HC (const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel); + + +/* Note : + * Decompression functions are provided within "lz4.h" (BSD license) + */ + + +/*! LZ4_compress_HC_extStateHC() : + * Same as LZ4_compress_HC(), but using an externally allocated memory segment for `state`. + * `state` size is provided by LZ4_sizeofStateHC(). + * Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() should do properly). + */ +LZ4LIB_API int LZ4_sizeofStateHC(void); +LZ4LIB_API int LZ4_compress_HC_extStateHC(void* stateHC, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel); + + +/*! LZ4_compress_HC_destSize() : v1.9.0+ + * Will compress as much data as possible from `src` + * to fit into `targetDstSize` budget. + * Result is provided in 2 parts : + * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize) + * or 0 if compression fails. + * `srcSizePtr` : on success, *srcSizePtr is updated to indicate how much bytes were read from `src` + */ +LZ4LIB_API int LZ4_compress_HC_destSize(void* stateHC, + const char* src, char* dst, + int* srcSizePtr, int targetDstSize, + int compressionLevel); + + +/*-************************************ + * Streaming Compression + * Bufferless synchronous API + **************************************/ + typedef union LZ4_streamHC_u LZ4_streamHC_t; /* incomplete type (defined later) */ + +/*! LZ4_createStreamHC() and LZ4_freeStreamHC() : + * These functions create and release memory for LZ4 HC streaming state. + * Newly created states are automatically initialized. + * A same state can be used multiple times consecutively, + * starting with LZ4_resetStreamHC_fast() to start a new stream of blocks. + */ +LZ4LIB_API LZ4_streamHC_t* LZ4_createStreamHC(void); +LZ4LIB_API int LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr); + +/* + These functions compress data in successive blocks of any size, + using previous blocks as dictionary, to improve compression ratio. + One key assumption is that previous blocks (up to 64 KB) remain read-accessible while compressing next blocks. + There is an exception for ring buffers, which can be smaller than 64 KB. + Ring-buffer scenario is automatically detected and handled within LZ4_compress_HC_continue(). + + Before starting compression, state must be allocated and properly initialized. + LZ4_createStreamHC() does both, though compression level is set to LZ4HC_CLEVEL_DEFAULT. + + Selecting the compression level can be done with LZ4_resetStreamHC_fast() (starts a new stream) + or LZ4_setCompressionLevel() (anytime, between blocks in the same stream) (experimental). + LZ4_resetStreamHC_fast() only works on states which have been properly initialized at least once, + which is automatically the case when state is created using LZ4_createStreamHC(). + + After reset, a first "fictional block" can be designated as initial dictionary, + using LZ4_loadDictHC() (Optional). + Note: In order for LZ4_loadDictHC() to create the correct data structure, + it is essential to set the compression level _before_ loading the dictionary. + + Invoke LZ4_compress_HC_continue() to compress each successive block. + The number of blocks is unlimited. + Previous input blocks, including initial dictionary when present, + must remain accessible and unmodified during compression. + + It's allowed to update compression level anytime between blocks, + using LZ4_setCompressionLevel() (experimental). + + @dst buffer should be sized to handle worst case scenarios + (see LZ4_compressBound(), it ensures compression success). + In case of failure, the API does not guarantee recovery, + so the state _must_ be reset. + To ensure compression success + whenever @dst buffer size cannot be made >= LZ4_compressBound(), + consider using LZ4_compress_HC_continue_destSize(). + + Whenever previous input blocks can't be preserved unmodified in-place during compression of next blocks, + it's possible to copy the last blocks into a more stable memory space, using LZ4_saveDictHC(). + Return value of LZ4_saveDictHC() is the size of dictionary effectively saved into 'safeBuffer' (<= 64 KB) + + After completing a streaming compression, + it's possible to start a new stream of blocks, using the same LZ4_streamHC_t state, + just by resetting it, using LZ4_resetStreamHC_fast(). +*/ + +LZ4LIB_API void LZ4_resetStreamHC_fast(LZ4_streamHC_t* streamHCPtr, int compressionLevel); /* v1.9.0+ */ +LZ4LIB_API int LZ4_loadDictHC (LZ4_streamHC_t* streamHCPtr, const char* dictionary, int dictSize); + +LZ4LIB_API int LZ4_compress_HC_continue (LZ4_streamHC_t* streamHCPtr, + const char* src, char* dst, + int srcSize, int maxDstSize); + +/*! LZ4_compress_HC_continue_destSize() : v1.9.0+ + * Similar to LZ4_compress_HC_continue(), + * but will read as much data as possible from `src` + * to fit into `targetDstSize` budget. + * Result is provided into 2 parts : + * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize) + * or 0 if compression fails. + * `srcSizePtr` : on success, *srcSizePtr will be updated to indicate how much bytes were read from `src`. + * Note that this function may not consume the entire input. + */ +LZ4LIB_API int LZ4_compress_HC_continue_destSize(LZ4_streamHC_t* LZ4_streamHCPtr, + const char* src, char* dst, + int* srcSizePtr, int targetDstSize); + +LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSize); + + +/*! LZ4_attach_HC_dictionary() : stable since v1.10.0 + * This API allows for the efficient re-use of a static dictionary many times. + * + * Rather than re-loading the dictionary buffer into a working context before + * each compression, or copying a pre-loaded dictionary's LZ4_streamHC_t into a + * working LZ4_streamHC_t, this function introduces a no-copy setup mechanism, + * in which the working stream references the dictionary stream in-place. + * + * Several assumptions are made about the state of the dictionary stream. + * Currently, only streams which have been prepared by LZ4_loadDictHC() should + * be expected to work. + * + * Alternatively, the provided dictionary stream pointer may be NULL, in which + * case any existing dictionary stream is unset. + * + * A dictionary should only be attached to a stream without any history (i.e., + * a stream that has just been reset). + * + * The dictionary will remain attached to the working stream only for the + * current stream session. Calls to LZ4_resetStreamHC(_fast) will remove the + * dictionary context association from the working stream. The dictionary + * stream (and source buffer) must remain in-place / accessible / unchanged + * through the lifetime of the stream session. + */ +LZ4LIB_API void +LZ4_attach_HC_dictionary(LZ4_streamHC_t* working_stream, + const LZ4_streamHC_t* dictionary_stream); + + +/*^********************************************** + * !!!!!! STATIC LINKING ONLY !!!!!! + ***********************************************/ + +/*-****************************************************************** + * PRIVATE DEFINITIONS : + * Do not use these definitions directly. + * They are merely exposed to allow static allocation of `LZ4_streamHC_t`. + * Declare an `LZ4_streamHC_t` directly, rather than any type below. + * Even then, only do so in the context of static linking, as definitions may change between versions. + ********************************************************************/ + +#define LZ4HC_DICTIONARY_LOGSIZE 16 +#define LZ4HC_MAXD (1<= LZ4HC_CLEVEL_OPT_MIN. + */ +LZ4LIB_STATIC_API void LZ4_favorDecompressionSpeed( + LZ4_streamHC_t* LZ4_streamHCPtr, int favor); + +/*! LZ4_resetStreamHC_fast() : v1.9.0+ + * When an LZ4_streamHC_t is known to be in a internally coherent state, + * it can often be prepared for a new compression with almost no work, only + * sometimes falling back to the full, expensive reset that is always required + * when the stream is in an indeterminate state (i.e., the reset performed by + * LZ4_resetStreamHC()). + * + * LZ4_streamHCs are guaranteed to be in a valid state when: + * - returned from LZ4_createStreamHC() + * - reset by LZ4_resetStreamHC() + * - memset(stream, 0, sizeof(LZ4_streamHC_t)) + * - the stream was in a valid state and was reset by LZ4_resetStreamHC_fast() + * - the stream was in a valid state and was then used in any compression call + * that returned success + * - the stream was in an indeterminate state and was used in a compression + * call that fully reset the state (LZ4_compress_HC_extStateHC()) and that + * returned success + * + * Note: + * A stream that was last used in a compression call that returned an error + * may be passed to this function. However, it will be fully reset, which will + * clear any existing history and settings from the context. + */ +LZ4LIB_STATIC_API void LZ4_resetStreamHC_fast( + LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel); + +/*! LZ4_compress_HC_extStateHC_fastReset() : + * A variant of LZ4_compress_HC_extStateHC(). + * + * Using this variant avoids an expensive initialization step. It is only safe + * to call if the state buffer is known to be correctly initialized already + * (see above comment on LZ4_resetStreamHC_fast() for a definition of + * "correctly initialized"). From a high level, the difference is that this + * function initializes the provided state with a call to + * LZ4_resetStreamHC_fast() while LZ4_compress_HC_extStateHC() starts with a + * call to LZ4_resetStreamHC(). + */ +LZ4LIB_STATIC_API int LZ4_compress_HC_extStateHC_fastReset ( + void* state, + const char* src, char* dst, + int srcSize, int dstCapacity, + int compressionLevel); + +#if defined (__cplusplus) +} +#endif + +#endif /* LZ4_HC_SLO_098092834 */ +#endif /* LZ4_HC_STATIC_LINKING_ONLY */