#include "Precomp.h"
#include <string.h>
#include "CpuArch.h"
#include "LzmaEnc.h"
#include "LzFind.h"
#include "LzFindMt.h"

Data Structures
struct	COptimal

struct	CLenEnc

struct	CLenPriceEnc

struct	CRangeEnc

struct	CSaveState

struct	CLzmaEnc

struct	CLzmaEnc_SeqOutStreamBuf

Macros
#define	kLzmaMaxHistorySize ((UInt32)15 << 28)

#define	kTopValue ((UInt32)1 << 24)

#define	kNumBitModelTotalBits 11

#define	kBitModelTotal (1 << kNumBitModelTotalBits)

#define	kNumMoveBits 5

#define	kProbInitValue (kBitModelTotal >> 1)

#define	kNumMoveReducingBits 4

#define	kNumBitPriceShiftBits 4

#define	REP_LEN_COUNT 64

#define	kNumLogBits (11 + sizeof(size_t) / 8 * 3)

#define	kDicLogSizeMaxCompress ((kNumLogBits - 1) * 2 + 7)

#define	BSR2_RET(pos, res)

#define	GetPosSlot1(pos)

#define	GetPosSlot2(pos, res)

#define	GetPosSlot(pos, res)

#define	LZMA_NUM_REPS 4

#define	kNumOpts (1 << 11)

#define	kPackReserve (kNumOpts * 8)

#define	kNumLenToPosStates 4

#define	kNumPosSlotBits 6

#define	kDicLogSizeMax 32

#define	kDistTableSizeMax (kDicLogSizeMax * 2)

#define	kNumAlignBits 4

#define	kAlignTableSize (1 << kNumAlignBits)

#define	kAlignMask (kAlignTableSize - 1)

#define	kStartPosModelIndex 4

#define	kEndPosModelIndex 14

#define	kNumFullDistances (1 << (kEndPosModelIndex >> 1))

#define	LZMA_PB_MAX 4

#define	LZMA_LC_MAX 8

#define	LZMA_LP_MAX 4

#define	LZMA_NUM_PB_STATES_MAX (1 << LZMA_PB_MAX)

#define	kLenNumLowBits 3

#define	kLenNumLowSymbols (1 << kLenNumLowBits)

#define	kLenNumHighBits 8

#define	kLenNumHighSymbols (1 << kLenNumHighBits)

#define	kLenNumSymbolsTotal (kLenNumLowSymbols * 2 + kLenNumHighSymbols)

#define	LZMA_MATCH_LEN_MIN 2

#define	LZMA_MATCH_LEN_MAX (LZMA_MATCH_LEN_MIN + kLenNumSymbolsTotal - 1)

#define	kNumStates 12

#define	GET_PRICE_LEN(p, posState, len)

#define	MFB (p->matchFinderBase)

#define	COPY_ARR(dest, src, arr)

#define	COPY_LZMA_ENC_STATE(d, s, p)

#define	kState_Start 0

#define	kState_LitAfterMatch 4

#define	kState_LitAfterRep 5

#define	kState_MatchAfterLit 7

#define	kState_RepAfterLit 8

#define	IsLitState(s)

#define	GetLenToPosState2(len)

#define	GetLenToPosState(len)

#define	kInfinityPrice (1 << 30)

#define	RangeEnc_GetProcessed(p)

#define	RangeEnc_GetProcessed_sizet(p)

#define	RC_BUF_SIZE (1 << 16)

#define	RC_NORM(p)

#define	RC_BIT_PRE(p, prob)

#define	RC_BIT(p, prob, bit)

#define	RC_BIT_0_BASE(p, prob)

#define	RC_BIT_1_BASE(p, prob)

#define	RC_BIT_0(p, prob)

#define	RC_BIT_1(p, prob)

#define	GET_PRICE(prob, bit)

#define	GET_PRICEa(prob, bit)

#define	GET_PRICE_0(prob)

#define	GET_PRICE_1(prob)

#define	GET_PRICEa_0(prob)

#define	GET_PRICEa_1(prob)

#define	MOVE_POS(p, num)

#define	MARK_LIT ((UInt32)(Int32)-1)

#define	MakeAs_Lit(p)

#define	MakeAs_ShortRep(p)

#define	IsShortRep(p)

#define	GetPrice_ShortRep(p, state, posState)

#define	GetPrice_Rep_0(p, state, posState)

#define	LIT_PROBS(pos, prevByte)

#define	MATCHES matches

#define	ChangePair(smallDist, bigDist)

#define	kBigHashDicLimit ((UInt32)1 << 24)

Functions
SRes	LzmaEnc_PrepareForLzma2 (CLzmaEncHandle p, ISeqInStreamPtr inStream, UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)

SRes	LzmaEnc_MemPrepare (CLzmaEncHandle p, const Byte *src, SizeT srcLen, UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)

SRes	LzmaEnc_CodeOneMemBlock (CLzmaEncHandle p, BoolInt reInit, Byte dest, size_t destLen, UInt32 desiredPackSize, UInt32 *unpackSize)

const Byte *	LzmaEnc_GetCurBuf (CLzmaEncHandle p)

void	LzmaEnc_Finish (CLzmaEncHandle p)

void	LzmaEnc_SaveState (CLzmaEncHandle p)

void	LzmaEnc_RestoreState (CLzmaEncHandle p)

int	lgetpor_ar (__int64 max, __int64 fatia)

void	LzmaEncProps_Init (CLzmaEncProps *p)

void	LzmaEncProps_Normalize (CLzmaEncProps *p)

UInt32	LzmaEncProps_GetDictSize (const CLzmaEncProps *props2)

Z7_NO_INLINE SRes	LzmaEnc_SetProps (CLzmaEncHandle p, const CLzmaEncProps *props2)

void	LzmaEnc_SetDataSize (CLzmaEncHandle p, UInt64 expectedDataSiize)

CLzmaEncHandle	LzmaEnc_Create (ISzAllocPtr alloc)

void	LzmaEnc_Destroy (CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig)

SRes	LzmaEnc_Encode (CLzmaEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)

SRes	LzmaEnc_WriteProperties (CLzmaEncHandle p, Byte props, SizeT size)

unsigned	LzmaEnc_IsWriteEndMark (CLzmaEncHandle p)

SRes	LzmaEnc_MemEncode (CLzmaEncHandle p, Byte dest, SizeT destLen, const Byte *src, SizeT srcLen, int writeEndMark, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)

SRes	LzmaEncode (Byte dest, SizeT destLen, const Byte src, SizeT srcLen, const CLzmaEncProps props, Byte propsEncoded, SizeT propsSize, int writeEndMark, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)

Macro Definition Documentation

◆ BSR2_RET

#define BSR2_RET	(		pos,
			res )

Value:

     {                                                                              \
          unsigned zz = (pos < (1 << (kNumLogBits + 6))) ? 6 : 6 + kNumLogBits - 1; \
          res = p->g_FastPos[pos >> zz] + (zz * 2);                                 \
     }

◆ ChangePair

#define ChangePair	(		smallDist,
			bigDist )

Value:

(((bigDist) >> 7) > (smallDist))

◆ COPY_ARR

#define COPY_ARR	(	dest,
		src,
		arr )

Value:

memcpy((dest)->arr, (src)->arr, sizeof((src)->arr));

src

const char * src

Definition lz4.h:866

dest

char * dest

Definition lz4.h:806

◆ COPY_LZMA_ENC_STATE

#define COPY_LZMA_ENC_STATE	(	d,
		s,
		p )

Value:

     (d)->state = (s)->state;             \
     COPY_ARR(d, s, reps)                 \
     COPY_ARR(d, s, posAlignEncoder)      \
     COPY_ARR(d, s, isRep)                \
     COPY_ARR(d, s, isRepG0)              \
     COPY_ARR(d, s, isRepG1)              \
     COPY_ARR(d, s, isRepG2)              \
     COPY_ARR(d, s, isMatch)              \
     COPY_ARR(d, s, isRep0Long)           \
     COPY_ARR(d, s, posSlotEncoder)       \
     COPY_ARR(d, s, posEncoders)          \
     (d)->lenProbs = (s)->lenProbs;       \
     (d)->repLenProbs = (s)->repLenProbs; \
     memcpy((d)->litProbs, (s)->litProbs, ((UInt32)0x300 << (p)->lclp) * sizeof(CLzmaProb));

◆ GET_PRICE

#define GET_PRICE	(		prob,
			bit )

Value:

p->ProbPrices[((prob) ^ (unsigned)(((-(int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits]

kBitModelTotal

#define kBitModelTotal

Definition LzmaEnc.c:47

kNumMoveReducingBits

#define kNumMoveReducingBits

Definition LzmaEnc.c:51

int

Definition lzoconf.h:340

◆ GET_PRICE_0

#define GET_PRICE_0 ( prob )

Value:

p->ProbPrices[(prob) >> kNumMoveReducingBits]

◆ GET_PRICE_1

#define GET_PRICE_1 ( prob )

Value:

p->ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]

◆ GET_PRICE_LEN

#define GET_PRICE_LEN	(	p,
		posState,
		len )

Value:

((p)->prices[posState][(size_t)(len)-LZMA_MATCH_LEN_MIN])

LZMA_MATCH_LEN_MIN

#define LZMA_MATCH_LEN_MIN

Definition LzmaEnc.c:342

len

static uint32_t const uint8_t uint32_t len

Definition memcmplen.h:44

◆ GET_PRICEa

#define GET_PRICEa	(		prob,
			bit )

Value:

ProbPrices[((prob) ^ (unsigned)((-((int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits]

◆ GET_PRICEa_0

#define GET_PRICEa_0 ( prob )

Value:

ProbPrices[(prob) >> kNumMoveReducingBits]

◆ GET_PRICEa_1

#define GET_PRICEa_1 ( prob )

Value:

ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]

◆ GetLenToPosState

#define GetLenToPosState ( len )

Value:

(((len) < kNumLenToPosStates + 1) ? (len)-2 : kNumLenToPosStates - 1)

kNumLenToPosStates

#define kNumLenToPosStates

Definition LzmaEnc.c:308

◆ GetLenToPosState2

#define GetLenToPosState2 ( len )

Value:

(((len) < kNumLenToPosStates - 1) ? (len) : kNumLenToPosStates - 1)

◆ GetPosSlot

#define GetPosSlot	(		pos,
			res )

Value:

     {                                                            \
          if (pos < kNumFullDistances)                            \
               res = p->g_FastPos[pos & (kNumFullDistances - 1)]; \
          else                                                    \
               BSR2_RET(pos, res);                                \
     }

◆ GetPosSlot1

#define GetPosSlot1 ( pos )

Value:

p->g_FastPos[pos]

◆ GetPosSlot2

#define GetPosSlot2	(		pos,
			res )

Value:

     {                        \
          BSR2_RET(pos, res); \
     }

◆ GetPrice_Rep_0

#define GetPrice_Rep_0	(	p,
		state,
		posState )

Value:

                                               (                                                                                             \
                                               GET_PRICE_1(p->isMatch[state][posState]) + GET_PRICE_1(p->isRep0Long[state][posState])) + \
                                               GET_PRICE_1(p->isRep[state]) + GET_PRICE_0(p->isRepG0[state])

◆ GetPrice_ShortRep

#define GetPrice_ShortRep	(	p,
		state,
		posState )

Value:

(GET_PRICE_0(p->isRepG0[state]) + GET_PRICE_0(p->isRep0Long[state][posState]))

◆ IsLitState

#define IsLitState ( s )

Value:

((s) < 7)

◆ IsShortRep

#define IsShortRep ( p )

Value:

((p)->dist == 0)

◆ kAlignMask

#define kAlignMask (kAlignTableSize - 1)

◆ kAlignTableSize

#define kAlignTableSize (1 << kNumAlignBits)

◆ kBigHashDicLimit

#define kBigHashDicLimit ((UInt32)1 << 24)

◆ kBitModelTotal

#define kBitModelTotal (1 << kNumBitModelTotalBits)

◆ kDicLogSizeMax

#define kDicLogSizeMax 32

◆ kDicLogSizeMaxCompress

#define kDicLogSizeMaxCompress ((kNumLogBits - 1) * 2 + 7)

◆ kDistTableSizeMax

#define kDistTableSizeMax (kDicLogSizeMax * 2)

◆ kEndPosModelIndex

#define kEndPosModelIndex 14

◆ kInfinityPrice

#define kInfinityPrice (1 << 30)

◆ kLenNumHighBits

#define kLenNumHighBits 8

◆ kLenNumHighSymbols

#define kLenNumHighSymbols (1 << kLenNumHighBits)

◆ kLenNumLowBits

#define kLenNumLowBits 3

◆ kLenNumLowSymbols

#define kLenNumLowSymbols (1 << kLenNumLowBits)

◆ kLenNumSymbolsTotal

#define kLenNumSymbolsTotal (kLenNumLowSymbols * 2 + kLenNumHighSymbols)

◆ kLzmaMaxHistorySize

#define kLzmaMaxHistorySize ((UInt32)15 << 28)

◆ kNumAlignBits

#define kNumAlignBits 4

◆ kNumBitModelTotalBits

#define kNumBitModelTotalBits 11

◆ kNumBitPriceShiftBits

#define kNumBitPriceShiftBits 4

◆ kNumFullDistances

#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))

◆ kNumLenToPosStates

#define kNumLenToPosStates 4

◆ kNumLogBits

#define kNumLogBits (11 + sizeof(size_t) / 8 * 3)

◆ kNumMoveBits

#define kNumMoveBits 5

◆ kNumMoveReducingBits

#define kNumMoveReducingBits 4

◆ kNumOpts

#define kNumOpts (1 << 11)

◆ kNumPosSlotBits

#define kNumPosSlotBits 6

◆ kNumStates

#define kNumStates 12

◆ kPackReserve

#define kPackReserve (kNumOpts * 8)

◆ kProbInitValue

#define kProbInitValue (kBitModelTotal >> 1)

◆ kStartPosModelIndex

#define kStartPosModelIndex 4

◆ kState_LitAfterMatch

#define kState_LitAfterMatch 4

◆ kState_LitAfterRep

#define kState_LitAfterRep 5

◆ kState_MatchAfterLit

#define kState_MatchAfterLit 7

◆ kState_RepAfterLit

#define kState_RepAfterLit 8

◆ kState_Start

#define kState_Start 0

◆ kTopValue

#define kTopValue ((UInt32)1 << 24)

◆ LIT_PROBS

#define LIT_PROBS	(		pos,
			prevByte )

Value:

(p->litProbs + (UInt32)3 * (((((pos) << 8) + (prevByte)) & p->lpMask) << p->lc))

◆ LZMA_LC_MAX

#define LZMA_LC_MAX 8

◆ LZMA_LP_MAX

#define LZMA_LP_MAX 4

◆ LZMA_MATCH_LEN_MAX

#define LZMA_MATCH_LEN_MAX (LZMA_MATCH_LEN_MIN + kLenNumSymbolsTotal - 1)

◆ LZMA_MATCH_LEN_MIN

#define LZMA_MATCH_LEN_MIN 2

◆ LZMA_NUM_PB_STATES_MAX

#define LZMA_NUM_PB_STATES_MAX (1 << LZMA_PB_MAX)

◆ LZMA_NUM_REPS

#define LZMA_NUM_REPS 4

◆ LZMA_PB_MAX

#define LZMA_PB_MAX 4

◆ MakeAs_Lit

#define MakeAs_Lit ( p )

Value:

     {                          \
          (p)->dist = MARK_LIT; \
          (p)->extra = 0;       \
     }

◆ MakeAs_ShortRep

#define MakeAs_ShortRep ( p )

Value:

     {                     \
          (p)->dist = 0;   \
          (p)->extra = 0;  \
     }

◆ MARK_LIT

#define MARK_LIT ((UInt32)(Int32)-1)

◆ MATCHES

#define MATCHES matches

◆ MFB

#define MFB (p->matchFinderBase)

◆ MOVE_POS

#define MOVE_POS	(		p,
			num )

Value:

     {                                                           \
          p->additionalOffset += (num);                          \
          p->matchFinder.Skip(p->matchFinderObj, (UInt32)(num)); \
     }

◆ RangeEnc_GetProcessed

#define RangeEnc_GetProcessed ( p )

Value:

((p)->processed + (size_t)((p)->buf - (p)->bufBase) + (p)->cacheSize)

◆ RangeEnc_GetProcessed_sizet

#define RangeEnc_GetProcessed_sizet ( p )

Value:

((size_t)(p)->processed + (size_t)((p)->buf - (p)->bufBase) + (size_t)(p)->cacheSize)

◆ RC_BIT

#define RC_BIT	(	p,
		prob,
		bit )

Value:

     {                                                          \
          UInt32 mask;                                          \
          RC_BIT_PRE(p, prob)                                   \
          mask = 0 - (UInt32)bit;                               \
          range &= mask;                                        \
          mask &= newBound;                                     \
          range -= mask;                                        \
          (p)->low += mask;                                     \
          mask = (UInt32)bit - 1;                               \
          range += newBound & mask;                             \
          mask &= (kBitModelTotal - ((1 << kNumMoveBits) - 1)); \
          mask += ((1 << kNumMoveBits) - 1);                    \
          ttt += (UInt32)((Int32)(mask - ttt) >> kNumMoveBits); \
          *(prob) = (CLzmaProb)ttt;                             \
          RC_NORM(p)                                            \
     }

◆ RC_BIT_0

#define RC_BIT_0	(		p,
			prob )

Value:

RC_BIT_0_BASE(p, prob) \

RC_NORM(p)

RC_BIT_0_BASE

#define RC_BIT_0_BASE(p, prob)

Definition LzmaEnc.c:795

◆ RC_BIT_0_BASE

#define RC_BIT_0_BASE	(		p,
			prob )

Value:

range = newBound; \

*(prob) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));

◆ RC_BIT_1

#define RC_BIT_1	(		p,
			prob )

Value:

RC_BIT_1_BASE(p, prob) \

RC_NORM(p)

RC_BIT_1_BASE

#define RC_BIT_1_BASE(p, prob)

Definition LzmaEnc.c:799

◆ RC_BIT_1_BASE

#define RC_BIT_1_BASE	(		p,
			prob )

Value:

     range -= newBound;        \
     (p)->low += newBound;     \
     *(prob) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));

◆ RC_BIT_PRE

#define RC_BIT_PRE	(		p,
			prob )

Value:

ttt = *(prob); \

newBound = (range >> kNumBitModelTotalBits) * ttt;

kNumBitModelTotalBits

#define kNumBitModelTotalBits

Definition LzmaEnc.c:46

◆ RC_BUF_SIZE

#define RC_BUF_SIZE (1 << 16)

◆ RC_NORM

#define RC_NORM ( p )

Value:

     if (range < kTopValue)     \
     {                          \
          range <<= 8;          \
          RangeEnc_ShiftLow(p); \
     }

◆ REP_LEN_COUNT

#define REP_LEN_COUNT 64

Function Documentation

◆ lgetpor_ar()

int lgetpor_ar	(	__int64	max,
		__int64	fatia )

extern

◆ LzmaEnc_CodeOneMemBlock()

SRes LzmaEnc_CodeOneMemBlock	(	CLzmaEncHandle	p,
		BoolInt	reInit,
		Byte *	dest,
		size_t *	destLen,
		UInt32	desiredPackSize,
		UInt32 *	unpackSize )

◆ LzmaEnc_Create()

CLzmaEncHandle LzmaEnc_Create ( ISzAllocPtr alloc )

◆ LzmaEnc_Destroy()

void LzmaEnc_Destroy	(	CLzmaEncHandle	p,
		ISzAllocPtr	alloc,
		ISzAllocPtr	allocBig )

◆ LzmaEnc_Encode()

SRes LzmaEnc_Encode	(	CLzmaEncHandle	p,
		ISeqOutStreamPtr	outStream,
		ISeqInStreamPtr	inStream,
		ICompressProgressPtr	progress,
		ISzAllocPtr	alloc,
		ISzAllocPtr	allocBig )

◆ LzmaEnc_Finish()

void LzmaEnc_Finish ( CLzmaEncHandle p )

◆ LzmaEnc_GetCurBuf()

const Byte * LzmaEnc_GetCurBuf ( CLzmaEncHandle p )

◆ LzmaEnc_IsWriteEndMark()

unsigned LzmaEnc_IsWriteEndMark ( CLzmaEncHandle p )

◆ LzmaEnc_MemEncode()

SRes LzmaEnc_MemEncode	(	CLzmaEncHandle	p,
		Byte *	dest,
		SizeT *	destLen,
		const Byte *	src,
		SizeT	srcLen,
		int	writeEndMark,
		ICompressProgressPtr	progress,
		ISzAllocPtr	alloc,
		ISzAllocPtr	allocBig )

◆ LzmaEnc_MemPrepare()

SRes LzmaEnc_MemPrepare	(	CLzmaEncHandle	p,
		const Byte *	src,
		SizeT	srcLen,
		UInt32	keepWindowSize,
		ISzAllocPtr	alloc,
		ISzAllocPtr	allocBig )

◆ LzmaEnc_PrepareForLzma2()

SRes LzmaEnc_PrepareForLzma2	(	CLzmaEncHandle	p,
		ISeqInStreamPtr	inStream,
		UInt32	keepWindowSize,
		ISzAllocPtr	alloc,
		ISzAllocPtr	allocBig )

◆ LzmaEnc_RestoreState()

void LzmaEnc_RestoreState ( CLzmaEncHandle p )

◆ LzmaEnc_SaveState()

void LzmaEnc_SaveState ( CLzmaEncHandle p )

◆ LzmaEnc_SetDataSize()

void LzmaEnc_SetDataSize	(	CLzmaEncHandle	p,
		UInt64	expectedDataSiize )

◆ LzmaEnc_SetProps()

Z7_NO_INLINE SRes LzmaEnc_SetProps	(	CLzmaEncHandle	p,
		const CLzmaEncProps *	props2 )

◆ LzmaEnc_WriteProperties()

SRes LzmaEnc_WriteProperties	(	CLzmaEncHandle	p,
		Byte *	props,
		SizeT *	size )

◆ LzmaEncode()

SRes LzmaEncode	(	Byte *	dest,
		SizeT *	destLen,
		const Byte *	src,
		SizeT	srcLen,
		const CLzmaEncProps *	props,
		Byte *	propsEncoded,
		SizeT *	propsSize,
		int	writeEndMark,
		ICompressProgressPtr	progress,
		ISzAllocPtr	alloc,
		ISzAllocPtr	allocBig )

◆ LzmaEncProps_GetDictSize()

UInt32 LzmaEncProps_GetDictSize ( const CLzmaEncProps * props2 )

◆ LzmaEncProps_Init()

void LzmaEncProps_Init ( CLzmaEncProps * p )

◆ LzmaEncProps_Normalize()

void LzmaEncProps_Normalize ( CLzmaEncProps * p )

Data Structures

Macros

Functions

Macro Definition Documentation

◆ BSR2_RET

◆ ChangePair

◆ COPY_ARR

◆ COPY_LZMA_ENC_STATE

◆ GET_PRICE

◆ GET_PRICE_0

◆ GET_PRICE_1

◆ GET_PRICE_LEN

◆ GET_PRICEa

◆ GET_PRICEa_0

◆ GET_PRICEa_1

◆ GetLenToPosState

◆ GetLenToPosState2

◆ GetPosSlot

◆ GetPosSlot1

◆ GetPosSlot2

◆ GetPrice_Rep_0

◆ GetPrice_ShortRep

◆ IsLitState

◆ IsShortRep

◆ kAlignMask

◆ kAlignTableSize

◆ kBigHashDicLimit

◆ kBitModelTotal

◆ kDicLogSizeMax

◆ kDicLogSizeMaxCompress

◆ kDistTableSizeMax

◆ kEndPosModelIndex

◆ kInfinityPrice

◆ kLenNumHighBits

◆ kLenNumHighSymbols

◆ kLenNumLowBits

◆ kLenNumLowSymbols

◆ kLenNumSymbolsTotal

◆ kLzmaMaxHistorySize

◆ kNumAlignBits

◆ kNumBitModelTotalBits

◆ kNumBitPriceShiftBits

◆ kNumFullDistances

◆ kNumLenToPosStates

◆ kNumLogBits

◆ kNumMoveBits

◆ kNumMoveReducingBits

◆ kNumOpts

◆ kNumPosSlotBits

◆ kNumStates

◆ kPackReserve

◆ kProbInitValue

◆ kStartPosModelIndex

◆ kState_LitAfterMatch

◆ kState_LitAfterRep

◆ kState_MatchAfterLit

◆ kState_RepAfterLit

◆ kState_Start

◆ kTopValue

◆ LIT_PROBS

◆ LZMA_LC_MAX

◆ LZMA_LP_MAX

◆ LZMA_MATCH_LEN_MAX

◆ LZMA_MATCH_LEN_MIN

◆ LZMA_NUM_PB_STATES_MAX

◆ LZMA_NUM_REPS

◆ LZMA_PB_MAX

◆ MakeAs_Lit

◆ MakeAs_ShortRep

◆ MARK_LIT

◆ MATCHES

◆ MFB

◆ MOVE_POS

◆ RangeEnc_GetProcessed

◆ RangeEnc_GetProcessed_sizet

◆ RC_BIT

◆ RC_BIT_0

◆ RC_BIT_0_BASE

◆ RC_BIT_1

◆ RC_BIT_1_BASE