Go to the source code of this file.
Macros | |
| #define | ACCELERATION_DEFAULT 1 |
| #define | ALLOCATOR(n, s) calloc(n,s) |
| #define | DEBUGLOG(l, ...) {} /* disabled */ |
| #define | expect(expr, value) (expr) |
| #define | FORCE_INLINE static |
| #define | FREEMEM free |
| #define | GB *(1U<<30) |
| #define | HASH_UNIT sizeof(reg_t) |
| #define | KB *(1 <<10) |
| #define | LASTLITERALS 5 |
| #define | likely(expr) expect((expr) != 0, 1) |
| #define | LZ4_HEAPMODE 0 |
| #define | LZ4_STATIC_ASSERT(c) { enum { LZ4_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ |
| #define | MAX_DISTANCE ((1 << MAXD_LOG) - 1) |
| #define | MAXD_LOG 16 |
| #define | MB *(1 <<20) |
| #define | MEM_INIT memset |
| #define | MFLIMIT (WILDCOPYLENGTH+MINMATCH) |
| #define | MINMATCH 4 |
| #define | ML_BITS 4 |
| #define | ML_MASK ((1U<<ML_BITS)-1) |
| #define | RUN_BITS (8-ML_BITS) |
| #define | RUN_MASK ((1U<<RUN_BITS)-1) |
| #define | STEPSIZE sizeof(reg_t) |
| #define | unlikely(expr) expect((expr) != 0, 0) |
| #define | WILDCOPYLENGTH 8 |
Typedefs | |
| typedef unsigned char | BYTE |
| typedef size_t | reg_t |
| typedef signed int | S32 |
| typedef unsigned short | U16 |
| typedef unsigned int | U32 |
| typedef unsigned long long | U64 |
| typedef size_t | uptrval |
Enumerations | |
| enum | dict_directive { noDict = 0, withPrefix64k, usingExtDict } |
| enum | dictIssue_directive { noDictIssue = 0, dictSmall } |
| enum | earlyEnd_directive { full = 0, partial = 1 } |
| enum | endCondition_directive { endOnOutputSize = 0, endOnInputSize = 1 } |
| enum | limitedOutput_directive { notLimited = 0, limitedOutput = 1, noLimit = 0, limitedOutput = 1, limitedDestSize = 2 } |
| enum | tableType_t { byPtr, byU32, byU16 } |
Functions | |
| int | LZ4_compress (const char *source, char *dest, int inputSize) |
| int | LZ4_compress_continue (LZ4_stream_t *LZ4_stream, const char *source, char *dest, int inputSize) |
| int | LZ4_compress_default (const char *source, char *dest, int inputSize, int maxOutputSize) |
| int | LZ4_compress_destSize (const char *src, char *dst, int *srcSizePtr, int targetDstSize) |
| static int | LZ4_compress_destSize_extState (LZ4_stream_t *state, const char *src, char *dst, int *srcSizePtr, int targetDstSize) |
| static int | LZ4_compress_destSize_generic (LZ4_stream_t_internal *const ctx, const char *const src, char *const dst, int *const srcSizePtr, const int targetDstSize, const tableType_t tableType) |
| int | LZ4_compress_fast (const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration) |
| int | LZ4_compress_fast_continue (LZ4_stream_t *LZ4_stream, const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration) |
| int | LZ4_compress_fast_extState (void *state, const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration) |
| int | LZ4_compress_fast_force (const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration) |
| int | LZ4_compress_forceExtDict (LZ4_stream_t *LZ4_dict, const char *source, char *dest, int inputSize) |
| FORCE_INLINE int | LZ4_compress_generic (LZ4_stream_t_internal *const cctx, const char *const source, char *const dest, const int inputSize, const int maxOutputSize, const limitedOutput_directive outputLimited, const tableType_t tableType, const dict_directive dict, const dictIssue_directive dictIssue, const U32 acceleration) |
| int | LZ4_compress_limitedOutput (const char *source, char *dest, int inputSize, int maxOutputSize) |
| int | LZ4_compress_limitedOutput_continue (LZ4_stream_t *LZ4_stream, const char *src, char *dst, int srcSize, int maxDstSize) |
| int | LZ4_compress_limitedOutput_withState (void *state, const char *src, char *dst, int srcSize, int dstSize) |
| int | LZ4_compress_withState (void *state, const char *src, char *dst, int srcSize) |
| int | LZ4_compressBound (int isize) |
| static void | LZ4_copy8 (void *dst, const void *src) |
| static unsigned | LZ4_count (const BYTE *pIn, const BYTE *pMatch, const BYTE *pInLimit) |
| void * | LZ4_create (char *inputBuffer) |
| LZ4_stream_t * | LZ4_createStream (void) |
| LZ4_streamDecode_t * | LZ4_createStreamDecode (void) |
| int | LZ4_decompress_fast (const char *source, char *dest, int originalSize) |
| int | LZ4_decompress_fast_continue (LZ4_streamDecode_t *LZ4_streamDecode, const char *source, char *dest, int originalSize) |
| int | LZ4_decompress_fast_usingDict (const char *source, char *dest, int originalSize, const char *dictStart, int dictSize) |
| int | LZ4_decompress_fast_withPrefix64k (const char *source, char *dest, int originalSize) |
| FORCE_INLINE int | LZ4_decompress_generic (const char *const source, char *const dest, int inputSize, int outputSize, int endOnInput, int partialDecoding, int targetOutputSize, int dict, const BYTE *const lowPrefix, const BYTE *const dictStart, const size_t dictSize) |
| int | LZ4_decompress_safe (const char *source, char *dest, int compressedSize, int maxDecompressedSize) |
| int | LZ4_decompress_safe_continue (LZ4_streamDecode_t *LZ4_streamDecode, const char *source, char *dest, int compressedSize, int maxOutputSize) |
| int | LZ4_decompress_safe_forceExtDict (const char *source, char *dest, int compressedSize, int maxOutputSize, const char *dictStart, int dictSize) |
| int | LZ4_decompress_safe_partial (const char *source, char *dest, int compressedSize, int targetOutputSize, int maxDecompressedSize) |
| int | LZ4_decompress_safe_usingDict (const char *source, char *dest, int compressedSize, int maxOutputSize, const char *dictStart, int dictSize) |
| int | LZ4_decompress_safe_withPrefix64k (const char *source, char *dest, int compressedSize, int maxOutputSize) |
| FORCE_INLINE int | LZ4_decompress_usingDict_generic (const char *source, char *dest, int compressedSize, int maxOutputSize, int safe, const char *dictStart, int dictSize) |
| int | LZ4_freeStream (LZ4_stream_t *LZ4_stream) |
| int | LZ4_freeStreamDecode (LZ4_streamDecode_t *LZ4_stream) |
| FORCE_INLINE const BYTE * | LZ4_getPosition (const BYTE *p, void *tableBase, tableType_t tableType, const BYTE *srcBase) |
| static const BYTE * | LZ4_getPositionOnHash (U32 h, void *tableBase, tableType_t tableType, const BYTE *srcBase) |
| static U32 | LZ4_hash4 (U32 sequence, tableType_t const tableType) |
| static U32 | LZ4_hash5 (U64 sequence, tableType_t const tableType) |
| FORCE_INLINE U32 | LZ4_hashPosition (const void *const p, tableType_t const tableType) |
| static void | LZ4_init (LZ4_stream_t *lz4ds, BYTE *base) |
| static unsigned | LZ4_isLittleEndian (void) |
| int | LZ4_loadDict (LZ4_stream_t *LZ4_dict, const char *dictionary, int dictSize) |
| static unsigned | LZ4_NbCommonBytes (register reg_t val) |
| FORCE_INLINE void | LZ4_putPosition (const BYTE *p, void *tableBase, tableType_t tableType, const BYTE *srcBase) |
| static void | LZ4_putPositionOnHash (const BYTE *p, U32 h, void *tableBase, tableType_t const tableType, const BYTE *srcBase) |
| static U16 | LZ4_read16 (const void *memPtr) |
| static U32 | LZ4_read32 (const void *memPtr) |
| static reg_t | LZ4_read_ARCH (const void *memPtr) |
| static U16 | LZ4_readLE16 (const void *memPtr) |
| static void | LZ4_renormDictT (LZ4_stream_t_internal *LZ4_dict, const BYTE *src) |
| void | LZ4_resetStream (LZ4_stream_t *LZ4_stream) |
| int | LZ4_resetStreamState (void *state, char *inputBuffer) |
| int | LZ4_saveDict (LZ4_stream_t *LZ4_dict, char *safeBuffer, int dictSize) |
| int | LZ4_setStreamDecode (LZ4_streamDecode_t *LZ4_streamDecode, const char *dictionary, int dictSize) |
| int | LZ4_sizeofState () |
| int | LZ4_sizeofStreamState () |
| char * | LZ4_slideInputBuffer (void *LZ4_Data) |
| int | LZ4_uncompress (const char *source, char *dest, int outputSize) |
| int | LZ4_uncompress_unknownOutputSize (const char *source, char *dest, int isize, int maxOutputSize) |
| int | LZ4_versionNumber (void) |
| const char * | LZ4_versionString (void) |
| static void | LZ4_wildCopy (void *dstPtr, const void *srcPtr, void *dstEnd) |
| static void | LZ4_write16 (void *memPtr, U16 value) |
| static void | LZ4_write32 (void *memPtr, U32 value) |
| static void | LZ4_writeLE16 (void *memPtr, U16 value) |
Variables | |
| static const int | LZ4_64Klimit = ((64 KB) + (MFLIMIT-1)) |
| static const int | LZ4_minLength = (MFLIMIT+1) |
| static const U32 | LZ4_skipTrigger = 6 |
Macro Definition Documentation
| #define MFLIMIT (WILDCOPYLENGTH+MINMATCH) |
Typedef Documentation
Enumeration Type Documentation
| enum dict_directive |
| enum dictIssue_directive |
| enum earlyEnd_directive |
| enum tableType_t |
Function Documentation
| int LZ4_compress | ( | const char * | source, |
| char * | dest, | ||
| int | inputSize | ||
| ) |
| int LZ4_compress_continue | ( | LZ4_stream_t * | LZ4_stream, |
| const char * | source, | ||
| char * | dest, | ||
| int | inputSize | ||
| ) |
| int LZ4_compress_default | ( | const char * | source, |
| char * | dest, | ||
| int | sourceSize, | ||
| int | maxDestSize | ||
| ) |
LZ4_compress_default() : Compresses 'sourceSize' bytes from buffer 'source' into already allocated 'dest' buffer of size 'maxDestSize'. Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize). It also runs faster, so it's a recommended setting. If the function cannot compress 'source' into a more limited 'dest' budget, compression stops immediately, and the function result is zero. As a consequence, 'dest' content is not valid. This function never writes outside 'dest' buffer, nor read outside 'source' buffer. sourceSize : Max supported value is LZ4_MAX_INPUT_VALUE maxDestSize : full or partial size of buffer 'dest' (which must be already allocated) return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize) or 0 if compression fails
| int LZ4_compress_destSize | ( | const char * | source, |
| char * | dest, | ||
| int * | sourceSizePtr, | ||
| int | targetDestSize | ||
| ) |
LZ4_compress_destSize() : Reverse the logic, by compressing as much data as possible from 'source' buffer into already allocated buffer 'dest' of size 'targetDestSize'. This function either compresses the entire 'source' content into 'dest' if it's large enough, or fill 'dest' buffer completely with as much data as possible from 'source'. sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'. New value is necessarily <= old value. return : Nb bytes written into 'dest' (necessarily <= targetDestSize) or 0 if compression fails
|
static |
|
static |
| int LZ4_compress_fast | ( | const char * | source, |
| char * | dest, | ||
| int | sourceSize, | ||
| int | maxDestSize, | ||
| int | acceleration | ||
| ) |
LZ4_compress_fast() : Same as LZ4_compress_default(), but allows to select an "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 ACCELERATION_DEFAULT (see lz4.c), which is 1.
| int LZ4_compress_fast_continue | ( | LZ4_stream_t * | streamPtr, |
| const char * | src, | ||
| char * | dst, | ||
| int | srcSize, | ||
| int | dstCapacity, | ||
| int | acceleration | ||
| ) |
LZ4_compress_fast_continue() : Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio. Important : Previous data blocks are assumed to remain present and unmodified ! 'dst' buffer must be already allocated. If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster. If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function returns a zero. After an error, the stream status is invalid, and it can only be reset or freed.
| int LZ4_compress_fast_extState | ( | void * | state, |
| const char * | source, | ||
| char * | dest, | ||
| int | inputSize, | ||
| int | maxOutputSize, | ||
| int | acceleration | ||
| ) |
| int LZ4_compress_fast_force | ( | const char * | source, |
| char * | dest, | ||
| int | inputSize, | ||
| int | maxOutputSize, | ||
| int | acceleration | ||
| ) |
| int LZ4_compress_forceExtDict | ( | LZ4_stream_t * | LZ4_dict, |
| const char * | source, | ||
| char * | dest, | ||
| int | inputSize | ||
| ) |
| FORCE_INLINE int LZ4_compress_generic | ( | LZ4_stream_t_internal *const | cctx, |
| const char *const | source, | ||
| char *const | dest, | ||
| const int | inputSize, | ||
| const int | maxOutputSize, | ||
| const limitedOutput_directive | outputLimited, | ||
| const tableType_t | tableType, | ||
| const dict_directive | dict, | ||
| const dictIssue_directive | dictIssue, | ||
| const U32 | acceleration | ||
| ) |
LZ4_compress_generic() : inlined, to ensure branches are decided at compilation time
| int LZ4_compress_limitedOutput | ( | const char * | source, |
| char * | dest, | ||
| int | inputSize, | ||
| int | maxOutputSize | ||
| ) |
| int LZ4_compress_limitedOutput_continue | ( | LZ4_stream_t * | LZ4_stream, |
| const char * | src, | ||
| char * | dst, | ||
| int | srcSize, | ||
| int | maxDstSize | ||
| ) |
| int LZ4_compress_limitedOutput_withState | ( | void * | state, |
| const char * | src, | ||
| char * | dst, | ||
| int | srcSize, | ||
| int | dstSize | ||
| ) |
| int LZ4_compress_withState | ( | void * | state, |
| const char * | src, | ||
| char * | dst, | ||
| int | srcSize | ||
| ) |
| int LZ4_compressBound | ( | int | inputSize | ) |
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() compress faster when dest buffer size 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 too large ( > LZ4_MAX_INPUT_SIZE)
| LZ4_stream_t* LZ4_createStream | ( | void | ) |
LZ4_createStream() and LZ4_freeStream() : LZ4_createStream() will allocate and initialize an LZ4_stream_t structure. LZ4_freeStream() releases its memory.
| LZ4_streamDecode_t* LZ4_createStreamDecode | ( | void | ) |
LZ4_createStreamDecode() and LZ4_freeStreamDecode() : creation / destruction of streaming decompression tracking structure
| int LZ4_decompress_fast | ( | const char * | source, |
| char * | dest, | ||
| int | originalSize | ||
| ) |
LZ4_decompress_fast() : originalSize : is the original and therefore uncompressed size return : the number of bytes read from the source buffer (in other words, the compressed size) If the source stream is detected malformed, the function will stop decoding and return a negative result. Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes. note : This function fully respect memory boundaries for properly formed compressed data. It is a bit faster than LZ4_decompress_safe(). However, it does not provide any protection against intentionally modified data stream (malicious input). Use this function in trusted environment only (data to decode comes from a trusted source).
| int LZ4_decompress_fast_continue | ( | LZ4_streamDecode_t * | LZ4_streamDecode, |
| const char * | source, | ||
| char * | dest, | ||
| int | originalSize | ||
| ) |
| int LZ4_decompress_fast_usingDict | ( | const char * | source, |
| char * | dest, | ||
| int | originalSize, | ||
| const char * | dictStart, | ||
| int | dictSize | ||
| ) |
| int LZ4_decompress_fast_withPrefix64k | ( | const char * | source, |
| char * | dest, | ||
| int | originalSize | ||
| ) |
| FORCE_INLINE int LZ4_decompress_generic | ( | const char *const | source, |
| char *const | dest, | ||
| int | inputSize, | ||
| int | outputSize, | ||
| int | endOnInput, | ||
| int | partialDecoding, | ||
| int | targetOutputSize, | ||
| int | dict, | ||
| const BYTE *const | lowPrefix, | ||
| const BYTE *const | dictStart, | ||
| const size_t | dictSize | ||
| ) |
LZ4_decompress_generic() : This generic decompression function cover all use cases. It shall be instantiated several times, using different sets of directives Note that it is important this generic function is really inlined, in order to remove useless branches during compilation optimization.
| int LZ4_decompress_safe | ( | const char * | source, |
| char * | dest, | ||
| int | compressedSize, | ||
| int | maxDecompressedSize | ||
| ) |
LZ4_decompress_safe() : compressedSize : is the precise full size of the compressed block. maxDecompressedSize : is the size of destination buffer, which must be already allocated. return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize) If destination buffer is not large enough, decoding will stop and output an error code (<0). If the source stream is detected malformed, the function will stop decoding and return a negative result. This function is protected against buffer overflow exploits, including malicious data packets. It never writes outside output buffer, nor reads outside input buffer.
| int LZ4_decompress_safe_continue | ( | LZ4_streamDecode_t * | LZ4_streamDecode, |
| const char * | source, | ||
| char * | dest, | ||
| int | compressedSize, | ||
| int | maxDecompressedSize | ||
| ) |
LZ4_decompress_*_continue() : These decoding functions allow decompression of multiple blocks in "streaming" mode. Previously decoded blocks must remain available at the memory position where they were decoded (up to 64 KB) In the case of a ring buffers, decoding buffer must be either :
- Exactly same size as encoding buffer, with same update rule (block boundaries at same positions) In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
- Larger than encoding buffer, by a minimum of maxBlockSize more bytes. maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block. 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).
- At least 64 KB + 8 bytes + maxBlockSize. In which case, encoding and decoding buffers do not need to be synchronized, and encoding ring buffer can have any size, including larger than decoding buffer. Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer, and indicate where it is saved using LZ4_setStreamDecode()
| int LZ4_decompress_safe_forceExtDict | ( | const char * | source, |
| char * | dest, | ||
| int | compressedSize, | ||
| int | maxOutputSize, | ||
| const char * | dictStart, | ||
| int | dictSize | ||
| ) |
| int LZ4_decompress_safe_partial | ( | const char * | source, |
| char * | dest, | ||
| int | compressedSize, | ||
| int | targetOutputSize, | ||
| int | maxDecompressedSize | ||
| ) |
LZ4_decompress_safe_partial() : This function decompress a compressed block of size 'compressedSize' at position 'source' into destination buffer 'dest' of size 'maxDecompressedSize'. The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached, reducing decompression time. return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize) Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller. Always control how many bytes were decoded. If the source stream is detected malformed, the function will stop decoding and return a negative result. This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
| int LZ4_decompress_safe_usingDict | ( | const char * | source, |
| char * | dest, | ||
| int | compressedSize, | ||
| int | maxDecompressedSize, | ||
| const char * | dictStart, | ||
| int | dictSize | ||
| ) |
LZ4_decompress_*_usingDict() : These decoding functions work the same as a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue() They are stand-alone, and don't need an LZ4_streamDecode_t structure.
| int LZ4_decompress_safe_withPrefix64k | ( | const char * | source, |
| char * | dest, | ||
| int | compressedSize, | ||
| int | maxOutputSize | ||
| ) |
| FORCE_INLINE int LZ4_decompress_usingDict_generic | ( | const char * | source, |
| char * | dest, | ||
| int | compressedSize, | ||
| int | maxOutputSize, | ||
| int | safe, | ||
| const char * | dictStart, | ||
| int | dictSize | ||
| ) |
| int LZ4_freeStream | ( | LZ4_stream_t * | LZ4_stream | ) |
| int LZ4_freeStreamDecode | ( | LZ4_streamDecode_t * | LZ4_stream | ) |
| FORCE_INLINE const BYTE* LZ4_getPosition | ( | const BYTE * | p, |
| void * | tableBase, | ||
| tableType_t | tableType, | ||
| const BYTE * | srcBase | ||
| ) |
|
static |
|
static |
|
static |
| FORCE_INLINE U32 LZ4_hashPosition | ( | const void *const | p, |
| tableType_t const | tableType | ||
| ) |
|
static |
| int LZ4_loadDict | ( | LZ4_stream_t * | streamPtr, |
| const char * | dictionary, | ||
| int | dictSize | ||
| ) |
LZ4_loadDict() : Use this function to load a static dictionary into LZ4_stream. Any previous data will be forgotten, only 'dictionary' will remain in memory. Loading a size of 0 is allowed. Return : dictionary size, in bytes (necessarily <= 64 KB)
|
static |
| FORCE_INLINE void LZ4_putPosition | ( | const BYTE * | p, |
| void * | tableBase, | ||
| tableType_t | tableType, | ||
| const BYTE * | srcBase | ||
| ) |
|
static |
| void LZ4_resetStream | ( | LZ4_stream_t * | streamPtr | ) |
LZ4_resetStream() : An LZ4_stream_t structure can be allocated once and re-used multiple times. Use this function to init an allocated LZ4_stream_t structure and start a new compression.
| int LZ4_resetStreamState | ( | void * | state, |
| char * | inputBuffer | ||
| ) |
| int LZ4_saveDict | ( | LZ4_stream_t * | LZ4_dict, |
| char * | safeBuffer, | ||
| int | dictSize | ||
| ) |
LZ4_saveDict() : If previously compressed data block is not guaranteed to remain available at its memory location, save it into a safer place (char* safeBuffer). Note : you don't need to call LZ4_loadDict() afterwards, dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue(). Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
| int LZ4_setStreamDecode | ( | LZ4_streamDecode_t * | LZ4_streamDecode, |
| const char * | dictionary, | ||
| int | dictSize | ||
| ) |
LZ4_setStreamDecode() : Use this function to instruct where to find the dictionary. This function is not necessary if previous data is still available where it was decoded. Loading a size of 0 is allowed (same effect as no dictionary). Return : 1 if OK, 0 if error
| int LZ4_sizeofState | ( | void | ) |
LZ4_compress_fast_extState() : Same compression function, just using an externally allocated memory space to store compression state. Use LZ4_sizeofState() to know how much memory must be allocated, and allocate it on 8-bytes boundaries (using malloc() typically). Then, provide it as 'void* state' to compression function.
| int LZ4_uncompress | ( | const char * | source, |
| char * | dest, | ||
| int | outputSize | ||
| ) |
| int LZ4_uncompress_unknownOutputSize | ( | const char * | source, |
| char * | dest, | ||
| int | isize, | ||
| int | maxOutputSize | ||
| ) |
| int LZ4_versionNumber | ( | void | ) |
| const char* LZ4_versionString | ( | void | ) |