lz4.c File Reference

#include "lz4.h"
#include <stdlib.h>
#include <string.h>
#include <limits.h>

Go to the source code of this file.

Macros
#define	LZ4_HEAPMODE   0
#define	LZ4_ACCELERATION_DEFAULT   1
#define	LZ4_ACCELERATION_MAX   65537
#define	LZ4_SRC_INCLUDED   1
#define	LZ4_STATIC_LINKING_ONLY
#define	LZ4_DISABLE_DEPRECATE_WARNINGS   /* due to LZ4_decompress_safe_withPrefix64k */
#define	LZ4_STATIC_LINKING_ONLY   /* LZ4_DISTANCE_MAX */
#define	LZ4_FORCE_INLINE   static
#define	LZ4_FORCE_O2
#define	expect(expr, value)   (expr)
#define	likely(expr)   expect((expr) != 0, 1)
#define	unlikely(expr)   expect((expr) != 0, 0)
#define	LZ4_ALIGN_TEST   1
#define	ALLOC(s)   malloc(s)
#define	ALLOC_AND_ZERO(s)   calloc(1,s)
#define	FREEMEM(p)   free(p)
#define	MEM_INIT(p, v, s)   memset((p),(v),(s))
#define	MINMATCH   4
#define	WILDCOPYLENGTH   8
#define	LASTLITERALS   5 /* see ../doc/lz4_Block_format.md#parsing-restrictions */
#define	MFLIMIT   12 /* see ../doc/lz4_Block_format.md#parsing-restrictions */
#define	MATCH_SAFEGUARD_DISTANCE   ((2*WILDCOPYLENGTH) - MINMATCH) /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */
#define	FASTLOOP_SAFE_DISTANCE   64
#define	KB   *(1 <<10)
#define	MB   *(1 <<20)
#define	GB   *(1U<<30)
#define	LZ4_DISTANCE_ABSOLUTE_MAX   65535
#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	assert(condition)   ((void)0)
#define	LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; } /* use after variable declarations */
#define	DEBUGLOG(l, ...)   {} /* disabled */
#define	LZ4_memcpy(dst, src, size)   memcpy(dst, src, size)
#define	LZ4_FAST_DEC_LOOP   0
#define	STEPSIZE   sizeof(reg_t)
#define	HASH_UNIT   sizeof(reg_t)
#define	MIN(a, b)   ( (a) < (b) ? (a) : (b) )

Typedefs
typedef unsigned char	BYTE
typedef unsigned short	U16
typedef unsigned int	U32
typedef signed int	S32
typedef unsigned long long	U64
typedef size_t	uptrval
typedef size_t	reg_t

Enumerations
enum	limitedOutput_directive { notLimited = 0 , limitedOutput = 1 , fillOutput = 2 }
enum	tableType_t { clearedTable = 0 , byPtr , byU32 , byU16 }
enum	dict_directive { noDict = 0 , withPrefix64k , usingExtDict , usingDictCtx }
enum	dictIssue_directive { noDictIssue = 0 , dictSmall }
enum	endCondition_directive { endOnOutputSize = 0 , endOnInputSize = 1 }
enum	earlyEnd_directive { decode_full_block = 0 , partial_decode = 1 }
enum	variable_length_error { loop_error = -2 , initial_error = -1 , ok = 0 }

Functions
static int	LZ4_isAligned (const void *ptr, size_t alignment)
static unsigned	LZ4_isLittleEndian (void)
static U16	LZ4_read16 (const void *memPtr)
static U32	LZ4_read32 (const void *memPtr)
static reg_t	LZ4_read_ARCH (const void *memPtr)
static void	LZ4_write16 (void *memPtr, U16 value)
static void	LZ4_write32 (void *memPtr, U32 value)
static U16	LZ4_readLE16 (const void *memPtr)
static void	LZ4_writeLE16 (void *memPtr, U16 value)
LZ4_FORCE_INLINE void	LZ4_wildCopy8 (void *dstPtr, const void *srcPtr, void *dstEnd)
static unsigned	LZ4_NbCommonBytes (reg_t val)
LZ4_FORCE_INLINE unsigned	LZ4_count (const BYTE *pIn, const BYTE *pMatch, const BYTE *pInLimit)
int	LZ4_versionNumber (void)
const char *	LZ4_versionString (void)
int	LZ4_compressBound (int isize)
int	LZ4_sizeofState (void)
int	LZ4_compress_forceExtDict (LZ4_stream_t *LZ4_dict, const char *source, char *dest, int srcSize)
int	LZ4_decompress_safe_forceExtDict (const char *source, char *dest, int compressedSize, int maxOutputSize, const void *dictStart, size_t dictSize)
LZ4_FORCE_INLINE U32	LZ4_hash4 (U32 sequence, tableType_t const tableType)
LZ4_FORCE_INLINE U32	LZ4_hash5 (U64 sequence, tableType_t const tableType)
LZ4_FORCE_INLINE U32	LZ4_hashPosition (const void *const p, tableType_t const tableType)
LZ4_FORCE_INLINE void	LZ4_clearHash (U32 h, void *tableBase, tableType_t const tableType)
LZ4_FORCE_INLINE void	LZ4_putIndexOnHash (U32 idx, U32 h, void *tableBase, tableType_t const tableType)
LZ4_FORCE_INLINE void	LZ4_putPositionOnHash (const BYTE *p, U32 h, void *tableBase, tableType_t const tableType, const BYTE *srcBase)
LZ4_FORCE_INLINE void	LZ4_putPosition (const BYTE *p, void *tableBase, tableType_t tableType, const BYTE *srcBase)
LZ4_FORCE_INLINE U32	LZ4_getIndexOnHash (U32 h, const void *tableBase, tableType_t tableType)
static const BYTE *	LZ4_getPositionOnHash (U32 h, const void *tableBase, tableType_t tableType, const BYTE *srcBase)
LZ4_FORCE_INLINE const BYTE *	LZ4_getPosition (const BYTE *p, const void *tableBase, tableType_t tableType, const BYTE *srcBase)
LZ4_FORCE_INLINE void	LZ4_prepareTable (LZ4_stream_t_internal *const cctx, const int inputSize, const tableType_t tableType)
LZ4_FORCE_INLINE int	LZ4_compress_generic_validated (LZ4_stream_t_internal *const cctx, const char *const source, char *const dest, const int inputSize, int *inputConsumed, const int maxOutputSize, const limitedOutput_directive outputDirective, const tableType_t tableType, const dict_directive dictDirective, const dictIssue_directive dictIssue, const int acceleration)
LZ4_FORCE_INLINE int	LZ4_compress_generic (LZ4_stream_t_internal *const cctx, const char *const src, char *const dst, const int srcSize, int *inputConsumed, const int dstCapacity, const limitedOutput_directive outputDirective, const tableType_t tableType, const dict_directive dictDirective, const dictIssue_directive dictIssue, const int acceleration)
int	LZ4_compress_fast_extState (void *state, const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration)
int	LZ4_compress_fast_extState_fastReset (void *state, const char *src, char *dst, int srcSize, int dstCapacity, int acceleration)
int	LZ4_compress_fast (const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration)
int	LZ4_compress_default (const char *src, char *dst, int srcSize, int maxOutputSize)
static int	LZ4_compress_destSize_extState (LZ4_stream_t *state, const char *src, char *dst, int *srcSizePtr, int targetDstSize)
int	LZ4_compress_destSize (const char *src, char *dst, int *srcSizePtr, int targetDstSize)
LZ4_stream_t *	LZ4_createStream (void)
static size_t	LZ4_stream_t_alignment (void)
LZ4_stream_t *	LZ4_initStream (void *buffer, size_t size)
void	LZ4_resetStream (LZ4_stream_t *LZ4_stream)
void	LZ4_resetStream_fast (LZ4_stream_t *ctx)
int	LZ4_freeStream (LZ4_stream_t *LZ4_stream)
int	LZ4_loadDict (LZ4_stream_t *LZ4_dict, const char *dictionary, int dictSize)
void	LZ4_attach_dictionary (LZ4_stream_t *workingStream, const LZ4_stream_t *dictionaryStream)
static void	LZ4_renormDictT (LZ4_stream_t_internal *LZ4_dict, int nextSize)
int	LZ4_compress_fast_continue (LZ4_stream_t *LZ4_stream, const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration)
int	LZ4_saveDict (LZ4_stream_t *LZ4_dict, char *safeBuffer, int dictSize)
LZ4_FORCE_INLINE unsigned	read_variable_length (const BYTE **ip, const BYTE *lencheck, int loop_check, int initial_check, variable_length_error *error)
LZ4_FORCE_INLINE int	LZ4_decompress_generic (const char *const src, char *const dst, int srcSize, int outputSize, endCondition_directive endOnInput, earlyEnd_directive partialDecoding, dict_directive dict, const BYTE *const lowPrefix, const BYTE *const dictStart, const size_t dictSize)
LZ4_FORCE_O2 int	LZ4_decompress_safe (const char *source, char *dest, int compressedSize, int maxDecompressedSize)
LZ4_FORCE_O2 int	LZ4_decompress_safe_partial (const char *src, char *dst, int compressedSize, int targetOutputSize, int dstCapacity)
LZ4_FORCE_O2 int	LZ4_decompress_fast (const char *source, char *dest, int originalSize)
LZ4_FORCE_O2 int	LZ4_decompress_safe_withPrefix64k (const char *source, char *dest, int compressedSize, int maxOutputSize)
int	LZ4_decompress_fast_withPrefix64k (const char *source, char *dest, int originalSize)
static LZ4_FORCE_O2 int	LZ4_decompress_safe_withSmallPrefix (const char *source, char *dest, int compressedSize, int maxOutputSize, size_t prefixSize)
static LZ4_FORCE_O2 int	LZ4_decompress_fast_extDict (const char *source, char *dest, int originalSize, const void *dictStart, size_t dictSize)
LZ4_FORCE_INLINE int	LZ4_decompress_safe_doubleDict (const char *source, char *dest, int compressedSize, int maxOutputSize, size_t prefixSize, const void *dictStart, size_t dictSize)
LZ4_FORCE_INLINE int	LZ4_decompress_fast_doubleDict (const char *source, char *dest, int originalSize, size_t prefixSize, const void *dictStart, size_t dictSize)
LZ4_streamDecode_t *	LZ4_createStreamDecode (void)
int	LZ4_freeStreamDecode (LZ4_streamDecode_t *LZ4_stream)
int	LZ4_setStreamDecode (LZ4_streamDecode_t *LZ4_streamDecode, const char *dictionary, int dictSize)
int	LZ4_decoderRingBufferSize (int maxBlockSize)
LZ4_FORCE_O2 int	LZ4_decompress_safe_continue (LZ4_streamDecode_t *LZ4_streamDecode, const char *source, char *dest, int compressedSize, int maxOutputSize)
LZ4_FORCE_O2 int	LZ4_decompress_fast_continue (LZ4_streamDecode_t *LZ4_streamDecode, const char *source, char *dest, int originalSize)
int	LZ4_decompress_safe_usingDict (const char *source, char *dest, int compressedSize, int maxOutputSize, const char *dictStart, int dictSize)
int	LZ4_decompress_fast_usingDict (const char *source, char *dest, int originalSize, const char *dictStart, int dictSize)
int	LZ4_compress_limitedOutput (const char *source, char *dest, int inputSize, int maxOutputSize)
int	LZ4_compress (const char *src, char *dest, int srcSize)
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_compress_limitedOutput_continue (LZ4_stream_t *LZ4_stream, const char *src, char *dst, int srcSize, int dstCapacity)
int	LZ4_compress_continue (LZ4_stream_t *LZ4_stream, const char *source, char *dest, int inputSize)
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_sizeofStreamState (void)
int	LZ4_resetStreamState (void *state, char *inputBuffer)
void *	LZ4_create (char *inputBuffer)
char *	LZ4_slideInputBuffer (void *state)

Variables
static const int	LZ4_minLength = (MFLIMIT+1)
static const unsigned	inc32table [8] = {0, 1, 2, 1, 0, 4, 4, 4}
static const int	dec64table [8] = {0, 0, 0, -1, -4, 1, 2, 3}
static const int	LZ4_64Klimit = ((64 KB) + (MFLIMIT-1))
static const U32	LZ4_skipTrigger = 6

Macro Definition Documentation

ALLOC

#define ALLOC

(

s

)

malloc(s)

Definition at line 202 of file lz4.c.

ALLOC_AND_ZERO

#define ALLOC_AND_ZERO

(

s

)

calloc(1,s)

Definition at line 203 of file lz4.c.

assert

#define assert

(

condition

)

((void)0)

Definition at line 245 of file lz4.c.

DEBUGLOG

#define DEBUGLOG	(		l,
			...
	)		{} /* disabled */

Definition at line 261 of file lz4.c.

expect

#define expect	(		expr,
			value
	)		(expr)

Definition at line 170 of file lz4.c.

FASTLOOP_SAFE_DISTANCE

#define FASTLOOP_SAFE_DISTANCE   64

Definition at line 220 of file lz4.c.

FREEMEM

#define FREEMEM

(

p

)

free(p)

Definition at line 204 of file lz4.c.

GB

#define GB   *(1U<<30)

Definition at line 225 of file lz4.c.

HASH_UNIT

#define HASH_UNIT   sizeof(reg_t)

Definition at line 1474 of file lz4.c.

KB

#define KB   *(1 <<10)

Definition at line 223 of file lz4.c.

LASTLITERALS

#define LASTLITERALS   5 /* see ../doc/lz4_Block_format.md#parsing-restrictions */

Definition at line 217 of file lz4.c.

likely

#define likely

(

expr

)

expect((expr) != 0, 1)

Definition at line 174 of file lz4.c.

LZ4_ACCELERATION_DEFAULT

#define LZ4_ACCELERATION_DEFAULT   1

Definition at line 51 of file lz4.c.

LZ4_ACCELERATION_MAX

#define LZ4_ACCELERATION_MAX   65537

Definition at line 57 of file lz4.c.

LZ4_ALIGN_TEST

#define LZ4_ALIGN_TEST   1

Definition at line 183 of file lz4.c.

LZ4_DISABLE_DEPRECATE_WARNINGS

#define LZ4_DISABLE_DEPRECATE_WARNINGS   /* due to LZ4_decompress_safe_withPrefix64k */

Definition at line 113 of file lz4.c.

LZ4_DISTANCE_ABSOLUTE_MAX

#define LZ4_DISTANCE_ABSOLUTE_MAX   65535

Definition at line 227 of file lz4.c.

LZ4_FAST_DEC_LOOP

#define LZ4_FAST_DEC_LOOP   0

Definition at line 430 of file lz4.c.

LZ4_FORCE_INLINE

#define LZ4_FORCE_INLINE   static

Definition at line 140 of file lz4.c.

LZ4_FORCE_O2

#define LZ4_FORCE_O2

Definition at line 164 of file lz4.c.

LZ4_HEAPMODE

#define LZ4_HEAPMODE   0

Definition at line 44 of file lz4.c.

LZ4_memcpy

#define LZ4_memcpy	(		dst,
			src,
			size
	)		memcpy(dst, src, size)

LZ4 relies on memcpy with a constant size being inlined. In freestanding environments, the compiler can't assume the implementation of memcpy() is standard compliant, so it can't apply its specialized memcpy() inlining logic. When possible, use __builtin_memcpy() to tell the compiler to analyze memcpy() as if it were standard compliant, so it can inline it in freestanding environments. This is needed when decompressing the Linux Kernel, for example.

Definition at line 322 of file lz4.c.

LZ4_SRC_INCLUDED

#define LZ4_SRC_INCLUDED   1

Definition at line 105 of file lz4.c.

LZ4_STATIC_ASSERT

#define LZ4_STATIC_ASSERT

(

c

)

{ enum { LZ4_static_assert = 1/(int)(!!(c)) }; } /* use after variable declarations */

Definition at line 249 of file lz4.c.

LZ4_STATIC_LINKING_ONLY [1/2]

#define LZ4_STATIC_LINKING_ONLY

Definition at line 116 of file lz4.c.

LZ4_STATIC_LINKING_ONLY [2/2]

#define LZ4_STATIC_LINKING_ONLY   /* LZ4_DISTANCE_MAX */

Definition at line 116 of file lz4.c.

MATCH_SAFEGUARD_DISTANCE

#define MATCH_SAFEGUARD_DISTANCE   ((2*WILDCOPYLENGTH) - MINMATCH) /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */

Definition at line 219 of file lz4.c.

MB

#define MB   *(1 <<20)

Definition at line 224 of file lz4.c.

MEM_INIT

#define MEM_INIT	(		p,
			v,
			s
	)		memset((p),(v),(s))

Definition at line 208 of file lz4.c.

MFLIMIT

#define MFLIMIT   12 /* see ../doc/lz4_Block_format.md#parsing-restrictions */

Definition at line 218 of file lz4.c.

MIN

#define MIN	(		a,
			b
	)		( (a) < (b) ? (a) : (b) )

Definition at line 1696 of file lz4.c.

MINMATCH

#define MINMATCH   4

Definition at line 214 of file lz4.c.

ML_BITS

#define ML_BITS   4

Definition at line 232 of file lz4.c.

ML_MASK

#define ML_MASK   ((1U<<ML_BITS)-1)

Definition at line 233 of file lz4.c.

RUN_BITS

#define RUN_BITS   (8-ML_BITS)

Definition at line 234 of file lz4.c.

RUN_MASK

#define RUN_MASK   ((1U<<RUN_BITS)-1)

Definition at line 235 of file lz4.c.

STEPSIZE

#define STEPSIZE   sizeof(reg_t)

Definition at line 601 of file lz4.c.

unlikely

#define unlikely

(

expr

)

expect((expr) != 0, 0)

Definition at line 177 of file lz4.c.

WILDCOPYLENGTH

#define WILDCOPYLENGTH   8

Definition at line 216 of file lz4.c.

Typedef Documentation

BYTE

typedef unsigned char BYTE

Definition at line 286 of file lz4.c.

reg_t

typedef size_t reg_t

Definition at line 297 of file lz4.c.

S32

typedef signed int S32

Definition at line 289 of file lz4.c.

U16

typedef unsigned short U16

Definition at line 287 of file lz4.c.

U32

typedef unsigned int U32

Definition at line 288 of file lz4.c.

U64

typedef unsigned long long U64

Definition at line 290 of file lz4.c.

uptrval

typedef size_t uptrval

Definition at line 291 of file lz4.c.

Enumeration Type Documentation

dict_directive

enum dict_directive

This enum distinguishes several different modes of accessing previous content in the stream.

• noDict : There is no preceding content.
• withPrefix64k : Table entries up to ctx->dictSize before the current blob blob being compressed are valid and refer to the preceding content (of length ctx->dictSize), which is available contiguously preceding in memory the content currently being compressed.
• usingExtDict : Like withPrefix64k, but the preceding content is somewhere else in memory, starting at ctx->dictionary with length ctx->dictSize.
• usingDictCtx : Like usingExtDict, but everything concerning the preceding content is in a separate context, pointed to by ctx->dictCtx. ctx->dictionary, ctx->dictSize, and table entries in the current context that refer to positions preceding the beginning of the current compression are ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx ->dictSize describe the location and size of the preceding content, and matches are found by looking in the ctx ->dictCtx->hashTable.

Enumerator
noDict
withPrefix64k
usingExtDict
usingDictCtx

Definition at line 665 of file lz4.c.

{ noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive;

dictIssue_directive

enum dictIssue_directive

Enumerator
noDictIssue
dictSmall

Definition at line 666 of file lz4.c.

{ noDictIssue = 0, dictSmall } dictIssue_directive;

earlyEnd_directive

enum earlyEnd_directive

Enumerator
decode_full_block
partial_decode

Definition at line 1693 of file lz4.c.

{ decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;

endCondition_directive

enum endCondition_directive

Enumerator
endOnOutputSize
endOnInputSize

Definition at line 1692 of file lz4.c.

{ endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;

limitedOutput_directive

enum limitedOutput_directive

Enumerator
notLimited
limitedOutput
fillOutput

Definition at line 300 of file lz4.c.

             {
    notLimited = 0,
    limitedOutput = 1,
    fillOutput = 2
} limitedOutput_directive;

tableType_t

enum tableType_t

Enumerator
clearedTable
byPtr
byU32
byU16

Definition at line 640 of file lz4.c.

{ clearedTable = 0, byPtr, byU32, byU16 } tableType_t;

variable_length_error

enum variable_length_error

Enumerator
loop_error
initial_error
ok

Definition at line 1706 of file lz4.c.

{ loop_error = -2, initial_error = -1, ok = 0 } variable_length_error;

Function Documentation

LZ4_attach_dictionary()

void LZ4_attach_dictionary	(	LZ4_stream_t *	workingStream,
		const LZ4_stream_t *	dictionaryStream
	)

Definition at line 1517 of file lz4.c.

                                                                                              {
    const LZ4_stream_t_internal* dictCtx = dictionaryStream == NULL ? NULL :
        &(dictionaryStream->internal_donotuse);
 
    DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
             workingStream, dictionaryStream,
             dictCtx != NULL ? dictCtx->dictSize : 0);
 
    if (dictCtx != NULL) {
        /* If the current offset is zero, we will never look in the
         * external dictionary context, since there is no value a table
         * entry can take that indicate a miss. In that case, we need
         * to bump the offset to something non-zero.
         */
        if (workingStream->internal_donotuse.currentOffset == 0) {
            workingStream->internal_donotuse.currentOffset = 64 KB;
        }
 
        /* Don't actually attach an empty dictionary.
         */
        if (dictCtx->dictSize == 0) {
            dictCtx = NULL;
        }
    }
    workingStream->internal_donotuse.dictCtx = dictCtx;
}

References LZ4_stream_t_internal::currentOffset, DEBUGLOG, LZ4_stream_t_internal::dictCtx, LZ4_stream_t_internal::dictSize, LZ4_stream_u::internal_donotuse, KB, and NULL.

Referenced by FUZ_test(), LZ4_compressResetStream(), LZ4F_initStream(), and state_attachDictRoundTrip().

LZ4_clearHash()

LZ4_FORCE_INLINE void LZ4_clearHash	(	U32	h,
		void *	tableBase,
		tableType_t const	tableType
	)

Definition at line 724 of file lz4.c.

{
    switch (tableType)
    {
    default: /* fallthrough */
    case clearedTable: { /* illegal! */ assert(0); return; }
    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }
    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }
    }
}

References assert, byPtr, byU16, byU32, clearedTable, h, and NULL.

Referenced by LZ4_compress_generic_validated().

LZ4_compress()

int LZ4_compress	(	const char *	src,
		char *	dest,
		int	srcSize
	)

Definition at line 2436 of file lz4.c.

{
    return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize));
}

References dest, LZ4_compress_default(), LZ4_compressBound(), src, and srcSize.

LZ4_compress_continue()

int LZ4_compress_continue	(	LZ4_stream_t *	LZ4_stream,
		const char *	source,
		char *	dest,
		int	inputSize
	)

Definition at line 2452 of file lz4.c.

{
    return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1);
}

References dest, inputSize, LZ4_compress_fast_continue(), LZ4_compressBound(), LZ4_stream, and source.

LZ4_compress_default()

int LZ4_compress_default	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity
	)

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)

Returns

: 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).

Definition at line 1373 of file lz4.c.

{
    return LZ4_compress_fast(src, dst, srcSize, maxOutputSize, 1);
}

References dst, LZ4_compress_fast(), maxOutputSize, src, and srcSize.

Referenced by bench(), fullSpeedBench(), FUZ_test(), FUZ_unitTests(), LLVMFuzzerTestOneInput(), local_LZ4_compress_default_large(), local_LZ4_compress_default_small(), LZ4_compress(), LZ4_compress_limitedOutput(), and main().

LZ4_compress_destSize()

int LZ4_compress_destSize	(	const char *	src,
		char *	dst,
		int *	srcSizePtr,
		int	targetDstSize
	)

LZ4_compress_destSize() : Reverse the logic : compresses as much data as possible from 'src' buffer into already allocated buffer 'dst', of size >= 'targetDestSize'. 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 : will be modified to indicate how many bytes where read from 'src' to fill 'dst'. New value is necessarily <= input value.

Returns

: Nb bytes written into 'dst' (necessarily <= targetDestSize) or 0 if compression fails.

Note : from v1.8.2 to v1.9.1, this function had a bug (fixed un 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

Definition at line 1399 of file lz4.c.

{
#if (LZ4_HEAPMODE)
    LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
    if (ctx == NULL) return 0;
#else
    LZ4_stream_t ctxBody;
    LZ4_stream_t* ctx = &ctxBody;
#endif
 
    int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
 
#if (LZ4_HEAPMODE)
    FREEMEM(ctx);
#endif
    return result;
}

References ALLOC, dst, FREEMEM, LZ4_compress_destSize_extState(), NULL, and src.

Referenced by FUZ_test(), FUZ_unitTests(), LLVMFuzzerTestOneInput(), and local_LZ4_compress_destSize().

LZ4_compress_destSize_extState()

static int LZ4_compress_destSize_extState ( LZ4_stream_t *  state, const char *  src, char *  dst, int *  srcSizePtr, int  targetDstSize  )

static

Definition at line 1382 of file lz4.c.

{
    void* const s = LZ4_initStream(state, sizeof (*state));
    assert(s != NULL); (void)s;
 
    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
    } else {
        if (*srcSizePtr < LZ4_64Klimit) {
            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, 1);
        } else {
            tableType_t const addrMode = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, 1);
    }   }
}

References assert, byPtr, byU16, byU32, dst, fillOutput, LZ4_64Klimit, LZ4_compress_fast_extState(), LZ4_compress_generic(), LZ4_compressBound(), LZ4_initStream(), noDict, noDictIssue, NULL, s, and src.

Referenced by LZ4_compress_destSize().

LZ4_compress_fast()

int LZ4_compress_fast	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity,
		int	acceleration
	)

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).

Definition at line 1354 of file lz4.c.

{
    int result;
#if (LZ4_HEAPMODE)
    LZ4_stream_t* ctxPtr = ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
    if (ctxPtr == NULL) return 0;
#else
    LZ4_stream_t ctx;
    LZ4_stream_t* const ctxPtr = &ctx;
#endif
    result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
 
#if (LZ4_HEAPMODE)
    FREEMEM(ctxPtr);
#endif
    return result;
}

References ALLOC, dest, FREEMEM, inputSize, LZ4_compress_fast_extState(), maxOutputSize, NULL, and source.

Referenced by bench(), local_LZ4_compress_fast0(), local_LZ4_compress_fast1(), local_LZ4_compress_fast17(), local_LZ4_compress_fast2(), LZ4_compress_default(), LZ4_compressBlockNoStream(), LZ4IO_LZ4_compress(), main(), and roundTripTest().

LZ4_compress_fast_continue()

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 '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.

Returns

: 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.

Definition at line 1565 of file lz4.c.

{
    const tableType_t tableType = byU32;
    LZ4_stream_t_internal* streamPtr = &LZ4_stream->internal_donotuse;
    const BYTE* dictEnd = streamPtr->dictionary + streamPtr->dictSize;
 
    DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i)", inputSize);
 
    LZ4_renormDictT(streamPtr, inputSize);   /* avoid index overflow */
    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
 
    /* invalidate tiny dictionaries */
    if ( (streamPtr->dictSize-1 < 4-1)   /* intentional underflow */
      && (dictEnd != (const BYTE*)source) ) {
        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary);
        streamPtr->dictSize = 0;
        streamPtr->dictionary = (const BYTE*)source;
        dictEnd = (const BYTE*)source;
    }
 
    /* Check overlapping input/dictionary space */
    {   const BYTE* sourceEnd = (const BYTE*) source + inputSize;
        if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) {
            streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
            if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
            if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
            streamPtr->dictionary = dictEnd - streamPtr->dictSize;
        }
    }
 
    /* prefix mode : source data follows dictionary */
    if (dictEnd == (const BYTE*)source) {
        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration);
        else
            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration);
    }
 
    /* external dictionary mode */
    {   int result;
        if (streamPtr->dictCtx) {
            /* We depend here on the fact that dictCtx'es (produced by
             * LZ4_loadDict) guarantee that their tables contain no references
             * to offsets between dictCtx->currentOffset - 64 KB and
             * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe
             * to use noDictIssue even when the dict isn't a full 64 KB.
             */
            if (inputSize > 4 KB) {
                /* For compressing large blobs, it is faster to pay the setup
                 * cost to copy the dictionary's tables into the active context,
                 * so that the compression loop is only looking into one table.
                 */
                LZ4_memcpy(streamPtr, streamPtr->dictCtx, sizeof(*streamPtr));
                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
            } else {
                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration);
            }
        } else {
            if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration);
            } else {
                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
            }
        }
        streamPtr->dictionary = (const BYTE*)source;
        streamPtr->dictSize = (U32)inputSize;
        return result;
    }
}

References byU32, LZ4_stream_t_internal::currentOffset, DEBUGLOG, dest, LZ4_stream_t_internal::dictCtx, LZ4_stream_t_internal::dictionary, LZ4_stream_t_internal::dictSize, dictSmall, inputSize, LZ4_stream_u::internal_donotuse, KB, limitedOutput, LZ4_ACCELERATION_DEFAULT, LZ4_ACCELERATION_MAX, LZ4_compress_generic(), LZ4_memcpy, LZ4_renormDictT(), LZ4_stream, maxOutputSize, noDictIssue, NULL, source, usingDictCtx, usingExtDict, and withPrefix64k.

Referenced by FUZ_test(), FUZ_unitTests(), local_LZ4_compress_fast_continue0(), LZ4_compress_continue(), LZ4_compress_limitedOutput_continue(), LZ4_compressBlockStream(), LZ4F_compressBlock(), LZ4F_compressBlock_continue(), state_extDictRoundTrip(), state_prefixRoundTrip(), and test_compress().

LZ4_compress_fast_extState()

int LZ4_compress_fast_extState	(	void *	state,
		const char *	source,
		char *	dest,
		int	inputSize,
		int	maxOutputSize,
		int	acceleration
	)

Definition at line 1284 of file lz4.c.

{
    LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
    assert(ctx != NULL);
    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
        if (inputSize < LZ4_64Klimit) {
            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
        } else {
            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
        }
    } else {
        if (inputSize < LZ4_64Klimit) {
            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
        } else {
            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration);
        }
    }
}

References assert, byPtr, byU16, byU32, dest, inputSize, limitedOutput, LZ4_64Klimit, LZ4_ACCELERATION_DEFAULT, LZ4_ACCELERATION_MAX, LZ4_compress_generic(), LZ4_compressBound(), LZ4_initStream(), maxOutputSize, noDict, noDictIssue, notLimited, NULL, and source.

Referenced by bench(), FUZ_test(), local_LZ4_compress_fast_extState0(), LZ4_compress_destSize_extState(), LZ4_compress_fast(), LZ4_compress_limitedOutput_withState(), LZ4_compress_withState(), and main().

LZ4_compress_fast_extState_fastReset()

int LZ4_compress_fast_extState_fastReset	(	void *	state,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity,
		int	acceleration
	)

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 comment in lz4.h on LZ4_resetStream_fast() for a definition of "correctly initialized").

Definition at line 1316 of file lz4.c.

{
    LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
 
    if (dstCapacity >= LZ4_compressBound(srcSize)) {
        if (srcSize < LZ4_64Klimit) {
            const tableType_t tableType = byU16;
            LZ4_prepareTable(ctx, srcSize, tableType);
            if (ctx->currentOffset) {
                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration);
            } else {
                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
            }
        } else {
            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
            LZ4_prepareTable(ctx, srcSize, tableType);
            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
        }
    } else {
        if (srcSize < LZ4_64Klimit) {
            const tableType_t tableType = byU16;
            LZ4_prepareTable(ctx, srcSize, tableType);
            if (ctx->currentOffset) {
                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration);
            } else {
                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
            }
        } else {
            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
            LZ4_prepareTable(ctx, srcSize, tableType);
            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
        }
    }
}

References byPtr, byU16, byU32, dictSmall, dst, limitedOutput, LZ4_64Klimit, LZ4_ACCELERATION_DEFAULT, LZ4_ACCELERATION_MAX, LZ4_compress_generic(), LZ4_compressBound(), LZ4_prepareTable(), noDict, noDictIssue, notLimited, NULL, src, and srcSize.

Referenced by FUZ_test(), and LZ4F_compressBlock().

LZ4_compress_forceExtDict()

int LZ4_compress_forceExtDict	(	LZ4_stream_t *	LZ4_dict,
		const char *	source,
		char *	dest,
		int	srcSize
	)

Definition at line 1641 of file lz4.c.

{
    LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
    int result;
 
    LZ4_renormDictT(streamPtr, srcSize);
 
    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1);
    } else {
        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
    }
 
    streamPtr->dictionary = (const BYTE*)source;
    streamPtr->dictSize = (U32)srcSize;
 
    return result;
}

References byU32, LZ4_stream_t_internal::currentOffset, dest, LZ4_stream_t_internal::dictionary, LZ4_stream_t_internal::dictSize, dictSmall, LZ4_stream_u::internal_donotuse, KB, LZ4_compress_generic(), LZ4_renormDictT(), noDictIssue, notLimited, NULL, source, srcSize, and usingExtDict.

Referenced by local_LZ4_compress_forceDict().

LZ4_compress_generic()

LZ4_FORCE_INLINE int LZ4_compress_generic	(	LZ4_stream_t_internal *const	cctx,
		const char *const	src,
		char *const	dst,
		const int	srcSize,
		int *	inputConsumed,
		const int	dstCapacity,
		const limitedOutput_directive	outputDirective,
		const tableType_t	tableType,
		const dict_directive	dictDirective,
		const dictIssue_directive	dictIssue,
		const int	acceleration
	)

LZ4_compress_generic() : inlined, to ensure branches are decided at compilation time; takes care of src == (NULL, 0) and forward the rest to LZ4_compress_generic_validated

Definition at line 1246 of file lz4.c.

{
    DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i",
                srcSize, dstCapacity);
 
    if ((U32)srcSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; }  /* Unsupported srcSize, too large (or negative) */
    if (srcSize == 0) {   /* src == NULL supported if srcSize == 0 */
        if (outputDirective != notLimited && dstCapacity <= 0) return 0;  /* no output, can't write anything */
        DEBUGLOG(5, "Generating an empty block");
        assert(outputDirective == notLimited || dstCapacity >= 1);
        assert(dst != NULL);
        dst[0] = 0;
        if (outputDirective == fillOutput) {
            assert (inputConsumed != NULL);
            *inputConsumed = 0;
        }
        return 1;
    }
    assert(src != NULL);
 
    return LZ4_compress_generic_validated(cctx, src, dst, srcSize,
                inputConsumed, /* only written into if outputDirective == fillOutput */
                dstCapacity, outputDirective,
                tableType, dictDirective, dictIssue, acceleration);
}

References assert, DEBUGLOG, dst, fillOutput, LZ4_compress_generic_validated(), LZ4_MAX_INPUT_SIZE, notLimited, NULL, src, and srcSize.

Referenced by LZ4_compress_destSize_extState(), LZ4_compress_fast_continue(), LZ4_compress_fast_extState(), LZ4_compress_fast_extState_fastReset(), and LZ4_compress_forceExtDict().

LZ4_compress_generic_validated()

LZ4_FORCE_INLINE int LZ4_compress_generic_validated	(	LZ4_stream_t_internal *const	cctx,
		const char *const	source,
		char *const	dest,
		const int	inputSize,
		int *	inputConsumed,
		const int	maxOutputSize,
		const limitedOutput_directive	outputDirective,
		const tableType_t	tableType,
		const dict_directive	dictDirective,
		const dictIssue_directive	dictIssue,
		const int	acceleration
	)

LZ4_compress_generic() : inlined, to ensure branches are decided at compilation time. Presumed already validated at this stage:

• source != NULL
• inputSize > 0

Definition at line 851 of file lz4.c.

{
    int result;
    const BYTE* ip = (const BYTE*) source;
 
    U32 const startIndex = cctx->currentOffset;
    const BYTE* base = (const BYTE*) source - startIndex;
    const BYTE* lowLimit;
 
    const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx;
    const BYTE* const dictionary =
        dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary;
    const U32 dictSize =
        dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize;
    const U32 dictDelta = (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0;   /* make indexes in dictCtx comparable with index in current context */
 
    int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx);
    U32 const prefixIdxLimit = startIndex - dictSize;   /* used when dictDirective == dictSmall */
    const BYTE* const dictEnd = dictionary ? dictionary + dictSize : dictionary;
    const BYTE* anchor = (const BYTE*) source;
    const BYTE* const iend = ip + inputSize;
    const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1;
    const BYTE* const matchlimit = iend - LASTLITERALS;
 
    /* the dictCtx currentOffset is indexed on the start of the dictionary,
     * while a dictionary in the current context precedes the currentOffset */
    const BYTE* dictBase = !dictionary ? NULL : (dictDirective == usingDictCtx) ?
                            dictionary + dictSize - dictCtx->currentOffset :
                            dictionary + dictSize - startIndex;
 
    BYTE* op = (BYTE*) dest;
    BYTE* const olimit = op + maxOutputSize;
 
    U32 offset = 0;
    U32 forwardH;
 
    DEBUGLOG(5, "LZ4_compress_generic_validated: srcSize=%i, tableType=%u", inputSize, tableType);
    assert(ip != NULL);
    /* If init conditions are not met, we don't have to mark stream
     * as having dirty context, since no action was taken yet */
    if (outputDirective == fillOutput && maxOutputSize < 1) { return 0; } /* Impossible to store anything */
    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) { return 0; }  /* Size too large (not within 64K limit) */
    if (tableType==byPtr) assert(dictDirective==noDict);      /* only supported use case with byPtr */
    assert(acceleration >= 1);
 
    lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0);
 
    /* Update context state */
    if (dictDirective == usingDictCtx) {
        /* Subsequent linked blocks can't use the dictionary. */
        /* Instead, they use the block we just compressed. */
        cctx->dictCtx = NULL;
        cctx->dictSize = (U32)inputSize;
    } else {
        cctx->dictSize += (U32)inputSize;
    }
    cctx->currentOffset += (U32)inputSize;
    cctx->tableType = (U32)tableType;
 
    if (inputSize<LZ4_minLength) goto _last_literals;        /* Input too small, no compression (all literals) */
 
    /* First Byte */
    LZ4_putPosition(ip, cctx->hashTable, tableType, base);
    ip++; forwardH = LZ4_hashPosition(ip, tableType);
 
    /* Main Loop */
    for ( ; ; ) {
        const BYTE* match;
        BYTE* token;
        const BYTE* filledIp;
 
        /* Find a match */
        if (tableType == byPtr) {
            const BYTE* forwardIp = ip;
            int step = 1;
            int searchMatchNb = acceleration << LZ4_skipTrigger;
            do {
                U32 const h = forwardH;
                ip = forwardIp;
                forwardIp += step;
                step = (searchMatchNb++ >> LZ4_skipTrigger);
 
                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
                assert(ip < mflimitPlusOne);
 
                match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);
                forwardH = LZ4_hashPosition(forwardIp, tableType);
                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);
 
            } while ( (match+LZ4_DISTANCE_MAX < ip)
                   || (LZ4_read32(match) != LZ4_read32(ip)) );
 
        } else {   /* byU32, byU16 */
 
            const BYTE* forwardIp = ip;
            int step = 1;
            int searchMatchNb = acceleration << LZ4_skipTrigger;
            do {
                U32 const h = forwardH;
                U32 const current = (U32)(forwardIp - base);
                U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
                assert(matchIndex <= current);
                assert(forwardIp - base < (ptrdiff_t)(2 GB - 1));
                ip = forwardIp;
                forwardIp += step;
                step = (searchMatchNb++ >> LZ4_skipTrigger);
 
                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
                assert(ip < mflimitPlusOne);
 
                if (dictDirective == usingDictCtx) {
                    if (matchIndex < startIndex) {
                        /* there was no match, try the dictionary */
                        assert(tableType == byU32);
                        matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
                        match = dictBase + matchIndex;
                        matchIndex += dictDelta;   /* make dictCtx index comparable with current context */
                        lowLimit = dictionary;
                    } else {
                        match = base + matchIndex;
                        lowLimit = (const BYTE*)source;
                    }
                } else if (dictDirective==usingExtDict) {
                    if (matchIndex < startIndex) {
                        DEBUGLOG(7, "extDict candidate: matchIndex=%5u  <  startIndex=%5u", matchIndex, startIndex);
                        assert(startIndex - matchIndex >= MINMATCH);
                        match = dictBase + matchIndex;
                        lowLimit = dictionary;
                    } else {
                        match = base + matchIndex;
                        lowLimit = (const BYTE*)source;
                    }
                } else {   /* single continuous memory segment */
                    match = base + matchIndex;
                }
                forwardH = LZ4_hashPosition(forwardIp, tableType);
                LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
 
                DEBUGLOG(7, "candidate at pos=%u  (offset=%u \n", matchIndex, current - matchIndex);
                if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) { continue; }    /* match outside of valid area */
                assert(matchIndex < current);
                if ( ((tableType != byU16) || (LZ4_DISTANCE_MAX < LZ4_DISTANCE_ABSOLUTE_MAX))
                  && (matchIndex+LZ4_DISTANCE_MAX < current)) {
                    continue;
                } /* too far */
                assert((current - matchIndex) <= LZ4_DISTANCE_MAX);  /* match now expected within distance */
 
                if (LZ4_read32(match) == LZ4_read32(ip)) {
                    if (maybe_extMem) offset = current - matchIndex;
                    break;   /* match found */
                }
 
            } while(1);
        }
 
        /* Catch up */
        filledIp = ip;
        while (((ip>anchor) & (match > lowLimit)) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
 
        /* Encode Literals */
        {   unsigned const litLength = (unsigned)(ip - anchor);
            token = op++;
            if ((outputDirective == limitedOutput) &&  /* Check output buffer overflow */
                (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)) ) {
                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
            }
            if ((outputDirective == fillOutput) &&
                (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) {
                op--;
                goto _last_literals;
            }
            if (litLength >= RUN_MASK) {
                int len = (int)(litLength - RUN_MASK);
                *token = (RUN_MASK<<ML_BITS);
                for(; len >= 255 ; len-=255) *op++ = 255;
                *op++ = (BYTE)len;
            }
            else *token = (BYTE)(litLength<<ML_BITS);
 
            /* Copy Literals */
            LZ4_wildCopy8(op, anchor, op+litLength);
            op+=litLength;
            DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
                        (int)(anchor-(const BYTE*)source), litLength, (int)(ip-(const BYTE*)source));
        }
 
_next_match:
        /* at this stage, the following variables must be correctly set :
         * - ip : at start of LZ operation
         * - match : at start of previous pattern occurence; can be within current prefix, or within extDict
         * - offset : if maybe_ext_memSegment==1 (constant)
         * - lowLimit : must be == dictionary to mean "match is within extDict"; must be == source otherwise
         * - token and *token : position to write 4-bits for match length; higher 4-bits for literal length supposed already written
         */
 
        if ((outputDirective == fillOutput) &&
            (op + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit)) {
            /* the match was too close to the end, rewind and go to last literals */
            op = token;
            goto _last_literals;
        }
 
        /* Encode Offset */
        if (maybe_extMem) {   /* static test */
            DEBUGLOG(6, "             with offset=%u  (ext if > %i)", offset, (int)(ip - (const BYTE*)source));
            assert(offset <= LZ4_DISTANCE_MAX && offset > 0);
            LZ4_writeLE16(op, (U16)offset); op+=2;
        } else  {
            DEBUGLOG(6, "             with offset=%u  (same segment)", (U32)(ip - match));
            assert(ip-match <= LZ4_DISTANCE_MAX);
            LZ4_writeLE16(op, (U16)(ip - match)); op+=2;
        }
 
        /* Encode MatchLength */
        {   unsigned matchCode;
 
            if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx)
              && (lowLimit==dictionary) /* match within extDict */ ) {
                const BYTE* limit = ip + (dictEnd-match);
                assert(dictEnd > match);
                if (limit > matchlimit) limit = matchlimit;
                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
                ip += (size_t)matchCode + MINMATCH;
                if (ip==limit) {
                    unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit);
                    matchCode += more;
                    ip += more;
                }
                DEBUGLOG(6, "             with matchLength=%u starting in extDict", matchCode+MINMATCH);
            } else {
                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
                ip += (size_t)matchCode + MINMATCH;
                DEBUGLOG(6, "             with matchLength=%u", matchCode+MINMATCH);
            }
 
            if ((outputDirective) &&    /* Check output buffer overflow */
                (unlikely(op + (1 + LASTLITERALS) + (matchCode+240)/255 > olimit)) ) {
                if (outputDirective == fillOutput) {
                    /* Match description too long : reduce it */
                    U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 1 - LASTLITERALS) * 255;
                    ip -= matchCode - newMatchCode;
                    assert(newMatchCode < matchCode);
                    matchCode = newMatchCode;
                    if (unlikely(ip <= filledIp)) {
                        /* We have already filled up to filledIp so if ip ends up less than filledIp
                         * we have positions in the hash table beyond the current position. This is
                         * a problem if we reuse the hash table. So we have to remove these positions
                         * from the hash table.
                         */
                        const BYTE* ptr;
                        DEBUGLOG(5, "Clearing %u positions", (U32)(filledIp - ip));
                        for (ptr = ip; ptr <= filledIp; ++ptr) {
                            U32 const h = LZ4_hashPosition(ptr, tableType);
                            LZ4_clearHash(h, cctx->hashTable, tableType);
                        }
                    }
                } else {
                    assert(outputDirective == limitedOutput);
                    return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
                }
            }
            if (matchCode >= ML_MASK) {
                *token += ML_MASK;
                matchCode -= ML_MASK;
                LZ4_write32(op, 0xFFFFFFFF);
                while (matchCode >= 4*255) {
                    op+=4;
                    LZ4_write32(op, 0xFFFFFFFF);
                    matchCode -= 4*255;
                }
                op += matchCode / 255;
                *op++ = (BYTE)(matchCode % 255);
            } else
                *token += (BYTE)(matchCode);
        }
        /* Ensure we have enough space for the last literals. */
        assert(!(outputDirective == fillOutput && op + 1 + LASTLITERALS > olimit));
 
        anchor = ip;
 
        /* Test end of chunk */
        if (ip >= mflimitPlusOne) break;
 
        /* Fill table */
        LZ4_putPosition(ip-2, cctx->hashTable, tableType, base);
 
        /* Test next position */
        if (tableType == byPtr) {
 
            match = LZ4_getPosition(ip, cctx->hashTable, tableType, base);
            LZ4_putPosition(ip, cctx->hashTable, tableType, base);
            if ( (match+LZ4_DISTANCE_MAX >= ip)
              && (LZ4_read32(match) == LZ4_read32(ip)) )
            { token=op++; *token=0; goto _next_match; }
 
        } else {   /* byU32, byU16 */
 
            U32 const h = LZ4_hashPosition(ip, tableType);
            U32 const current = (U32)(ip-base);
            U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
            assert(matchIndex < current);
            if (dictDirective == usingDictCtx) {
                if (matchIndex < startIndex) {
                    /* there was no match, try the dictionary */
                    matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
                    match = dictBase + matchIndex;
                    lowLimit = dictionary;   /* required for match length counter */
                    matchIndex += dictDelta;
                } else {
                    match = base + matchIndex;
                    lowLimit = (const BYTE*)source;  /* required for match length counter */
                }
            } else if (dictDirective==usingExtDict) {
                if (matchIndex < startIndex) {
                    match = dictBase + matchIndex;
                    lowLimit = dictionary;   /* required for match length counter */
                } else {
                    match = base + matchIndex;
                    lowLimit = (const BYTE*)source;   /* required for match length counter */
                }
            } else {   /* single memory segment */
                match = base + matchIndex;
            }
            LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
            assert(matchIndex < current);
            if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1)
              && (((tableType==byU16) && (LZ4_DISTANCE_MAX == LZ4_DISTANCE_ABSOLUTE_MAX)) ? 1 : (matchIndex+LZ4_DISTANCE_MAX >= current))
              && (LZ4_read32(match) == LZ4_read32(ip)) ) {
                token=op++;
                *token=0;
                if (maybe_extMem) offset = current - matchIndex;
                DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
                            (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source));
                goto _next_match;
            }
        }
 
        /* Prepare next loop */
        forwardH = LZ4_hashPosition(++ip, tableType);
 
    }
 
_last_literals:
    /* Encode Last Literals */
    {   size_t lastRun = (size_t)(iend - anchor);
        if ( (outputDirective) &&  /* Check output buffer overflow */
            (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) {
            if (outputDirective == fillOutput) {
                /* adapt lastRun to fill 'dst' */
                assert(olimit >= op);
                lastRun  = (size_t)(olimit-op) - 1/*token*/;
                lastRun -= (lastRun + 256 - RUN_MASK) / 256;  /*additional length tokens*/
            } else {
                assert(outputDirective == limitedOutput);
                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
            }
        }
        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRun);
        if (lastRun >= RUN_MASK) {
            size_t accumulator = lastRun - RUN_MASK;
            *op++ = RUN_MASK << ML_BITS;
            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
            *op++ = (BYTE) accumulator;
        } else {
            *op++ = (BYTE)(lastRun<<ML_BITS);
        }
        LZ4_memcpy(op, anchor, lastRun);
        ip = anchor + lastRun;
        op += lastRun;
    }
 
    if (outputDirective == fillOutput) {
        *inputConsumed = (int) (((const char*)ip)-source);
    }
    result = (int)(((char*)op) - dest);
    assert(result > 0);
    DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, result);
    return result;
}

References anchor, assert, byPtr, byU16, byU32, LZ4_stream_t_internal::currentOffset, DEBUGLOG, dest, LZ4_stream_t_internal::dictCtx, LZ4_stream_t_internal::dictionary, LZ4_stream_t_internal::dictSize, dictSmall, fillOutput, GB, h, LZ4_stream_t_internal::hashTable, inputSize, int, ip, LASTLITERALS, len, limit, limitedOutput, LZ4_64Klimit, LZ4_clearHash(), LZ4_count(), LZ4_DISTANCE_ABSOLUTE_MAX, LZ4_getIndexOnHash(), LZ4_getPosition(), LZ4_getPositionOnHash(), LZ4_hashPosition(), LZ4_memcpy, LZ4_minLength, LZ4_putIndexOnHash(), LZ4_putPosition(), LZ4_putPositionOnHash(), LZ4_read32(), LZ4_skipTrigger, LZ4_wildCopy8(), LZ4_write32(), LZ4_writeLE16(), match, maxOutputSize, MFLIMIT, MINMATCH, ML_BITS, ML_MASK, noDict, NULL, op, RUN_MASK, source, step(), LZ4_stream_t_internal::tableType, unlikely, unsigned, usingDictCtx, usingExtDict, and withPrefix64k.

Referenced by LZ4_compress_generic().

LZ4_compress_limitedOutput()

int LZ4_compress_limitedOutput	(	const char *	source,
		char *	dest,
		int	inputSize,
		int	maxOutputSize
	)

Definition at line 2432 of file lz4.c.

{
    return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
}

References dest, inputSize, LZ4_compress_default(), maxOutputSize, and source.

LZ4_compress_limitedOutput_continue()

int LZ4_compress_limitedOutput_continue	(	LZ4_stream_t *	LZ4_stream,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity
	)

Definition at line 2448 of file lz4.c.

{
    return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1);
}

References dst, LZ4_compress_fast_continue(), LZ4_stream, src, and srcSize.

LZ4_compress_limitedOutput_withState()

int LZ4_compress_limitedOutput_withState	(	void *	state,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	dstSize
	)

Definition at line 2440 of file lz4.c.

{
    return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
}

References dst, LZ4_compress_fast_extState(), src, and srcSize.

LZ4_compress_withState()

int LZ4_compress_withState	(	void *	state,
		const char *	src,
		char *	dst,
		int	srcSize
	)

Definition at line 2444 of file lz4.c.

{
    return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1);
}

References dst, LZ4_compress_fast_extState(), LZ4_compressBound(), src, and srcSize.

LZ4_compressBound()

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() 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)

Definition at line 674 of file lz4.c.

{ return LZ4_COMPRESSBOUND(isize); }

References isize, and LZ4_COMPRESSBOUND.

Referenced by BMK_benchMem(), fullSpeedBench(), FUZ_test(), FUZ_unitTests(), LLVMFuzzerTestOneInput(), local_LZ4_compress_default_large(), local_LZ4_compress_default_small(), local_LZ4_compress_destSize(), local_LZ4_compress_fast0(), local_LZ4_compress_fast1(), local_LZ4_compress_fast17(), local_LZ4_compress_fast2(), local_LZ4_compress_fast_continue0(), local_LZ4_compress_fast_extState0(), local_LZ4_compress_HC(), local_LZ4_compress_HC_continue(), local_LZ4_compress_HC_extStateHC(), LZ4_compress(), LZ4_compress_continue(), LZ4_compress_destSize_extState(), LZ4_compress_fast_extState(), LZ4_compress_fast_extState_fastReset(), LZ4_compress_HC_continue(), LZ4_compress_HC_extStateHC_fastReset(), LZ4_compress_withState(), LZ4_compressHC(), LZ4_compressHC2(), LZ4_compressHC2_withStateHC(), LZ4_compressHC_continue(), LZ4_compressHC_withStateHC(), LZ4IO_compressFilename_Legacy(), LZ4IO_decodeLegacyStream(), main(), roundTripCheck(), and state_create().

LZ4_count()

LZ4_FORCE_INLINE unsigned LZ4_count	(	const BYTE *	pIn,
		const BYTE *	pMatch,
		const BYTE *	pInLimit
	)

Definition at line 603 of file lz4.c.

{
    const BYTE* const pStart = pIn;
 
    if (likely(pIn < pInLimit-(STEPSIZE-1))) {
        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
        if (!diff) {
            pIn+=STEPSIZE; pMatch+=STEPSIZE;
        } else {
            return LZ4_NbCommonBytes(diff);
    }   }
 
    while (likely(pIn < pInLimit-(STEPSIZE-1))) {
        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
        pIn += LZ4_NbCommonBytes(diff);
        return (unsigned)(pIn - pStart);
    }
 
    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
    return (unsigned)(pIn - pStart);
}

References likely, LZ4_NbCommonBytes(), LZ4_read16(), LZ4_read32(), LZ4_read_ARCH(), and STEPSIZE.

Referenced by LZ4_compress_generic_validated(), and LZ4HC_InsertAndGetWiderMatch().

LZ4_create()

void* LZ4_create

(

char *

inputBuffer

)

Definition at line 2483 of file lz4.c.

{
    (void)inputBuffer;
    return LZ4_createStream();
}

References inputBuffer, and LZ4_createStream().

LZ4_createStream()

LZ4_stream_t* LZ4_createStream

(

void

)

Definition at line 1423 of file lz4.c.

{
    LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
    LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal));    /* A compilation error here means LZ4_STREAMSIZE is not large enough */
    DEBUGLOG(4, "LZ4_createStream %p", lz4s);
    if (lz4s == NULL) return NULL;
    LZ4_initStream(lz4s, sizeof(*lz4s));
    return lz4s;
}

References ALLOC, DEBUGLOG, LZ4_initStream(), LZ4_STATIC_ASSERT, LZ4_STREAMSIZE, test-lz4-versions::lz4s, and NULL.

Referenced by FUZ_unitTests(), LZ4_compressInitStream(), LZ4_create(), LZ4F_compressBegin_usingCDict(), LZ4F_createCDict(), state_attachDictRoundTrip(), state_create(), and test_compress().

LZ4_createStreamDecode()

LZ4_streamDecode_t* LZ4_createStreamDecode

(

void

)

LZ4_createStreamDecode() and LZ4_freeStreamDecode() : creation / destruction of streaming decompression tracking context. A tracking context can be re-used multiple times.

Definition at line 2265 of file lz4.c.

{
    LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t));
    LZ4_STATIC_ASSERT(LZ4_STREAMDECODESIZE >= sizeof(LZ4_streamDecode_t_internal));    /* A compilation error here means LZ4_STREAMDECODESIZE is not large enough */
    return lz4s;
}

References ALLOC_AND_ZERO, LZ4_STATIC_ASSERT, LZ4_STREAMDECODESIZE, and test-lz4-versions::lz4s.

Referenced by state_create(), and test_decompress().

LZ4_decoderRingBufferSize()

int LZ4_decoderRingBufferSize

(

int

maxBlockSize

)

LZ4_decoderRingBufferSize() : when setting a ring buffer for streaming decompression (optional scenario), provides the minimum size of this ring buffer to be compatible with any source respecting maxBlockSize condition. Note : in a ring buffer scenario, blocks are presumed decompressed next to each other. When not enough space remains for next block (remainingSize < maxBlockSize), decoding resumes from beginning of ring buffer.

Returns

: minimum ring buffer size, or 0 if there is an error (invalid maxBlockSize).

Definition at line 2306 of file lz4.c.

{
    if (maxBlockSize < 0) return 0;
    if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
    if (maxBlockSize < 16) maxBlockSize = 16;
    return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize);
}

References LZ4_DECODER_RING_BUFFER_SIZE, and LZ4_MAX_INPUT_SIZE.

Referenced by FUZ_unitTests().

LZ4_decompress_fast()

LZ4_FORCE_O2 int LZ4_decompress_fast	(	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.

Returns

: 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.

Definition at line 2188 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, 0, originalSize,
                                  endOnOutputSize, decode_full_block, withPrefix64k,
                                  (BYTE*)dest - 64 KB, NULL, 0);
}

References decode_full_block, dest, endOnOutputSize, KB, LZ4_decompress_generic(), NULL, originalSize, source, and withPrefix64k.

Referenced by bench(), FUZ_test(), local_LZ4_decompress_fast(), LZ4_decompress_fast_continue(), LZ4_decompress_fast_usingDict(), LZ4_decompress_fast_withPrefix64k(), and LZ4_uncompress().

LZ4_decompress_fast_continue()

LZ4_FORCE_O2 int LZ4_decompress_fast_continue	(	LZ4_streamDecode_t *	LZ4_streamDecode,
		const char *	source,
		char *	dest,
		int	originalSize
	)

Definition at line 2362 of file lz4.c.

{
    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
    int result;
    assert(originalSize >= 0);
 
    if (lz4sd->prefixSize == 0) {
        assert(lz4sd->extDictSize == 0);
        result = LZ4_decompress_fast(source, dest, originalSize);
        if (result <= 0) return result;
        lz4sd->prefixSize = (size_t)originalSize;
        lz4sd->prefixEnd = (BYTE*)dest + originalSize;
    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
        if (lz4sd->prefixSize >= 64 KB - 1 || lz4sd->extDictSize == 0)
            result = LZ4_decompress_fast(source, dest, originalSize);
        else
            result = LZ4_decompress_fast_doubleDict(source, dest, originalSize,
                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
        if (result <= 0) return result;
        lz4sd->prefixSize += (size_t)originalSize;
        lz4sd->prefixEnd  += originalSize;
    } else {
        lz4sd->extDictSize = lz4sd->prefixSize;
        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
        result = LZ4_decompress_fast_extDict(source, dest, originalSize,
                                             lz4sd->externalDict, lz4sd->extDictSize);
        if (result <= 0) return result;
        lz4sd->prefixSize = (size_t)originalSize;
        lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
    }
 
    return result;
}

References assert, dest, LZ4_streamDecode_t_internal::extDictSize, LZ4_streamDecode_t_internal::externalDict, LZ4_streamDecode_u::internal_donotuse, KB, LZ4_decompress_fast(), LZ4_decompress_fast_doubleDict(), LZ4_decompress_fast_extDict(), originalSize, LZ4_streamDecode_t_internal::prefixEnd, LZ4_streamDecode_t_internal::prefixSize, and source.

Referenced by FUZ_unitTests().

LZ4_decompress_fast_doubleDict()

LZ4_FORCE_INLINE int LZ4_decompress_fast_doubleDict	(	const char *	source,
		char *	dest,
		int	originalSize,
		size_t	prefixSize,
		const void *	dictStart,
		size_t	dictSize
	)

Definition at line 2255 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, 0, originalSize,
                                  endOnOutputSize, decode_full_block, usingExtDict,
                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
}

References decode_full_block, dest, endOnOutputSize, LZ4_decompress_generic(), originalSize, source, and usingExtDict.

Referenced by LZ4_decompress_fast_continue().

LZ4_decompress_fast_extDict()

static LZ4_FORCE_O2 int LZ4_decompress_fast_extDict ( const char *  source, char *  dest, int  originalSize, const void *  dictStart, size_t  dictSize  )

static

Definition at line 2233 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, 0, originalSize,
                                  endOnOutputSize, decode_full_block, usingExtDict,
                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
}

References decode_full_block, dest, endOnOutputSize, LZ4_decompress_generic(), originalSize, source, and usingExtDict.

Referenced by LZ4_decompress_fast_continue(), and LZ4_decompress_fast_usingDict().

LZ4_decompress_fast_usingDict()

int LZ4_decompress_fast_usingDict	(	const char *	source,
		char *	dest,
		int	originalSize,
		const char *	dictStart,
		int	dictSize
	)

Definition at line 2419 of file lz4.c.

{
    if (dictSize==0 || dictStart+dictSize == dest)
        return LZ4_decompress_fast(source, dest, originalSize);
    assert(dictSize >= 0);
    return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize);
}

References assert, dest, LZ4_decompress_fast(), LZ4_decompress_fast_extDict(), originalSize, and source.

Referenced by FUZ_test(), local_LZ4_decompress_fast_usingDict_prefix(), and local_LZ4_decompress_fast_usingExtDict().

LZ4_decompress_fast_withPrefix64k()

int LZ4_decompress_fast_withPrefix64k	(	const char *	source,
		char *	dest,
		int	originalSize
	)

Definition at line 2206 of file lz4.c.

{
    /* LZ4_decompress_fast doesn't validate match offsets,
     * and thus serves well with any prefixed dictionary. */
    return LZ4_decompress_fast(source, dest, originalSize);
}

References dest, LZ4_decompress_fast(), originalSize, and source.

LZ4_decompress_generic()

LZ4_FORCE_INLINE int LZ4_decompress_generic	(	const char *const	src,
		char *const	dst,
		int	srcSize,
		int	outputSize,
		endCondition_directive	endOnInput,
		earlyEnd_directive	partialDecoding,
		dict_directive	dict,
		const BYTE *const	lowPrefix,
		const BYTE *const	dictStart,
		const size_t	dictSize
	)

LZ4_decompress_generic() : This generic decompression function covers all use cases. It shall be instantiated several times, using different sets of directives. Note that it is important for performance that this function really get inlined, in order to remove useless branches during compilation optimization.

Definition at line 1738 of file lz4.c.

{
    if (src == NULL) { return -1; }
 
    {   const BYTE* ip = (const BYTE*) src;
        const BYTE* const iend = ip + srcSize;
 
        BYTE* op = (BYTE*) dst;
        BYTE* const oend = op + outputSize;
        BYTE* cpy;
 
        const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize;
 
        const int safeDecode = (endOnInput==endOnInputSize);
        const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
 
 
        /* Set up the "end" pointers for the shortcut. */
        const BYTE* const shortiend = iend - (endOnInput ? 14 : 8) /*maxLL*/ - 2 /*offset*/;
        const BYTE* const shortoend = oend - (endOnInput ? 14 : 8) /*maxLL*/ - 18 /*maxML*/;
 
        const BYTE* match;
        size_t offset;
        unsigned token;
        size_t length;
 
 
        DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i, dstSize:%i)", srcSize, outputSize);
 
        /* Special cases */
        assert(lowPrefix <= op);
        if ((endOnInput) && (unlikely(outputSize==0))) {
            /* Empty output buffer */
            if (partialDecoding) return 0;
            return ((srcSize==1) && (*ip==0)) ? 0 : -1;
        }
        if ((!endOnInput) && (unlikely(outputSize==0))) { return (*ip==0 ? 1 : -1); }
        if ((endOnInput) && unlikely(srcSize==0)) { return -1; }
 
    /* Currently the fast loop shows a regression on qualcomm arm chips. */
#if LZ4_FAST_DEC_LOOP
        if ((oend - op) < FASTLOOP_SAFE_DISTANCE) {
            DEBUGLOG(6, "skip fast decode loop");
            goto safe_decode;
        }
 
        /* Fast loop : decode sequences as long as output < iend-FASTLOOP_SAFE_DISTANCE */
        while (1) {
            /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */
            assert(oend - op >= FASTLOOP_SAFE_DISTANCE);
            if (endOnInput) { assert(ip < iend); }
            token = *ip++;
            length = token >> ML_BITS;  /* literal length */
 
            assert(!endOnInput || ip <= iend); /* ip < iend before the increment */
 
            /* decode literal length */
            if (length == RUN_MASK) {
                variable_length_error error = ok;
                length += read_variable_length(&ip, iend-RUN_MASK, (int)endOnInput, (int)endOnInput, &error);
                if (error == initial_error) { goto _output_error; }
                if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
                if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
 
                /* copy literals */
                cpy = op+length;
                LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
                if (endOnInput) {  /* LZ4_decompress_safe() */
                    if ((cpy>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; }
                    LZ4_wildCopy32(op, ip, cpy);
                } else {   /* LZ4_decompress_fast() */
                    if (cpy>oend-8) { goto safe_literal_copy; }
                    LZ4_wildCopy8(op, ip, cpy); /* LZ4_decompress_fast() cannot copy more than 8 bytes at a time :
                                                 * it doesn't know input length, and only relies on end-of-block properties */
                }
                ip += length; op = cpy;
            } else {
                cpy = op+length;
                if (endOnInput) {  /* LZ4_decompress_safe() */
                    DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length);
                    /* We don't need to check oend, since we check it once for each loop below */
                    if (ip > iend-(16 + 1/*max lit + offset + nextToken*/)) { goto safe_literal_copy; }
                    /* Literals can only be 14, but hope compilers optimize if we copy by a register size */
                    LZ4_memcpy(op, ip, 16);
                } else {  /* LZ4_decompress_fast() */
                    /* LZ4_decompress_fast() cannot copy more than 8 bytes at a time :
                     * it doesn't know input length, and relies on end-of-block properties */
                    LZ4_memcpy(op, ip, 8);
                    if (length > 8) { LZ4_memcpy(op+8, ip+8, 8); }
                }
                ip += length; op = cpy;
            }
 
            /* get offset */
            offset = LZ4_readLE16(ip); ip+=2;
            match = op - offset;
            assert(match <= op);
 
            /* get matchlength */
            length = token & ML_MASK;
 
            if (length == ML_MASK) {
                variable_length_error error = ok;
                if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */
                length += read_variable_length(&ip, iend - LASTLITERALS + 1, (int)endOnInput, 0, &error);
                if (error != ok) { goto _output_error; }
                if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */
                length += MINMATCH;
                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
                    goto safe_match_copy;
                }
            } else {
                length += MINMATCH;
                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
                    goto safe_match_copy;
                }
 
                /* Fastpath check: Avoids a branch in LZ4_wildCopy32 if true */
                if ((dict == withPrefix64k) || (match >= lowPrefix)) {
                    if (offset >= 8) {
                        assert(match >= lowPrefix);
                        assert(match <= op);
                        assert(op + 18 <= oend);
 
                        LZ4_memcpy(op, match, 8);
                        LZ4_memcpy(op+8, match+8, 8);
                        LZ4_memcpy(op+16, match+16, 2);
                        op += length;
                        continue;
            }   }   }
 
            if (checkOffset && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */
            /* match starting within external dictionary */
            if ((dict==usingExtDict) && (match < lowPrefix)) {
                if (unlikely(op+length > oend-LASTLITERALS)) {
                    if (partialDecoding) {
                        DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd");
                        length = MIN(length, (size_t)(oend-op));
                    } else {
                        goto _output_error;  /* end-of-block condition violated */
                }   }
 
                if (length <= (size_t)(lowPrefix-match)) {
                    /* match fits entirely within external dictionary : just copy */
                    memmove(op, dictEnd - (lowPrefix-match), length);
                    op += length;
                } else {
                    /* match stretches into both external dictionary and current block */
                    size_t const copySize = (size_t)(lowPrefix - match);
                    size_t const restSize = length - copySize;
                    LZ4_memcpy(op, dictEnd - copySize, copySize);
                    op += copySize;
                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
                        BYTE* const endOfMatch = op + restSize;
                        const BYTE* copyFrom = lowPrefix;
                        while (op < endOfMatch) { *op++ = *copyFrom++; }
                    } else {
                        LZ4_memcpy(op, lowPrefix, restSize);
                        op += restSize;
                }   }
                continue;
            }
 
            /* copy match within block */
            cpy = op + length;
 
            assert((op <= oend) && (oend-op >= 32));
            if (unlikely(offset<16)) {
                LZ4_memcpy_using_offset(op, match, cpy, offset);
            } else {
                LZ4_wildCopy32(op, match, cpy);
            }
 
            op = cpy;   /* wildcopy correction */
        }
    safe_decode:
#endif
 
        /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */
        while (1) {
            token = *ip++;
            length = token >> ML_BITS;  /* literal length */
 
            assert(!endOnInput || ip <= iend); /* ip < iend before the increment */
 
            /* A two-stage shortcut for the most common case:
             * 1) If the literal length is 0..14, and there is enough space,
             * enter the shortcut and copy 16 bytes on behalf of the literals
             * (in the fast mode, only 8 bytes can be safely copied this way).
             * 2) Further if the match length is 4..18, copy 18 bytes in a similar
             * manner; but we ensure that there's enough space in the output for
             * those 18 bytes earlier, upon entering the shortcut (in other words,
             * there is a combined check for both stages).
             */
            if ( (endOnInput ? length != RUN_MASK : length <= 8)
                /* strictly "less than" on input, to re-enter the loop with at least one byte */
              && likely((endOnInput ? ip < shortiend : 1) & (op <= shortoend)) ) {
                /* Copy the literals */
                LZ4_memcpy(op, ip, endOnInput ? 16 : 8);
                op += length; ip += length;
 
                /* The second stage: prepare for match copying, decode full info.
                 * If it doesn't work out, the info won't be wasted. */
                length = token & ML_MASK; /* match length */
                offset = LZ4_readLE16(ip); ip += 2;
                match = op - offset;
                assert(match <= op); /* check overflow */
 
                /* Do not deal with overlapping matches. */
                if ( (length != ML_MASK)
                  && (offset >= 8)
                  && (dict==withPrefix64k || match >= lowPrefix) ) {
                    /* Copy the match. */
                    LZ4_memcpy(op + 0, match + 0, 8);
                    LZ4_memcpy(op + 8, match + 8, 8);
                    LZ4_memcpy(op +16, match +16, 2);
                    op += length + MINMATCH;
                    /* Both stages worked, load the next token. */
                    continue;
                }
 
                /* The second stage didn't work out, but the info is ready.
                 * Propel it right to the point of match copying. */
                goto _copy_match;
            }
 
            /* decode literal length */
            if (length == RUN_MASK) {
                variable_length_error error = ok;
                length += read_variable_length(&ip, iend-RUN_MASK, (int)endOnInput, (int)endOnInput, &error);
                if (error == initial_error) { goto _output_error; }
                if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
                if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
            }
 
            /* copy literals */
            cpy = op+length;
#if LZ4_FAST_DEC_LOOP
        safe_literal_copy:
#endif
            LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
            if ( ((endOnInput) && ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) )
              || ((!endOnInput) && (cpy>oend-WILDCOPYLENGTH)) )
            {
                /* We've either hit the input parsing restriction or the output parsing restriction.
                 * In the normal scenario, decoding a full block, it must be the last sequence,
                 * otherwise it's an error (invalid input or dimensions).
                 * In partialDecoding scenario, it's necessary to ensure there is no buffer overflow.
                 */
                if (partialDecoding) {
                    /* Since we are partial decoding we may be in this block because of the output parsing
                     * restriction, which is not valid since the output buffer is allowed to be undersized.
                     */
                    assert(endOnInput);
                    DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end")
                    DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length);
                    DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op));
                    DEBUGLOG(7, "partialDecoding: remaining space in srcBuffer : %i", (int)(iend - ip));
                    /* Finishing in the middle of a literals segment,
                     * due to lack of input.
                     */
                    if (ip+length > iend) {
                        length = (size_t)(iend-ip);
                        cpy = op + length;
                    }
                    /* Finishing in the middle of a literals segment,
                     * due to lack of output space.
                     */
                    if (cpy > oend) {
                        cpy = oend;
                        assert(op<=oend);
                        length = (size_t)(oend-op);
                    }
                } else {
                    /* We must be on the last sequence because of the parsing limitations so check
                     * that we exactly regenerate the original size (must be exact when !endOnInput).
                     */
                    if ((!endOnInput) && (cpy != oend)) { goto _output_error; }
                     /* We must be on the last sequence (or invalid) because of the parsing limitations
                      * so check that we exactly consume the input and don't overrun the output buffer.
                      */
                    if ((endOnInput) && ((ip+length != iend) || (cpy > oend))) {
                        DEBUGLOG(6, "should have been last run of literals")
                        DEBUGLOG(6, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend);
                        DEBUGLOG(6, "or cpy(%p) > oend(%p)", cpy, oend);
                        goto _output_error;
                    }
                }
                memmove(op, ip, length);  /* supports overlapping memory regions; only matters for in-place decompression scenarios */
                ip += length;
                op += length;
                /* Necessarily EOF when !partialDecoding.
                 * When partialDecoding, it is EOF if we've either
                 * filled the output buffer or
                 * can't proceed with reading an offset for following match.
                 */
                if (!partialDecoding || (cpy == oend) || (ip >= (iend-2))) {
                    break;
                }
            } else {
                LZ4_wildCopy8(op, ip, cpy);   /* may overwrite up to WILDCOPYLENGTH beyond cpy */
                ip += length; op = cpy;
            }
 
            /* get offset */
            offset = LZ4_readLE16(ip); ip+=2;
            match = op - offset;
 
            /* get matchlength */
            length = token & ML_MASK;
 
    _copy_match:
            if (length == ML_MASK) {
              variable_length_error error = ok;
              length += read_variable_length(&ip, iend - LASTLITERALS + 1, (int)endOnInput, 0, &error);
              if (error != ok) goto _output_error;
                if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
            }
            length += MINMATCH;
 
#if LZ4_FAST_DEC_LOOP
        safe_match_copy:
#endif
            if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error;   /* Error : offset outside buffers */
            /* match starting within external dictionary */
            if ((dict==usingExtDict) && (match < lowPrefix)) {
                if (unlikely(op+length > oend-LASTLITERALS)) {
                    if (partialDecoding) length = MIN(length, (size_t)(oend-op));
                    else goto _output_error;   /* doesn't respect parsing restriction */
                }
 
                if (length <= (size_t)(lowPrefix-match)) {
                    /* match fits entirely within external dictionary : just copy */
                    memmove(op, dictEnd - (lowPrefix-match), length);
                    op += length;
                } else {
                    /* match stretches into both external dictionary and current block */
                    size_t const copySize = (size_t)(lowPrefix - match);
                    size_t const restSize = length - copySize;
                    LZ4_memcpy(op, dictEnd - copySize, copySize);
                    op += copySize;
                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
                        BYTE* const endOfMatch = op + restSize;
                        const BYTE* copyFrom = lowPrefix;
                        while (op < endOfMatch) *op++ = *copyFrom++;
                    } else {
                        LZ4_memcpy(op, lowPrefix, restSize);
                        op += restSize;
                }   }
                continue;
            }
            assert(match >= lowPrefix);
 
            /* copy match within block */
            cpy = op + length;
 
            /* partialDecoding : may end anywhere within the block */
            assert(op<=oend);
            if (partialDecoding && (cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
                size_t const mlen = MIN(length, (size_t)(oend-op));
                const BYTE* const matchEnd = match + mlen;
                BYTE* const copyEnd = op + mlen;
                if (matchEnd > op) {   /* overlap copy */
                    while (op < copyEnd) { *op++ = *match++; }
                } else {
                    LZ4_memcpy(op, match, mlen);
                }
                op = copyEnd;
                if (op == oend) { break; }
                continue;
            }
 
            if (unlikely(offset<8)) {
                LZ4_write32(op, 0);   /* silence msan warning when offset==0 */
                op[0] = match[0];
                op[1] = match[1];
                op[2] = match[2];
                op[3] = match[3];
                match += inc32table[offset];
                LZ4_memcpy(op+4, match, 4);
                match -= dec64table[offset];
            } else {
                LZ4_memcpy(op, match, 8);
                match += 8;
            }
            op += 8;
 
            if (unlikely(cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
                BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH-1);
                if (cpy > oend-LASTLITERALS) { goto _output_error; } /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
                if (op < oCopyLimit) {
                    LZ4_wildCopy8(op, match, oCopyLimit);
                    match += oCopyLimit - op;
                    op = oCopyLimit;
                }
                while (op < cpy) { *op++ = *match++; }
            } else {
                LZ4_memcpy(op, match, 8);
                if (length > 16)  { LZ4_wildCopy8(op+8, match+8, cpy); }
            }
            op = cpy;   /* wildcopy correction */
        }
 
        /* end of decoding */
        if (endOnInput) {
            DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst));
           return (int) (((char*)op)-dst);     /* Nb of output bytes decoded */
       } else {
           return (int) (((const char*)ip)-src);   /* Nb of input bytes read */
       }
 
        /* Overflow error detected */
    _output_error:
        return (int) (-(((const char*)ip)-src))-1;
    }
}

References assert, DEBUGLOG, dec64table, dst, endOnInputSize, error(), FASTLOOP_SAFE_DISTANCE, inc32table, initial_error, ip, KB, LASTLITERALS, length, likely, LZ4_memcpy, LZ4_readLE16(), LZ4_STATIC_ASSERT, LZ4_wildCopy8(), LZ4_write32(), match, MATCH_SAFEGUARD_DISTANCE, MFLIMIT, MIN, MINMATCH, ML_BITS, ML_MASK, NULL, ok, op, outputSize, read_variable_length(), RUN_MASK, src, srcSize, unlikely, usingExtDict, WILDCOPYLENGTH, and withPrefix64k.

Referenced by LZ4_decompress_fast(), LZ4_decompress_fast_doubleDict(), LZ4_decompress_fast_extDict(), LZ4_decompress_safe(), LZ4_decompress_safe_doubleDict(), LZ4_decompress_safe_forceExtDict(), LZ4_decompress_safe_partial(), LZ4_decompress_safe_withPrefix64k(), and LZ4_decompress_safe_withSmallPrefix().

LZ4_decompress_safe()

LZ4_FORCE_O2 int LZ4_decompress_safe	(	const char *	src,
		char *	dst,
		int	compressedSize,
		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.

Returns

: 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.

Definition at line 2171 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
                                  endOnInputSize, decode_full_block, noDict,
                                  (BYTE*)dest, NULL, 0);
}

References compressedSize, decode_full_block, dest, endOnInputSize, LZ4_decompress_generic(), noDict, NULL, and source.

Referenced by bench(), decompress(), fullSpeedBench(), FUZ_AddressOverflow(), FUZ_test(), FUZ_unitTests(), LLVMFuzzerTestOneInput(), LZ4_decompress_safe_continue(), LZ4_decompress_safe_usingDict(), LZ4_uncompress_unknownOutputSize(), LZ4IO_decodeLegacyStream(), main(), and roundTripTest().

LZ4_decompress_safe_continue()

LZ4_FORCE_O2 int LZ4_decompress_safe_continue	(	LZ4_streamDecode_t *	LZ4_streamDecode,
		const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapacity
	)

LZ4_decompress_*_continue() : These decoding functions allow decompression of consecutive blocks in "streaming" mode. A block is an unsplittable entity, it must be presented entirely to a decompression function. Decompression functions only accepts one block at a time. The last 64KB of previously decoded data must remain available and unmodified at the memory position where they were 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.

Definition at line 2322 of file lz4.c.

{
    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
    int result;
 
    if (lz4sd->prefixSize == 0) {
        /* The first call, no dictionary yet. */
        assert(lz4sd->extDictSize == 0);
        result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
        if (result <= 0) return result;
        lz4sd->prefixSize = (size_t)result;
        lz4sd->prefixEnd = (BYTE*)dest + result;
    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
        /* They're rolling the current segment. */
        if (lz4sd->prefixSize >= 64 KB - 1)
            result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
        else if (lz4sd->extDictSize == 0)
            result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize,
                                                         lz4sd->prefixSize);
        else
            result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize,
                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
        if (result <= 0) return result;
        lz4sd->prefixSize += (size_t)result;
        lz4sd->prefixEnd  += result;
    } else {
        /* The buffer wraps around, or they're switching to another buffer. */
        lz4sd->extDictSize = lz4sd->prefixSize;
        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
        result = LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize,
                                                  lz4sd->externalDict, lz4sd->extDictSize);
        if (result <= 0) return result;
        lz4sd->prefixSize = (size_t)result;
        lz4sd->prefixEnd  = (BYTE*)dest + result;
    }
 
    return result;
}

References assert, compressedSize, dest, LZ4_streamDecode_t_internal::extDictSize, LZ4_streamDecode_t_internal::externalDict, LZ4_streamDecode_u::internal_donotuse, KB, LZ4_decompress_safe(), LZ4_decompress_safe_doubleDict(), LZ4_decompress_safe_forceExtDict(), LZ4_decompress_safe_withPrefix64k(), LZ4_decompress_safe_withSmallPrefix(), maxOutputSize, LZ4_streamDecode_t_internal::prefixEnd, LZ4_streamDecode_t_internal::prefixSize, and source.

Referenced by FUZ_unitTests(), state_decompress(), and test_decompress().

LZ4_decompress_safe_doubleDict()

LZ4_FORCE_INLINE int LZ4_decompress_safe_doubleDict	(	const char *	source,
		char *	dest,
		int	compressedSize,
		int	maxOutputSize,
		size_t	prefixSize,
		const void *	dictStart,
		size_t	dictSize
	)

Definition at line 2246 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
                                  endOnInputSize, decode_full_block, usingExtDict,
                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
}

References compressedSize, decode_full_block, dest, endOnInputSize, LZ4_decompress_generic(), maxOutputSize, source, and usingExtDict.

Referenced by LZ4_decompress_safe_continue().

LZ4_decompress_safe_forceExtDict()

LZ4_FORCE_O2 int LZ4_decompress_safe_forceExtDict	(	const char *	source,
		char *	dest,
		int	compressedSize,
		int	maxOutputSize,
		const void *	dictStart,
		size_t	dictSize
	)

Definition at line 2223 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
                                  endOnInputSize, decode_full_block, usingExtDict,
                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
}

References compressedSize, decode_full_block, dest, endOnInputSize, LZ4_decompress_generic(), maxOutputSize, source, and usingExtDict.

Referenced by local_LZ4_decompress_safe_forceExtDict(), LZ4_decompress_safe_continue(), and LZ4_decompress_safe_usingDict().

LZ4_decompress_safe_partial()

LZ4_FORCE_O2 int LZ4_decompress_safe_partial	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	targetOutputSize,
		int	dstCapacity
	)

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.

Returns

: the number of bytes decoded in dst (necessarily <= targetOutputSize) If source stream is detected malformed, function returns a negative result.

Note 1 :

Returns

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.

Definition at line 2179 of file lz4.c.

{
    dstCapacity = MIN(targetOutputSize, dstCapacity);
    return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity,
                                  endOnInputSize, partial_decode,
                                  noDict, (BYTE*)dst, NULL, 0);
}

References compressedSize, dst, endOnInputSize, LZ4_decompress_generic(), MIN, noDict, NULL, partial_decode, and src.

Referenced by FUZ_test(), LLVMFuzzerTestOneInput(), local_LZ4_decompress_safe_partial(), and main().

LZ4_decompress_safe_usingDict()

int LZ4_decompress_safe_usingDict	(	const char *	src,
		char *	dst,
		int	srcSize,
		int	dstCapcity,
		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. Dictionary is presumed stable : it must remain accessible and unmodified during decompression. Performance tip : Decompression speed can be substantially increased when dst == dictStart + dictSize.

Definition at line 2404 of file lz4.c.

{
    if (dictSize==0)
        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
    if (dictStart+dictSize == dest) {
        if (dictSize >= 64 KB - 1) {
            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
        }
        assert(dictSize >= 0);
        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize);
    }
    assert(dictSize >= 0);
    return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
}

References assert, compressedSize, dest, KB, LZ4_decompress_safe(), LZ4_decompress_safe_forceExtDict(), LZ4_decompress_safe_withPrefix64k(), LZ4_decompress_safe_withSmallPrefix(), maxOutputSize, and source.

Referenced by BMK_benchMem(), FUZ_test(), FUZ_unitTests(), LLVMFuzzerTestOneInput(), local_LZ4_decompress_safe_usingDict(), and LZ4F_decompress().

LZ4_decompress_safe_withPrefix64k()

LZ4_FORCE_O2 int LZ4_decompress_safe_withPrefix64k	(	const char *	source,
		char *	dest,
		int	compressedSize,
		int	maxOutputSize
	)

Definition at line 2198 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
                                  endOnInputSize, decode_full_block, withPrefix64k,
                                  (BYTE*)dest - 64 KB, NULL, 0);
}

References compressedSize, decode_full_block, dest, endOnInputSize, KB, LZ4_decompress_generic(), maxOutputSize, NULL, source, and withPrefix64k.

Referenced by local_LZ4_decompress_safe_withPrefix64k(), LZ4_decompress_safe_continue(), and LZ4_decompress_safe_usingDict().

LZ4_decompress_safe_withSmallPrefix()

static LZ4_FORCE_O2 int LZ4_decompress_safe_withSmallPrefix ( const char *  source, char *  dest, int  compressedSize, int  maxOutputSize, size_t  prefixSize  )

static

Definition at line 2214 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
                                  endOnInputSize, decode_full_block, noDict,
                                  (BYTE*)dest-prefixSize, NULL, 0);
}

References compressedSize, decode_full_block, dest, endOnInputSize, LZ4_decompress_generic(), maxOutputSize, noDict, NULL, and source.

Referenced by LZ4_decompress_safe_continue(), and LZ4_decompress_safe_usingDict().

LZ4_freeStream()

int LZ4_freeStream

(

LZ4_stream_t *

LZ4_stream

)

Definition at line 1465 of file lz4.c.

{
    if (!LZ4_stream) return 0;   /* support free on NULL */
    DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
    FREEMEM(LZ4_stream);
    return (0);
}

References DEBUGLOG, FREEMEM, and LZ4_stream.

Referenced by FUZ_unitTests(), LZ4_compressCleanupStream(), LZ4F_freeCDict(), state_attachDictRoundTrip(), state_free(), and test_compress().

LZ4_freeStreamDecode()

int LZ4_freeStreamDecode

(

LZ4_streamDecode_t *

LZ4_stream

)

Definition at line 2272 of file lz4.c.

{
    if (LZ4_stream == NULL) { return 0; }  /* support free on NULL */
    FREEMEM(LZ4_stream);
    return 0;
}

References FREEMEM, LZ4_stream, and NULL.

Referenced by state_free(), and test_decompress().

LZ4_getIndexOnHash()

LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash	(	U32	h,
		const void *	tableBase,
		tableType_t	tableType
	)

Definition at line 773 of file lz4.c.

{
    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
    if (tableType == byU32) {
        const U32* const hashTable = (const U32*) tableBase;
        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));
        return hashTable[h];
    }
    if (tableType == byU16) {
        const U16* const hashTable = (const U16*) tableBase;
        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));
        return hashTable[h];
    }
    assert(0); return 0;  /* forbidden case */
}

References assert, byU16, byU32, h, LZ4_MEMORY_USAGE, and LZ4_STATIC_ASSERT.

Referenced by LZ4_compress_generic_validated().

LZ4_getPosition()

LZ4_FORCE_INLINE const BYTE* LZ4_getPosition	(	const BYTE *	p,
		const void *	tableBase,
		tableType_t	tableType,
		const BYTE *	srcBase
	)

Definition at line 797 of file lz4.c.

{
    U32 const h = LZ4_hashPosition(p, tableType);
    return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
}

References h, LZ4_getPositionOnHash(), LZ4_hashPosition(), and p.

Referenced by LZ4_compress_generic_validated().

LZ4_getPositionOnHash()

static const BYTE* LZ4_getPositionOnHash ( U32  h, const void *  tableBase, tableType_t  tableType, const BYTE *  srcBase  )

static

Definition at line 789 of file lz4.c.

{
    if (tableType == byPtr) { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; }
    if (tableType == byU32) { const U32* const hashTable = (const U32*) tableBase; return hashTable[h] + srcBase; }
    { const U16* const hashTable = (const U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */
}

References byPtr, byU32, and h.

Referenced by LZ4_compress_generic_validated(), and LZ4_getPosition().

LZ4_hash4()

LZ4_FORCE_INLINE U32 LZ4_hash4	(	U32	sequence,
		tableType_t const	tableType
	)

Definition at line 698 of file lz4.c.

{
    if (tableType == byU16)
        return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
    else
        return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
}

References byU16, LZ4_HASHLOG, and MINMATCH.

Referenced by LZ4_hashPosition().

LZ4_hash5()

LZ4_FORCE_INLINE U32 LZ4_hash5	(	U64	sequence,
		tableType_t const	tableType
	)

Definition at line 706 of file lz4.c.

{
    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
    if (LZ4_isLittleEndian()) {
        const U64 prime5bytes = 889523592379ULL;
        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
    } else {
        const U64 prime8bytes = 11400714785074694791ULL;
        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
    }
}

References byU16, LZ4_HASHLOG, and LZ4_isLittleEndian().

Referenced by LZ4_hashPosition().

LZ4_hashPosition()

LZ4_FORCE_INLINE U32 LZ4_hashPosition	(	const void *const	p,
		tableType_t const	tableType
	)

Definition at line 718 of file lz4.c.

{
    if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
    return LZ4_hash4(LZ4_read32(p), tableType);
}

References byU16, LZ4_hash4(), LZ4_hash5(), LZ4_read32(), LZ4_read_ARCH(), and p.

Referenced by LZ4_compress_generic_validated(), LZ4_getPosition(), and LZ4_putPosition().

LZ4_initStream()

LZ4_stream_t* LZ4_initStream	(	void *	buffer,
		size_t	size
	)

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

Returns

a pointer of proper type upon initialization.

Note : initialization fails if size and alignment conditions are not respected. In which case, the function will

Returns

NULL. Note2: An LZ4_stream_t structure guarantees correct alignment and size. Note3: Before v1.9.0, use LZ4_resetStream() instead

Definition at line 1443 of file lz4.c.

{
    DEBUGLOG(5, "LZ4_initStream");
    if (buffer == NULL) { return NULL; }
    if (size < sizeof(LZ4_stream_t)) { return NULL; }
    if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL;
    MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal));
    return (LZ4_stream_t*)buffer;
}

References DEBUGLOG, LZ4_isAligned(), LZ4_stream_t_alignment(), MEM_INIT, and NULL.

Referenced by FUZ_test(), FUZ_unitTests(), local_LZ4_createStream(), local_LZ4_resetDictT(), LZ4_compress_destSize_extState(), LZ4_compress_fast_extState(), LZ4_createStream(), LZ4F_compressBegin_usingCDict(), LZ4F_compressFrame(), and test_compress().

LZ4_isAligned()

static int LZ4_isAligned ( const void *  ptr, size_t  alignment  )

static

Definition at line 264 of file lz4.c.

{
    return ((size_t)ptr & (alignment -1)) == 0;
}

Referenced by LZ4_compress_HC_extStateHC_fastReset(), LZ4_initStream(), and LZ4_initStreamHC().

LZ4_isLittleEndian()

static unsigned LZ4_isLittleEndian ( void  )

static

Definition at line 325 of file lz4.c.

{
    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
    return one.c[0];
}

References c.

Referenced by LZ4_hash5(), LZ4_NbCommonBytes(), LZ4_readLE16(), LZ4_writeLE16(), and LZ4HC_countPattern().

LZ4_loadDict()

int LZ4_loadDict	(	LZ4_stream_t *	streamPtr,
		const char *	dictionary,
		int	dictSize
	)

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 accept any input as dictionary, results are generally better when using Zstandard's Dictionary Builder. Loading a size of 0 is allowed, and is the same as reset.

Returns

: loaded dictionary size, in bytes (necessarily <= 64 KB)

Definition at line 1475 of file lz4.c.

{
    LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
    const tableType_t tableType = byU32;
    const BYTE* p = (const BYTE*)dictionary;
    const BYTE* const dictEnd = p + dictSize;
    const BYTE* base;
 
    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict);
 
    /* It's necessary to reset the context,
     * and not just continue it with prepareTable()
     * to avoid any risk of generating overflowing matchIndex
     * when compressing using this dictionary */
    LZ4_resetStream(LZ4_dict);
 
    /* We always increment the offset by 64 KB, since, if the dict is longer,
     * we truncate it to the last 64k, and if it's shorter, we still want to
     * advance by a whole window length so we can provide the guarantee that
     * there are only valid offsets in the window, which allows an optimization
     * in LZ4_compress_fast_continue() where it uses noDictIssue even when the
     * dictionary isn't a full 64k. */
    dict->currentOffset += 64 KB;
 
    if (dictSize < (int)HASH_UNIT) {
        return 0;
    }
 
    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
    base = dictEnd - dict->currentOffset;
    dict->dictionary = p;
    dict->dictSize = (U32)(dictEnd - p);
    dict->tableType = (U32)tableType;
 
    while (p <= dictEnd-HASH_UNIT) {
        LZ4_putPosition(p, dict->hashTable, tableType, base);
        p+=3;
    }
 
    return (int)dict->dictSize;
}

References byU32, LZ4_stream_t_internal::currentOffset, DEBUGLOG, LZ4_stream_t_internal::dictionary, LZ4_stream_t_internal::dictSize, HASH_UNIT, LZ4_stream_t_internal::hashTable, LZ4_stream_u::internal_donotuse, KB, LZ4_putPosition(), LZ4_resetStream(), p, and LZ4_stream_t_internal::tableType.

Referenced by fullSpeedBench(), FUZ_test(), LZ4_compressInitStream(), LZ4F_createCDict(), state_attachDictRoundTrip(), state_loadDictRoundTrip(), and test_compress().

LZ4_NbCommonBytes()

static unsigned LZ4_NbCommonBytes ( reg_t  val )

static

Definition at line 513 of file lz4.c.

{
    assert(val != 0);
    if (LZ4_isLittleEndian()) {
        if (sizeof(val) == 8) {
#       if defined(_MSC_VER) && (_MSC_VER >= 1800) && defined(_M_AMD64) && !defined(LZ4_FORCE_SW_BITCOUNT)
            /* x64 CPUS without BMI support interpret `TZCNT` as `REP BSF` */
            return (unsigned)_tzcnt_u64(val) >> 3;
#       elif defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
            unsigned long r = 0;
            _BitScanForward64(&r, (U64)val);
            return (unsigned)r >> 3;
#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
                                        !defined(LZ4_FORCE_SW_BITCOUNT)
            return (unsigned)__builtin_ctzll((U64)val) >> 3;
#       else
            const U64 m = 0x0101010101010101ULL;
            val ^= val - 1;
            return (unsigned)(((U64)((val & (m - 1)) * m)) >> 56);
#       endif
        } else /* 32 bits */ {
#       if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
            unsigned long r;
            _BitScanForward(&r, (U32)val);
            return (unsigned)r >> 3;
#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
            return (unsigned)__builtin_ctz((U32)val) >> 3;
#       else
            const U32 m = 0x01010101;
            return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
#       endif
        }
    } else   /* Big Endian CPU */ {
        if (sizeof(val)==8) {
#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
            return (unsigned)__builtin_clzll((U64)val) >> 3;
#       else
#if 1
            /* this method is probably faster,
             * but adds a 128 bytes lookup table */
            static const unsigned char ctz7_tab[128] = {
                7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
                6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
            };
            U64 const mask = 0x0101010101010101ULL;
            U64 const t = (((val >> 8) - mask) | val) & mask;
            return ctz7_tab[(t * 0x0080402010080402ULL) >> 57];
#else
            /* this method doesn't consume memory space like the previous one,
             * but it contains several branches,
             * that may end up slowing execution */
            static const U32 by32 = sizeof(val)*4;  /* 32 on 64 bits (goal), 16 on 32 bits.
            Just to avoid some static analyzer complaining about shift by 32 on 32-bits target.
            Note that this code path is never triggered in 32-bits mode. */
            unsigned r;
            if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; }
            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
            r += (!val);
            return r;
#endif
#       endif
        } else /* 32 bits */ {
#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
                                        !defined(LZ4_FORCE_SW_BITCOUNT)
            return (unsigned)__builtin_clz((U32)val) >> 3;
#       else
            val >>= 8;
            val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) |
              (val + 0x00FF0000)) >> 24;
            return (unsigned)val ^ 3;
#       endif
        }
    }
}

References assert, LZ4_isLittleEndian(), regress::m, mask, r, and val.

Referenced by LZ4_count(), and LZ4HC_countPattern().

LZ4_prepareTable()

LZ4_FORCE_INLINE void LZ4_prepareTable	(	LZ4_stream_t_internal *const	cctx,
		const int	inputSize,
		const tableType_t	tableType
	)

Definition at line 806 of file lz4.c.

                                        {
    /* If the table hasn't been used, it's guaranteed to be zeroed out, and is
     * therefore safe to use no matter what mode we're in. Otherwise, we figure
     * out if it's safe to leave as is or whether it needs to be reset.
     */
    if ((tableType_t)cctx->tableType != clearedTable) {
        assert(inputSize >= 0);
        if ((tableType_t)cctx->tableType != tableType
          || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU)
          || ((tableType == byU32) && cctx->currentOffset > 1 GB)
          || tableType == byPtr
          || inputSize >= 4 KB)
        {
            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);
            MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
            cctx->currentOffset = 0;
            cctx->tableType = (U32)clearedTable;
        } else {
            DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)");
        }
    }
 
    /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back, is faster
     * than compressing without a gap. However, compressing with
     * currentOffset == 0 is faster still, so we preserve that case.
     */
    if (cctx->currentOffset != 0 && tableType == byU32) {
        DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset");
        cctx->currentOffset += 64 KB;
    }
 
    /* Finally, clear history */
    cctx->dictCtx = NULL;
    cctx->dictionary = NULL;
    cctx->dictSize = 0;
}

References assert, byPtr, byU16, byU32, clearedTable, LZ4_stream_t_internal::currentOffset, DEBUGLOG, LZ4_stream_t_internal::dictCtx, LZ4_stream_t_internal::dictionary, LZ4_stream_t_internal::dictSize, GB, LZ4_stream_t_internal::hashTable, inputSize, KB, LZ4_HASHTABLESIZE, MEM_INIT, NULL, and LZ4_stream_t_internal::tableType.

Referenced by LZ4_compress_fast_extState_fastReset(), and LZ4_resetStream_fast().

LZ4_putIndexOnHash()

LZ4_FORCE_INLINE void LZ4_putIndexOnHash	(	U32	idx,
		U32	h,
		void *	tableBase,
		tableType_t const	tableType
	)

Definition at line 736 of file lz4.c.

{
    switch (tableType)
    {
    default: /* fallthrough */
    case clearedTable: /* fallthrough */
    case byPtr: { /* illegal! */ assert(0); return; }
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
    }
}

References assert, byPtr, byU16, byU32, clearedTable, h, and setup::idx.

Referenced by LZ4_compress_generic_validated().

LZ4_putPosition()

LZ4_FORCE_INLINE void LZ4_putPosition	(	const BYTE *	p,
		void *	tableBase,
		tableType_t	tableType,
		const BYTE *	srcBase
	)

Definition at line 761 of file lz4.c.

{
    U32 const h = LZ4_hashPosition(p, tableType);
    LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
}

References h, LZ4_hashPosition(), LZ4_putPositionOnHash(), and p.

Referenced by LZ4_compress_generic_validated(), and LZ4_loadDict().

LZ4_putPositionOnHash()

LZ4_FORCE_INLINE void LZ4_putPositionOnHash	(	const BYTE *	p,
		U32	h,
		void *	tableBase,
		tableType_t const	tableType,
		const BYTE *	srcBase
	)

Definition at line 748 of file lz4.c.

{
    switch (tableType)
    {
    case clearedTable: { /* illegal! */ assert(0); return; }
    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
    }
}

References assert, byPtr, byU16, byU32, clearedTable, h, and p.

Referenced by LZ4_compress_generic_validated(), and LZ4_putPosition().

LZ4_read16()

static U16 LZ4_read16 ( const void *  memPtr )

static

Definition at line 357 of file lz4.c.

{
    U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
}

References LZ4_memcpy, and val.

Referenced by LZ4_count(), LZ4_readLE16(), and LZ4HC_InsertAndGetWiderMatch().

LZ4_read32()

static U32 LZ4_read32 ( const void *  memPtr )

static

Definition at line 362 of file lz4.c.

{
    U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
}

References LZ4_memcpy, and val.

Referenced by LZ4_compress_generic_validated(), LZ4_count(), LZ4_hashPosition(), LZ4HC_hashPtr(), LZ4HC_InsertAndGetWiderMatch(), and LZ4HC_reverseCountPattern().

LZ4_read_ARCH()

static reg_t LZ4_read_ARCH ( const void *  memPtr )

static

Definition at line 367 of file lz4.c.

{
    reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
}

References LZ4_memcpy, and val.

Referenced by LZ4_count(), LZ4_hashPosition(), and LZ4HC_countPattern().

LZ4_readLE16()

static U16 LZ4_readLE16 ( const void *  memPtr )

static

Definition at line 385 of file lz4.c.

{
    if (LZ4_isLittleEndian()) {
        return LZ4_read16(memPtr);
    } else {
        const BYTE* p = (const BYTE*)memPtr;
        return (U16)((U16)p[0] + (p[1]<<8));
    }
}

References LZ4_isLittleEndian(), LZ4_read16(), and p.

Referenced by LZ4_decompress_generic().

LZ4_renormDictT()

static void LZ4_renormDictT ( LZ4_stream_t_internal *  LZ4_dict, int  nextSize  )

static

Definition at line 1545 of file lz4.c.

{
    assert(nextSize >= 0);
    if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
        /* rescale hash table */
        U32 const delta = LZ4_dict->currentOffset - 64 KB;
        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
        int i;
        DEBUGLOG(4, "LZ4_renormDictT");
        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
            else LZ4_dict->hashTable[i] -= delta;
        }
        LZ4_dict->currentOffset = 64 KB;
        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
    }
}

References assert, LZ4_stream_t_internal::currentOffset, DEBUGLOG, delta, LZ4_stream_t_internal::dictionary, LZ4_stream_t_internal::dictSize, LZ4_stream_t_internal::hashTable, i, KB, and LZ4_HASH_SIZE_U32.

Referenced by LZ4_compress_fast_continue(), and LZ4_compress_forceExtDict().

LZ4_resetStream()

void LZ4_resetStream

(

LZ4_stream_t *

streamPtr

)

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.

Definition at line 1455 of file lz4.c.

{
    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
    MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal));
}

References DEBUGLOG, LZ4_stream, and MEM_INIT.

Referenced by LZ4_loadDict(), and LZ4_resetStreamState().

LZ4_resetStream_fast()

void LZ4_resetStream_fast

(

LZ4_stream_t *

streamPtr

)

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.

Definition at line 1461 of file lz4.c.

                                             {
    LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32);
}

References byU32, and LZ4_prepareTable().

Referenced by FUZ_test(), FUZ_unitTests(), LZ4_compressResetStream(), LZ4F_initStream(), and state_reset().

LZ4_resetStreamState()

int LZ4_resetStreamState	(	void *	state,
		char *	inputBuffer
	)

Definition at line 2476 of file lz4.c.

{
    (void)inputBuffer;
    LZ4_resetStream((LZ4_stream_t*)state);
    return 0;
}

References inputBuffer, and LZ4_resetStream().

LZ4_saveDict()

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.

Definition at line 1668 of file lz4.c.

{
    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
    const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
 
    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }
 
    if (safeBuffer == NULL) assert(dictSize == 0);
    if (dictSize > 0)
        memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
 
    dict->dictionary = (const BYTE*)safeBuffer;
    dict->dictSize = (U32)dictSize;
 
    return dictSize;
}

References assert, LZ4_stream_t_internal::dictionary, LZ4_stream_t_internal::dictSize, int, LZ4_stream_u::internal_donotuse, KB, and NULL.

Referenced by FUZ_unitTests(), local_LZ4_saveDict(), and LZ4F_localSaveDict().

LZ4_setStreamDecode()

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).

Returns

: 1 if OK, 0 if error

Definition at line 2285 of file lz4.c.

{
    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
    lz4sd->prefixSize = (size_t) dictSize;
    lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
    lz4sd->externalDict = NULL;
    lz4sd->extDictSize  = 0;
    return 1;
}

References LZ4_streamDecode_t_internal::extDictSize, LZ4_streamDecode_t_internal::externalDict, LZ4_streamDecode_u::internal_donotuse, NULL, LZ4_streamDecode_t_internal::prefixEnd, and LZ4_streamDecode_t_internal::prefixSize.

Referenced by FUZ_unitTests(), state_attachDictHCRoundTrip(), state_attachDictRoundTrip(), state_loadDictHCRoundTrip(), state_loadDictRoundTrip(), state_reset(), and test_decompress().

LZ4_sizeofState()

int LZ4_sizeofState

(

void

)

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.

Definition at line 675 of file lz4.c.

{ return LZ4_STREAMSIZE; }

References LZ4_STREAMSIZE.

Referenced by FUZ_test().

LZ4_sizeofStreamState()

int LZ4_sizeofStreamState

(

void

)

Definition at line 2474 of file lz4.c.

{ return LZ4_STREAMSIZE; }

References LZ4_STREAMSIZE.

LZ4_slideInputBuffer()

char* LZ4_slideInputBuffer

(

void *

state

)

Definition at line 2489 of file lz4.c.

{
    /* avoid const char * -> char * conversion warning */
    return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary;
}

LZ4_stream_t_alignment()

static size_t LZ4_stream_t_alignment ( void  )

static

Definition at line 1433 of file lz4.c.

{
#if LZ4_ALIGN_TEST
    typedef struct { char c; LZ4_stream_t t; } t_a;
    return sizeof(t_a) - sizeof(LZ4_stream_t);
#else
    return 1;  /* effectively disabled */
#endif
}

References c.

Referenced by LZ4_initStream().

LZ4_uncompress()

int LZ4_uncompress	(	const char *	source,
		char *	dest,
		int	outputSize
	)

Definition at line 2463 of file lz4.c.

{
    return LZ4_decompress_fast(source, dest, outputSize);
}

References dest, LZ4_decompress_fast(), outputSize, and source.

LZ4_uncompress_unknownOutputSize()

int LZ4_uncompress_unknownOutputSize	(	const char *	source,
		char *	dest,
		int	isize,
		int	maxOutputSize
	)

Definition at line 2467 of file lz4.c.

{
    return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
}

References dest, isize, LZ4_decompress_safe(), maxOutputSize, and source.

LZ4_versionNumber()

int LZ4_versionNumber

(

void

)

library version number; useful to check dll version

Definition at line 672 of file lz4.c.

{ return LZ4_VERSION_NUMBER; }

References LZ4_VERSION_NUMBER.

Referenced by main().

LZ4_versionString()

const char* LZ4_versionString

(

void

)

library version string; useful to check dll version

Definition at line 673 of file lz4.c.

{ return LZ4_VERSION_STRING; }

References LZ4_VERSION_STRING.

Referenced by main().

LZ4_wildCopy8()

LZ4_FORCE_INLINE void LZ4_wildCopy8	(	void *	dstPtr,
		const void *	srcPtr,
		void *	dstEnd
	)

Definition at line 408 of file lz4.c.

{
    BYTE* d = (BYTE*)dstPtr;
    const BYTE* s = (const BYTE*)srcPtr;
    BYTE* const e = (BYTE*)dstEnd;
 
    do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d<e);
}

References d, e, LZ4_memcpy, and s.

Referenced by LZ4_compress_generic_validated(), LZ4_decompress_generic(), and LZ4HC_encodeSequence().

LZ4_write16()

static void LZ4_write16 ( void *  memPtr, U16  value  )

static

Definition at line 372 of file lz4.c.

{
    LZ4_memcpy(memPtr, &value, sizeof(value));
}

References LZ4_memcpy, and value.

Referenced by LZ4_writeLE16().

LZ4_write32()

static void LZ4_write32 ( void *  memPtr, U32  value  )

static

Definition at line 377 of file lz4.c.

{
    LZ4_memcpy(memPtr, &value, sizeof(value));
}

References LZ4_memcpy, and value.

Referenced by LZ4_compress_generic_validated(), and LZ4_decompress_generic().

LZ4_writeLE16()

static void LZ4_writeLE16 ( void *  memPtr, U16  value  )

static

Definition at line 395 of file lz4.c.

{
    if (LZ4_isLittleEndian()) {
        LZ4_write16(memPtr, value);
    } else {
        BYTE* p = (BYTE*)memPtr;
        p[0] = (BYTE) value;
        p[1] = (BYTE)(value>>8);
    }
}

References LZ4_isLittleEndian(), LZ4_write16(), p, and value.

Referenced by LZ4_compress_generic_validated(), and LZ4HC_encodeSequence().

read_variable_length()

LZ4_FORCE_INLINE unsigned read_variable_length	(	const BYTE **	ip,
		const BYTE *	lencheck,
		int	loop_check,
		int	initial_check,
		variable_length_error *	error
	)

Definition at line 1708 of file lz4.c.

{
    U32 length = 0;
    U32 s;
    if (initial_check && unlikely((*ip) >= lencheck)) {    /* overflow detection */
        *error = initial_error;
        return length;
    }
    do {
        s = **ip;
        (*ip)++;
        length += s;
        if (loop_check && unlikely((*ip) >= lencheck)) {    /* overflow detection */
            *error = loop_error;
            return length;
        }
    } while (s==255);
 
    return length;
}

References error(), initial_error, ip, length, loop_error, s, and unlikely.

Referenced by LZ4_decompress_generic().

Variable Documentation

dec64table

const int dec64table[8] = {0, 0, 0, -1, -4, 1, 2, 3}

static

Definition at line 418 of file lz4.c.

Referenced by LZ4_decompress_generic().

inc32table

const unsigned inc32table[8] = {0, 1, 2, 1, 0, 4, 4, 4}

static

Definition at line 417 of file lz4.c.

Referenced by LZ4_decompress_generic().

LZ4_64Klimit

const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1))

static

Definition at line 633 of file lz4.c.

Referenced by LZ4_compress_destSize_extState(), LZ4_compress_fast_extState(), LZ4_compress_fast_extState_fastReset(), and LZ4_compress_generic_validated().

LZ4_minLength

const int LZ4_minLength = (MFLIMIT+1)

static

Definition at line 221 of file lz4.c.

Referenced by LZ4_compress_generic_validated(), and LZ4HC_compress_hashChain().

LZ4_skipTrigger

const U32 LZ4_skipTrigger = 6

static

Definition at line 634 of file lz4.c.

Referenced by LZ4_compress_generic_validated().