Do you verify the boot functionality (boot to shell)? Do you collect the image size (old LZMA version and new LZMA version)? Thanks Liming 发件人: Liu, WeiX C 发送时间: 2020年12月20日 21:34 收件人: gaoliming ; devel@edk2.groups.io 抄送: 'Laszlo Ersek' 主题: RE: [PATCH 1/2] BaseTools LzmaCompress: Update LZMA to new 19.00 version Hi liming, I listed unittest result as below with Ovmf build, cause I have no apple machine so only list VS、GCC and clang tool chain . VS2019 GCC5 CLANGPDB IA32 Pass Pass Pass X64 Pass Pass Pass IA32x64 Pass Pass Pass -----Original Message----- From: gaoliming > Sent: 2020年12月17日 9:30 To: Liu, WeiX C >; devel@edk2.groups.io Cc: 'Laszlo Ersek' > Subject: 回复: [PATCH 1/2] BaseTools LzmaCompress: Update LZMA to new 19.00 version Wei: Can you list the unit test for this patch? Which tool chain and arch have been verified? Because LZMA is well used, I request to verify it on VS, GCC, XCODE and CLANG tool chain for the different ARCHs. Thanks Liming > -----邮件原件----- > 发件人: Wei Liu > > 发送时间: 2020年12月15日 10:07 > 收件人: devel@edk2.groups.io > 抄送: Wei Liu >; Liming Gao > >; Laszlo Ersek > > 主题: [PATCH 1/2] BaseTools LzmaCompress: Update LZMA to new 19.00 > version > > REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3101 > New formal release in https://www.7-zip.org/sdk.html is 19.00. > > Cc: Liming Gao > > > Cc: Laszlo Ersek > > Signed-off-by: Wei Liu > > --- > BaseTools/Source/C/LzmaCompress/LZMA-SDK-README.txt | 4 > ++-- > BaseTools/Source/C/LzmaCompress/LzmaCompress.c | 8 > ++++---- > BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h | 5 > +++-- > BaseTools/Source/C/LzmaCompress/Sdk/C/7zVersion.h | 8 > ++++---- > BaseTools/Source/C/LzmaCompress/Sdk/C/CpuArch.h | 9 > +++++---- > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c | 164 > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > +++++++++++++++++++++++++++++++++++++++++++++++++-------------------- > --------------------------------- > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c | 117 > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > +++++++++++++------------------------------------------ > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h | 14 > +++++++------- > BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c | 32 > ++++++++++++++++---------------- > BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c | 733 > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > ++++++++++++++++++++++++++-------------------------------------------------- ---- > ---------------------------------------------------------------------------- ----------------- > ---------------------------------------------------------------------------- ----------------- > --------------------------------- > BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt | 22 > ++++++++++++++++++++++ > BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt | 2 +- > 12 files changed, 710 insertions(+), 408 deletions(-) > > diff --git a/BaseTools/Source/C/LzmaCompress/LZMA-SDK-README.txt > b/BaseTools/Source/C/LzmaCompress/LZMA-SDK-README.txt > index 7cf967a774..b2338e2598 100644 > --- a/BaseTools/Source/C/LzmaCompress/LZMA-SDK-README.txt > +++ b/BaseTools/Source/C/LzmaCompress/LZMA-SDK-README.txt > @@ -1,3 +1,3 @@ > -LzmaCompress is based on the LZMA SDK 18.05. LZMA SDK 18.05 > > -was placed in the public domain on 2018-04-30. It was > > +LzmaCompress is based on the LZMA SDK 19.00. LZMA SDK 19.00 > > +was placed in the public domain on 2019-02-21. It was > > released on the http://www.7-zip.org/sdk.html website. > > diff --git a/BaseTools/Source/C/LzmaCompress/LzmaCompress.c > b/BaseTools/Source/C/LzmaCompress/LzmaCompress.c > index bebdb9aa84..bf4706ee23 100644 > --- a/BaseTools/Source/C/LzmaCompress/LzmaCompress.c > +++ b/BaseTools/Source/C/LzmaCompress/LzmaCompress.c > @@ -1,9 +1,9 @@ > /** @file > > LZMA Compress/Decompress tool (LzmaCompress) > > > > - Based on LZMA SDK 18.05: > > + Based on LZMA SDK 19.00: > > LzmaUtil.c -- Test application for LZMA compression > > - 2018-04-30 : Igor Pavlov : Public domain > > + 2019-02-21 : Igor Pavlov : Public domain > > > > Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.
> > SPDX-License-Identifier: BSD-2-Clause-Patent > > @@ -39,7 +39,7 @@ const char *kCantAllocateMessage = "Can not allocate > memory"; > const char *kDataErrorMessage = "Data error"; > > const char *kInvalidParamValMessage = "Invalid parameter value"; > > > > -static Bool mQuietMode = False; > > +static BoolInt mQuietMode = False; > > static CONVERTER_TYPE mConType = NoConverter; > > > > UINT64 mDictionarySize = 28; > > @@ -244,7 +244,7 @@ int main2(int numArgs, const char *args[], char *rs) > CFileOutStream outStream; > > int res; > > int encodeMode = 0; > > - Bool modeWasSet = False; > > + BoolInt modeWasSet = False; > > const char *inputFile = NULL; > > const char *outputFile = "file.tmp"; > > int param; > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h > b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h > index 4977cdaa66..593f5aa259 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h > @@ -1,5 +1,5 @@ > /* 7zTypes.h -- Basic types > > -2017-07-17 : Igor Pavlov : Public domain */ > > +2018-08-04 : Igor Pavlov : Public domain */ > > > > #ifndef __7Z_TYPES_H > > #define __7Z_TYPES_H > > @@ -103,7 +103,8 @@ typedef UInt32 SizeT; > typedef size_t SizeT; > > #endif > > > > -typedef int Bool; > > +typedef int BoolInt; > > +/* typedef BoolInt Bool; */ > > #define True 1 > > #define False 0 > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zVersion.h > b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zVersion.h > index ed3aa94270..0074c64be9 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zVersion.h > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zVersion.h > @@ -1,7 +1,7 @@ > -#define MY_VER_MAJOR 18 > > -#define MY_VER_MINOR 05 > > +#define MY_VER_MAJOR 19 > > +#define MY_VER_MINOR 00 > > #define MY_VER_BUILD 0 > > -#define MY_VERSION_NUMBERS "18.05" > > +#define MY_VERSION_NUMBERS "19.00" > > #define MY_VERSION MY_VERSION_NUMBERS > > > > #ifdef MY_CPU_NAME > > @@ -10,7 +10,7 @@ > #define MY_VERSION_CPU MY_VERSION > > #endif > > > > -#define MY_DATE "2018-04-30" > > +#define MY_DATE "2019-02-21" > > #undef MY_COPYRIGHT > > #undef MY_VERSION_COPYRIGHT_DATE > > #define MY_AUTHOR_NAME "Igor Pavlov" > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/CpuArch.h > b/BaseTools/Source/C/LzmaCompress/Sdk/C/CpuArch.h > index 7fb27282c7..5f74c1c0cb 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/CpuArch.h > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/CpuArch.h > @@ -1,5 +1,5 @@ > /* CpuArch.h -- CPU specific code > > -2017-09-04 : Igor Pavlov : Public domain */ > > +2018-02-18 : Igor Pavlov : Public domain */ > > > > #ifndef __CPU_ARCH_H > > #define __CPU_ARCH_H > > @@ -318,15 +318,16 @@ enum > > > void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d); > > > > -Bool x86cpuid_CheckAndRead(Cx86cpuid *p); > > +BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p); > > int x86cpuid_GetFirm(const Cx86cpuid *p); > > > > #define x86cpuid_GetFamily(ver) (((ver >> 16) & 0xFF0) | ((ver >> 8) & 0xF)) > > #define x86cpuid_GetModel(ver) (((ver >> 12) & 0xF0) | ((ver >> 4) & > 0xF)) > > #define x86cpuid_GetStepping(ver) (ver & 0xF) > > > > -Bool CPU_Is_InOrder(); > > -Bool CPU_Is_Aes_Supported(); > > +BoolInt CPU_Is_InOrder(); > > +BoolInt CPU_Is_Aes_Supported(); > > +BoolInt CPU_IsSupported_PageGB(); > > > > #endif > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c > b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c > index 6ea82a9b53..4eefc17dd2 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c > @@ -1,5 +1,5 @@ > /* LzFind.c -- Match finder for LZ algorithms > > -2017-06-10 : Igor Pavlov : Public domain */ > > +2018-07-08 : Igor Pavlov : Public domain */ > > > > #include "Precomp.h" > > > > @@ -138,7 +138,7 @@ static void > MatchFinder_SetDefaultSettings(CMatchFinder *p) > > > void MatchFinder_Construct(CMatchFinder *p) > > { > > - UInt32 i; > > + unsigned i; > > p->bufferBase = NULL; > > p->directInput = 0; > > p->hash = NULL; > > @@ -147,7 +147,7 @@ void MatchFinder_Construct(CMatchFinder *p) > > > for (i = 0; i < 256; i++) > > { > > - UInt32 r = i; > > + UInt32 r = (UInt32)i; > > unsigned j; > > for (j = 0; j < 8; j++) > > r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1))); > > @@ -368,6 +368,8 @@ static void MatchFinder_Normalize(CMatchFinder *p) > MatchFinder_ReduceOffsets(p, subValue); > > } > > > > + > > +MY_NO_INLINE > > static void MatchFinder_CheckLimits(CMatchFinder *p) > > { > > if (p->pos == kMaxValForNormalize) > > @@ -379,10 +381,16 @@ static void > MatchFinder_CheckLimits(CMatchFinder *p) > MatchFinder_SetLimits(p); > > } > > > > -static UInt32 * Hc_GetMatchesSpec(UInt32 lenLimit, UInt32 curMatch, > UInt32 pos, const Byte *cur, CLzRef *son, > > + > > +/* > > + (lenLimit > maxLen) > > +*/ > > +MY_FORCE_INLINE > > +static UInt32 * Hc_GetMatchesSpec(unsigned lenLimit, UInt32 curMatch, > UInt32 pos, const Byte *cur, CLzRef *son, > > UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue, > > - UInt32 *distances, UInt32 maxLen) > > + UInt32 *distances, unsigned maxLen) > > { > > + /* > > son[_cyclicBufferPos] = curMatch; > > for (;;) > > { > > @@ -400,7 +408,8 @@ static UInt32 * Hc_GetMatchesSpec(UInt32 lenLimit, > UInt32 curMatch, UInt32 pos, > break; > > if (maxLen < len) > > { > > - *distances++ = maxLen = len; > > + maxLen = len; > > + *distances++ = len; > > *distances++ = delta - 1; > > if (len == lenLimit) > > return distances; > > @@ -408,15 +417,58 @@ static UInt32 * Hc_GetMatchesSpec(UInt32 > lenLimit, UInt32 curMatch, UInt32 pos, > } > > } > > } > > + */ > > + > > + const Byte *lim = cur + lenLimit; > > + son[_cyclicBufferPos] = curMatch; > > + do > > + { > > + UInt32 delta = pos - curMatch; > > + if (delta >= _cyclicBufferSize) > > + break; > > + { > > + ptrdiff_t diff; > > + curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? > _cyclicBufferSize : 0)]; > > + diff = (ptrdiff_t)0 - delta; > > + if (cur[maxLen] == cur[maxLen + diff]) > > + { > > + const Byte *c = cur; > > + while (*c == c[diff]) > > + { > > + if (++c == lim) > > + { > > + distances[0] = (UInt32)(lim - cur); > > + distances[1] = delta - 1; > > + return distances + 2; > > + } > > + } > > + { > > + unsigned len = (unsigned)(c - cur); > > + if (maxLen < len) > > + { > > + maxLen = len; > > + distances[0] = (UInt32)len; > > + distances[1] = delta - 1; > > + distances += 2; > > + } > > + } > > + } > > + } > > + } > > + while (--cutValue); > > + > > + return distances; > > } > > > > + > > +MY_FORCE_INLINE > > UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, > const Byte *cur, CLzRef *son, > > UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue, > > UInt32 *distances, UInt32 maxLen) > > { > > - CLzRef *ptr0 = son + (_cyclicBufferPos << 1) + 1; > > - CLzRef *ptr1 = son + (_cyclicBufferPos << 1); > > - UInt32 len0 = 0, len1 = 0; > > + CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1; > > + CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1); > > + unsigned len0 = 0, len1 = 0; > > for (;;) > > { > > UInt32 delta = pos - curMatch; > > @@ -426,9 +478,10 @@ UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 > curMatch, UInt32 pos, const Byt > return distances; > > } > > { > > - CLzRef *pair = son + ((_cyclicBufferPos - delta + ((delta > > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1); > > + CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1); > > const Byte *pb = cur - delta; > > - UInt32 len = (len0 < len1 ? len0 : len1); > > + unsigned len = (len0 < len1 ? len0 : len1); > > + UInt32 pair0 = pair[0]; > > if (pb[len] == cur[len]) > > { > > if (++len != lenLimit && pb[len] == cur[len]) > > @@ -437,11 +490,12 @@ UInt32 * GetMatchesSpec1(UInt32 lenLimit, > UInt32 curMatch, UInt32 pos, const Byt > break; > > if (maxLen < len) > > { > > - *distances++ = maxLen = len; > > + maxLen = (UInt32)len; > > + *distances++ = (UInt32)len; > > *distances++ = delta - 1; > > if (len == lenLimit) > > { > > - *ptr1 = pair[0]; > > + *ptr1 = pair0; > > *ptr0 = pair[1]; > > return distances; > > } > > @@ -468,9 +522,9 @@ UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 > curMatch, UInt32 pos, const Byt > static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, > const Byte *cur, CLzRef *son, > > UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue) > > { > > - CLzRef *ptr0 = son + (_cyclicBufferPos << 1) + 1; > > - CLzRef *ptr1 = son + (_cyclicBufferPos << 1); > > - UInt32 len0 = 0, len1 = 0; > > + CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1; > > + CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1); > > + unsigned len0 = 0, len1 = 0; > > for (;;) > > { > > UInt32 delta = pos - curMatch; > > @@ -480,9 +534,9 @@ static void SkipMatchesSpec(UInt32 lenLimit, UInt32 > curMatch, UInt32 pos, const > return; > > } > > { > > - CLzRef *pair = son + ((_cyclicBufferPos - delta + ((delta > > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1); > > + CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1); > > const Byte *pb = cur - delta; > > - UInt32 len = (len0 < len1 ? len0 : len1); > > + unsigned len = (len0 < len1 ? len0 : len1); > > if (pb[len] == cur[len]) > > { > > while (++len != lenLimit) > > @@ -520,13 +574,13 @@ static void SkipMatchesSpec(UInt32 lenLimit, > UInt32 curMatch, UInt32 pos, const > p->buffer++; \ > > if (++p->pos == p->posLimit) MatchFinder_CheckLimits(p); > > > > -#define MOVE_POS_RET MOVE_POS return offset; > > +#define MOVE_POS_RET MOVE_POS return (UInt32)offset; > > > > static void MatchFinder_MovePos(CMatchFinder *p) { MOVE_POS; } > > > > #define GET_MATCHES_HEADER2(minLen, ret_op) \ > > - UInt32 lenLimit; UInt32 hv; const Byte *cur; UInt32 curMatch; \ > > - lenLimit = p->lenLimit; { if (lenLimit < minLen) { MatchFinder_MovePos(p); > ret_op; }} \ > > + unsigned lenLimit; UInt32 hv; const Byte *cur; UInt32 curMatch; \ > > + lenLimit = (unsigned)p->lenLimit; { if (lenLimit < minLen) > { MatchFinder_MovePos(p); ret_op; }} \ > > cur = p->buffer; > > > > #define GET_MATCHES_HEADER(minLen) GET_MATCHES_HEADER2(minLen, > return 0) > > @@ -535,22 +589,22 @@ static void MatchFinder_MovePos(CMatchFinder > *p) { MOVE_POS; } > #define MF_PARAMS(p) p->pos, p->buffer, p->son, p->cyclicBufferPos, > p->cyclicBufferSize, p->cutValue > > > > #define GET_MATCHES_FOOTER(offset, maxLen) \ > > - offset = (UInt32)(GetMatchesSpec1(lenLimit, curMatch, MF_PARAMS(p), \ > > - distances + offset, maxLen) - distances); MOVE_POS_RET; > > + offset = (unsigned)(GetMatchesSpec1((UInt32)lenLimit, curMatch, > MF_PARAMS(p), \ > > + distances + offset, (UInt32)maxLen) - distances); MOVE_POS_RET; > > > > #define SKIP_FOOTER \ > > - SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p)); MOVE_POS; > > + SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p)); > MOVE_POS; > > > > #define UPDATE_maxLen { \ > > ptrdiff_t diff = (ptrdiff_t)0 - d2; \ > > const Byte *c = cur + maxLen; \ > > const Byte *lim = cur + lenLimit; \ > > for (; c != lim; c++) if (*(c + diff) != *c) break; \ > > - maxLen = (UInt32)(c - cur); } > > + maxLen = (unsigned)(c - cur); } > > > > static UInt32 Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 > *distances) > > { > > - UInt32 offset; > > + unsigned offset; > > GET_MATCHES_HEADER(2) > > HASH2_CALC; > > curMatch = p->hash[hv]; > > @@ -561,7 +615,7 @@ static UInt32 > Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 > *distances) > > { > > - UInt32 offset; > > + unsigned offset; > > GET_MATCHES_HEADER(3) > > HASH_ZIP_CALC; > > curMatch = p->hash[hv]; > > @@ -572,7 +626,8 @@ UInt32 > Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 > *distances) > > { > > - UInt32 h2, d2, maxLen, offset, pos; > > + UInt32 h2, d2, pos; > > + unsigned maxLen, offset; > > UInt32 *hash; > > GET_MATCHES_HEADER(3) > > > > @@ -594,12 +649,12 @@ static UInt32 > Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur) > > { > > UPDATE_maxLen > > - distances[0] = maxLen; > > + distances[0] = (UInt32)maxLen; > > distances[1] = d2 - 1; > > offset = 2; > > if (maxLen == lenLimit) > > { > > - SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p)); > > + SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p)); > > MOVE_POS_RET; > > } > > } > > @@ -609,7 +664,8 @@ static UInt32 > Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 > *distances) > > { > > - UInt32 h2, h3, d2, d3, maxLen, offset, pos; > > + UInt32 h2, h3, d2, d3, pos; > > + unsigned maxLen, offset; > > UInt32 *hash; > > GET_MATCHES_HEADER(4) > > > > @@ -618,12 +674,12 @@ static UInt32 > Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > hash = p->hash; > > pos = p->pos; > > > > - d2 = pos - hash[ h2]; > > + d2 = pos - hash [h2]; > > d3 = pos - (hash + kFix3HashSize)[h3]; > > > > curMatch = (hash + kFix4HashSize)[hv]; > > > > - hash[ h2] = pos; > > + hash [h2] = pos; > > (hash + kFix3HashSize)[h3] = pos; > > (hash + kFix4HashSize)[hv] = pos; > > > > @@ -632,7 +688,8 @@ static UInt32 > Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur) > > { > > - distances[0] = maxLen = 2; > > + maxLen = 2; > > + distances[0] = 2; > > distances[1] = d2 - 1; > > offset = 2; > > } > > @@ -648,10 +705,10 @@ static UInt32 > Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > if (offset != 0) > > { > > UPDATE_maxLen > > - distances[(size_t)offset - 2] = maxLen; > > + distances[(size_t)offset - 2] = (UInt32)maxLen; > > if (maxLen == lenLimit) > > { > > - SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p)); > > + SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p)); > > MOVE_POS_RET; > > } > > } > > @@ -674,13 +731,13 @@ static UInt32 > Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > hash = p->hash; > > pos = p->pos; > > > > - d2 = pos - hash[ h2]; > > + d2 = pos - hash [h2]; > > d3 = pos - (hash + kFix3HashSize)[h3]; > > d4 = pos - (hash + kFix4HashSize)[h4]; > > > > curMatch = (hash + kFix5HashSize)[hv]; > > > > - hash[ h2] = pos; > > + hash [h2] = pos; > > (hash + kFix3HashSize)[h3] = pos; > > (hash + kFix4HashSize)[h4] = pos; > > (hash + kFix5HashSize)[hv] = pos; > > @@ -741,7 +798,8 @@ static UInt32 > Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 > *distances) > > { > > - UInt32 h2, h3, d2, d3, maxLen, offset, pos; > > + UInt32 h2, h3, d2, d3, pos; > > + unsigned maxLen, offset; > > UInt32 *hash; > > GET_MATCHES_HEADER(4) > > > > @@ -750,12 +808,11 @@ static UInt32 > Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > hash = p->hash; > > pos = p->pos; > > > > - d2 = pos - hash[ h2]; > > + d2 = pos - hash [h2]; > > d3 = pos - (hash + kFix3HashSize)[h3]; > > - > > curMatch = (hash + kFix4HashSize)[hv]; > > > > - hash[ h2] = pos; > > + hash [h2] = pos; > > (hash + kFix3HashSize)[h3] = pos; > > (hash + kFix4HashSize)[hv] = pos; > > > > @@ -764,7 +821,8 @@ static UInt32 > Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur) > > { > > - distances[0] = maxLen = 2; > > + maxLen = 2; > > + distances[0] = 2; > > distances[1] = d2 - 1; > > offset = 2; > > } > > @@ -780,7 +838,7 @@ static UInt32 > Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > if (offset != 0) > > { > > UPDATE_maxLen > > - distances[(size_t)offset - 2] = maxLen; > > + distances[(size_t)offset - 2] = (UInt32)maxLen; > > if (maxLen == lenLimit) > > { > > p->son[p->cyclicBufferPos] = curMatch; > > @@ -791,7 +849,7 @@ static UInt32 > Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > if (maxLen < 3) > > maxLen = 3; > > > > - offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p), > > + offset = (unsigned)(Hc_GetMatchesSpec(lenLimit, curMatch, > MF_PARAMS(p), > > distances + offset, maxLen) - (distances)); > > MOVE_POS_RET > > } > > @@ -808,13 +866,13 @@ static UInt32 > Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > hash = p->hash; > > pos = p->pos; > > > > - d2 = pos - hash[ h2]; > > + d2 = pos - hash [h2]; > > d3 = pos - (hash + kFix3HashSize)[h3]; > > d4 = pos - (hash + kFix4HashSize)[h4]; > > > > curMatch = (hash + kFix5HashSize)[hv]; > > > > - hash[ h2] = pos; > > + hash [h2] = pos; > > (hash + kFix3HashSize)[h3] = pos; > > (hash + kFix4HashSize)[h4] = pos; > > (hash + kFix5HashSize)[hv] = pos; > > @@ -877,12 +935,12 @@ static UInt32 > Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 > *distances) > > { > > - UInt32 offset; > > + unsigned offset; > > GET_MATCHES_HEADER(3) > > HASH_ZIP_CALC; > > curMatch = p->hash[hv]; > > p->hash[hv] = p->pos; > > - offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p), > > + offset = (unsigned)(Hc_GetMatchesSpec(lenLimit, curMatch, > MF_PARAMS(p), > > distances, 2) - (distances)); > > MOVE_POS_RET > > } > > @@ -940,7 +998,7 @@ static void Bt4_MatchFinder_Skip(CMatchFinder *p, > UInt32 num) > HASH4_CALC; > > hash = p->hash; > > curMatch = (hash + kFix4HashSize)[hv]; > > - hash[ h2] = > > + hash [h2] = > > (hash + kFix3HashSize)[h3] = > > (hash + kFix4HashSize)[hv] = p->pos; > > SKIP_FOOTER > > @@ -959,7 +1017,7 @@ static void Bt5_MatchFinder_Skip(CMatchFinder *p, > UInt32 num) > HASH5_CALC; > > hash = p->hash; > > curMatch = (hash + kFix5HashSize)[hv]; > > - hash[ h2] = > > + hash [h2] = > > (hash + kFix3HashSize)[h3] = > > (hash + kFix4HashSize)[h4] = > > (hash + kFix5HashSize)[hv] = p->pos; > > @@ -979,7 +1037,7 @@ static void Hc4_MatchFinder_Skip(CMatchFinder *p, > UInt32 num) > HASH4_CALC; > > hash = p->hash; > > curMatch = (hash + kFix4HashSize)[hv]; > > - hash[ h2] = > > + hash [h2] = > > (hash + kFix3HashSize)[h3] = > > (hash + kFix4HashSize)[hv] = p->pos; > > p->son[p->cyclicBufferPos] = curMatch; > > @@ -999,7 +1057,7 @@ static void Hc5_MatchFinder_Skip(CMatchFinder *p, > UInt32 num) > HASH5_CALC; > > hash = p->hash; > > curMatch = hash + kFix5HashSize)[hv]; > > - hash[ h2] = > > + hash [h2] = > > (hash + kFix3HashSize)[h3] = > > (hash + kFix4HashSize)[h4] = > > (hash + kFix5HashSize)[hv] = p->pos; > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c > b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c > index 2563824fcd..df32146f92 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c > @@ -1,5 +1,5 @@ > /* LzFindMt.c -- multithreaded Match finder for LZ algorithms > > -2017-06-10 : Igor Pavlov : Public domain */ > > +2018-12-29 : Igor Pavlov : Public domain */ > > > > #include "Precomp.h" > > > > @@ -232,38 +232,57 @@ static void > MatchFinderMt_GetNextBlock_Hash(CMatchFinderMt *p) > > > #define kEmptyHashValue 0 > > > > -/* #define MFMT_GM_INLINE */ > > +#define MFMT_GM_INLINE > > > > #ifdef MFMT_GM_INLINE > > > > -#define NO_INLINE MY_FAST_CALL > > +/* > > + we use size_t for _cyclicBufferPos instead of UInt32 > > + to eliminate "movsx" BUG in old MSVC x64 compiler. > > +*/ > > > > -static Int32 NO_INLINE GetMatchesSpecN(UInt32 lenLimit, UInt32 pos, > const Byte *cur, CLzRef *son, > > - UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue, > > - UInt32 *_distances, UInt32 _maxLen, const UInt32 *hash, Int32 limit, > UInt32 size, UInt32 *posRes) > > +MY_NO_INLINE > > +static UInt32 *GetMatchesSpecN(UInt32 lenLimit, UInt32 pos, const Byte > *cur, CLzRef *son, > > + size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue, > > + UInt32 *distances, UInt32 _maxLen, const UInt32 *hash, const UInt32 > *limit, UInt32 size, UInt32 *posRes) > > { > > do > > { > > - UInt32 *distances = _distances + 1; > > - UInt32 curMatch = pos - *hash++; > > + UInt32 *_distances = ++distances; > > + UInt32 delta = *hash++; > > > > - CLzRef *ptr0 = son + (_cyclicBufferPos << 1) + 1; > > - CLzRef *ptr1 = son + (_cyclicBufferPos << 1); > > - UInt32 len0 = 0, len1 = 0; > > + CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1; > > + CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1); > > + unsigned len0 = 0, len1 = 0; > > UInt32 cutValue = _cutValue; > > - UInt32 maxLen = _maxLen; > > - for (;;) > > + unsigned maxLen = (unsigned)_maxLen; > > + > > + /* > > + if (size > 1) > > { > > - UInt32 delta = pos - curMatch; > > - if (cutValue-- == 0 || delta >= _cyclicBufferSize) > > + UInt32 delta = *hash; > > + if (delta < _cyclicBufferSize) > > { > > - *ptr0 = *ptr1 = kEmptyHashValue; > > - break; > > + UInt32 cyc1 = _cyclicBufferPos + 1; > > + CLzRef *pair = son + ((size_t)(cyc1 - delta + ((delta > cyc1) ? > _cyclicBufferSize : 0)) << 1); > > + Byte b = *(cur + 1 - delta); > > + _distances[0] = pair[0]; > > + _distances[1] = b; > > } > > + } > > + */ > > + if (cutValue == 0 || delta >= _cyclicBufferSize) > > + { > > + *ptr0 = *ptr1 = kEmptyHashValue; > > + } > > + else > > + for(;;) > > + { > > { > > - CLzRef *pair = son + ((_cyclicBufferPos - delta + ((delta > > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1); > > + CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + > ((_cyclicBufferPos < delta) ? _cyclicBufferSize : 0)) << 1); > > const Byte *pb = cur - delta; > > - UInt32 len = (len0 < len1 ? len0 : len1); > > + unsigned len = (len0 < len1 ? len0 : len1); > > + UInt32 pair0 = *pair; > > if (pb[len] == cur[len]) > > { > > if (++len != lenLimit && pb[len] == cur[len]) > > @@ -272,54 +291,66 @@ static Int32 NO_INLINE GetMatchesSpecN(UInt32 > lenLimit, UInt32 pos, const Byte * > break; > > if (maxLen < len) > > { > > - *distances++ = maxLen = len; > > + maxLen = len; > > + *distances++ = (UInt32)len; > > *distances++ = delta - 1; > > if (len == lenLimit) > > { > > - *ptr1 = pair[0]; > > - *ptr0 = pair[1]; > > + UInt32 pair1 = pair[1]; > > + *ptr1 = pair0; > > + *ptr0 = pair1; > > break; > > } > > } > > } > > - if (pb[len] < cur[len]) > > - { > > - *ptr1 = curMatch; > > - ptr1 = pair + 1; > > - curMatch = *ptr1; > > - len1 = len; > > - } > > - else > > { > > - *ptr0 = curMatch; > > - ptr0 = pair; > > - curMatch = *ptr0; > > - len0 = len; > > + UInt32 curMatch = pos - delta; > > + // delta = pos - *pair; > > + // delta = pos - pair[((UInt32)pb[len] - (UInt32)cur[len]) >> 31]; > > + if (pb[len] < cur[len]) > > + { > > + delta = pos - pair[1]; > > + *ptr1 = curMatch; > > + ptr1 = pair + 1; > > + len1 = len; > > + } > > + else > > + { > > + delta = pos - *pair; > > + *ptr0 = curMatch; > > + ptr0 = pair; > > + len0 = len; > > + } > > } > > } > > + if (--cutValue == 0 || delta >= _cyclicBufferSize) > > + { > > + *ptr0 = *ptr1 = kEmptyHashValue; > > + break; > > + } > > } > > pos++; > > _cyclicBufferPos++; > > cur++; > > { > > UInt32 num = (UInt32)(distances - _distances); > > - *_distances = num - 1; > > - _distances += num; > > - limit -= num; > > + _distances[-1] = num; > > } > > } > > - while (limit > 0 && --size != 0); > > + while (distances < limit && --size != 0); > > *posRes = pos; > > - return limit; > > + return distances; > > } > > > > #endif > > > > + > > + > > static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances) > > { > > UInt32 numProcessed = 0; > > UInt32 curPos = 2; > > - UInt32 limit = kMtBtBlockSize - (p->matchMaxLen * 2); > > + UInt32 limit = kMtBtBlockSize - (p->matchMaxLen * 2); // * 2 > > > > distances[1] = p->hashNumAvail; > > > > @@ -369,8 +400,10 @@ static void BtGetMatches(CMatchFinderMt *p, > UInt32 *distances) > #else > > { > > UInt32 posRes; > > - curPos = limit - GetMatchesSpecN(lenLimit, pos, p->buffer, p->son, > cyclicBufferPos, p->cyclicBufferSize, p->cutValue, > > - distances + curPos, p->numHashBytes - 1, p->hashBuf + > p->hashBufPos, (Int32)(limit - curPos), size, &posRes); > > + curPos = (UInt32)(GetMatchesSpecN(lenLimit, pos, p->buffer, > p->son, cyclicBufferPos, p->cyclicBufferSize, p->cutValue, > > + distances + curPos, p->numHashBytes - 1, p->hashBuf + > p->hashBufPos, > > + distances + limit, > > + size, &posRes) - distances); > > p->hashBufPos += posRes - pos; > > cyclicBufferPos += posRes - pos; > > p->buffer += posRes - pos; > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h > b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h > index 3d86c788f3..fdd17008c2 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h > @@ -1,5 +1,5 @@ > /* LzFindMt.h -- multithreaded Match finder for LZ algorithms > > -2017-04-03 : Igor Pavlov : Public domain */ > > +2018-07-04 : Igor Pavlov : Public domain */ > > > > #ifndef __LZ_FIND_MT_H > > #define __LZ_FIND_MT_H > > @@ -19,10 +19,10 @@ EXTERN_C_BEGIN > > > typedef struct _CMtSync > > { > > - Bool wasCreated; > > - Bool needStart; > > - Bool exit; > > - Bool stopWriting; > > + BoolInt wasCreated; > > + BoolInt needStart; > > + BoolInt exit; > > + BoolInt stopWriting; > > > > CThread thread; > > CAutoResetEvent canStart; > > @@ -30,8 +30,8 @@ typedef struct _CMtSync > CAutoResetEvent wasStopped; > > CSemaphore freeSemaphore; > > CSemaphore filledSemaphore; > > - Bool csWasInitialized; > > - Bool csWasEntered; > > + BoolInt csWasInitialized; > > + BoolInt csWasEntered; > > CCriticalSection cs; > > UInt32 numProcessedBlocks; > > } CMtSync; > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c > b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c > index 962b94bb63..4d1576419f 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c > @@ -1,13 +1,13 @@ > /* LzmaDec.c -- LZMA Decoder > > -2018-02-28 : Igor Pavlov : Public domain */ > > +2018-07-04 : Igor Pavlov : Public domain */ > > > > #include "Precomp.h" > > > > +#include > > + > > /* #include "CpuArch.h" */ > > #include "LzmaDec.h" > > > > -#include > > - > > #define kNumTopBits 24 > > #define kTopValue ((UInt32)1 << kNumTopBits) > > > > @@ -19,7 +19,7 @@ > > > #define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) > | (*buf++); } > > > > -#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> > kNumBitModelTotalBits) * ttt; if (code < bound) > > +#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> > kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound) > > #define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + > ((kBitModelTotal - ttt) >> kNumMoveBits)); > > #define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt > - (ttt >> kNumMoveBits)); > > #define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \ > > @@ -66,7 +66,7 @@ > > > #define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) > return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); } > > > > -#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> > kNumBitModelTotalBits) * ttt; if (code < bound) > > +#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> > kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound) > > #define UPDATE_0_CHECK range = bound; > > #define UPDATE_1_CHECK range -= bound; code -= bound; > > #define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \ > > @@ -539,7 +539,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec > *p, SizeT limit, const Byte *bufLimit > curLen = ((rem < len) ? (unsigned)rem : len); > > pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0); > > > > - processedPos += curLen; > > + processedPos += (UInt32)curLen; > > > > len -= curLen; > > if (curLen <= dicBufSize - pos) > > @@ -547,7 +547,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec > *p, SizeT limit, const Byte *bufLimit > Byte *dest = dic + dicPos; > > ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos; > > const Byte *lim = dest + curLen; > > - dicPos += curLen; > > + dicPos += (SizeT)curLen; > > do > > *(dest) = (Byte)*(dest + src); > > while (++dest != lim); > > @@ -572,14 +572,14 @@ int MY_FAST_CALL > LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit > p->buf = buf; > > p->range = range; > > p->code = code; > > - p->remainLen = len; > > + p->remainLen = (UInt32)len; > > p->dicPos = dicPos; > > p->processedPos = processedPos; > > p->reps[0] = rep0; > > p->reps[1] = rep1; > > p->reps[2] = rep2; > > p->reps[3] = rep3; > > - p->state = state; > > + p->state = (UInt32)state; > > > > return SZ_OK; > > } > > @@ -601,8 +601,8 @@ static void MY_FAST_CALL > LzmaDec_WriteRem(CLzmaDec *p, SizeT limit) > if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len) > > p->checkDicSize = p->prop.dicSize; > > > > - p->processedPos += len; > > - p->remainLen -= len; > > + p->processedPos += (UInt32)len; > > + p->remainLen -= (UInt32)len; > > while (len != 0) > > { > > len--; > > @@ -850,7 +850,7 @@ static ELzmaDummy LzmaDec_TryDummy(const > CLzmaDec *p, const Byte *buf, SizeT inS > } > > > > > > -void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState) > > +void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt > initState) > > { > > p->remainLen = kMatchSpecLenStart + 1; > > p->tempBufSize = 0; > > @@ -979,10 +979,10 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT > dicLimit, const Byte *src, SizeT *sr > p->tempBufSize = rem; > > if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow) > > { > > - int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem); > > + int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, > (SizeT)rem); > > if (dummyRes == DUMMY_ERROR) > > { > > - (*srcLen) += lookAhead; > > + (*srcLen) += (SizeT)lookAhead; > > *status = LZMA_STATUS_NEEDS_MORE_INPUT; > > return SZ_OK; > > } > > @@ -1005,9 +1005,9 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT > dicLimit, const Byte *src, SizeT *sr > return SZ_ERROR_FAIL; /* some internal error */ > > lookAhead -= rem; > > } > > - (*srcLen) += lookAhead; > > + (*srcLen) += (SizeT)lookAhead; > > src += lookAhead; > > - inSize -= lookAhead; > > + inSize -= (SizeT)lookAhead; > > p->tempBufSize = 0; > > } > > } > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c > b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c > index e281716fee..14086fc4f9 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c > @@ -1,5 +1,5 @@ > /* LzmaEnc.c -- LZMA Encoder > > -2018-04-29 : Igor Pavlov : Public domain */ > > +2019-01-10: Igor Pavlov : Public domain */ > > > > #include "Precomp.h" > > > > @@ -38,6 +38,8 @@ static unsigned g_STAT_OFFSET = 0; > #define kNumBitPriceShiftBits 4 > > #define kBitPrice (1 << kNumBitPriceShiftBits) > > > > +#define REP_LEN_COUNT 64 > > + > > void LzmaEncProps_Init(CLzmaEncProps *p) > > { > > p->level = 5; > > @@ -183,8 +185,11 @@ typedef struct > } COptimal; > > > > > > -#define kNumOpts (1 << 12) > > -#define kPackReserve (1 + kNumOpts * 2) > > +// 18.06 > > +#define kNumOpts (1 << 11) > > +#define kPackReserve (kNumOpts * 8) > > +// #define kNumOpts (1 << 12) > > +// #define kPackReserve (1 + kNumOpts * 2) > > > > #define kNumLenToPosStates 4 > > #define kNumPosSlotBits 6 > > @@ -236,10 +241,18 @@ typedef struct > typedef struct > > { > > unsigned tableSize; > > - unsigned counters[LZMA_NUM_PB_STATES_MAX]; > > UInt32 prices[LZMA_NUM_PB_STATES_MAX][kLenNumSymbolsTotal]; > > + // UInt32 prices1[LZMA_NUM_PB_STATES_MAX][kLenNumLowSymbols * > 2]; > > + // UInt32 prices2[kLenNumSymbolsTotal]; > > } CLenPriceEnc; > > > > +#define GET_PRICE_LEN(p, posState, len) \ > > + ((p)->prices[posState][(size_t)(len) - LZMA_MATCH_LEN_MIN]) > > + > > +/* > > +#define GET_PRICE_LEN(p, posState, len) \ > > + ((p)->prices2[(size_t)(len) - 2] + ((p)->prices1[posState][((len) - 2) & > (kLenNumLowSymbols * 2 - 1)] & (((len) - 2 - kLenNumLowSymbols * 2) >> 9))) > > +*/ > > > > typedef struct > > { > > @@ -308,16 +321,18 @@ typedef struct > unsigned lc, lp, pb; > > unsigned lclp; > > > > - Bool fastMode; > > - Bool writeEndMark; > > - Bool finished; > > - Bool multiThread; > > - Bool needInit; > > + BoolInt fastMode; > > + BoolInt writeEndMark; > > + BoolInt finished; > > + BoolInt multiThread; > > + BoolInt needInit; > > + // BoolInt _maxMode; > > > > UInt64 nowPos64; > > > > unsigned matchPriceCount; > > - unsigned alignPriceCount; > > + // unsigned alignPriceCount; > > + int repLenEncCounter; > > > > unsigned distTableSize; > > > > @@ -325,7 +340,7 @@ typedef struct > SRes result; > > > > #ifndef _7ZIP_ST > > - Bool mtMode; > > + BoolInt mtMode; > > // begin of CMatchFinderMt is used in LZ thread > > CMatchFinderMt matchFinderMt; > > // end of CMatchFinderMt is used in BT and HASH threads > > @@ -458,6 +473,7 @@ SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const > CLzmaEncProps *props2) > p->lp = props.lp; > > p->pb = props.pb; > > p->fastMode = (props.algo == 0); > > + // p->_maxMode = True; > > p->matchFinderBase.btMode = (Byte)(props.btMode ? 1 : 0); > > { > > unsigned numHashBytes = 4; > > @@ -618,9 +634,9 @@ static void RangeEnc_FlushData(CRangeEnc *p) > > > #ifdef _LZMA_ENC_USE_BRANCH > > > > -#define RC_BIT(p, prob, symbol) { \ > > +#define RC_BIT(p, prob, bit) { \ > > RC_BIT_PRE(p, prob) \ > > - if (symbol == 0) { range = newBound; ttt += (kBitModelTotal - ttt) >> > kNumMoveBits; } \ > > + if (bit == 0) { range = newBound; ttt += (kBitModelTotal - ttt) >> > kNumMoveBits; } \ > > else { (p)->low += newBound; range -= newBound; ttt -= ttt >> > kNumMoveBits; } \ > > *(prob) = (CLzmaProb)ttt; \ > > RC_NORM(p) \ > > @@ -628,15 +644,15 @@ static void RangeEnc_FlushData(CRangeEnc *p) > > > #else > > > > -#define RC_BIT(p, prob, symbol) { \ > > +#define RC_BIT(p, prob, bit) { \ > > UInt32 mask; \ > > RC_BIT_PRE(p, prob) \ > > - mask = 0 - (UInt32)symbol; \ > > + mask = 0 - (UInt32)bit; \ > > range &= mask; \ > > mask &= newBound; \ > > range -= mask; \ > > (p)->low += mask; \ > > - mask = (UInt32)symbol - 1; \ > > + mask = (UInt32)bit - 1; \ > > range += newBound & mask; \ > > mask &= (kBitModelTotal - ((1 << kNumMoveBits) - 1)); \ > > mask += ((1 << kNumMoveBits) - 1); \ > > @@ -673,42 +689,42 @@ static void RangeEnc_EncodeBit_0(CRangeEnc *p, > CLzmaProb *prob) > p->range = range; > > } > > > > -static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 symbol) > > +static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 sym) > > { > > UInt32 range = p->range; > > - symbol |= 0x100; > > + sym |= 0x100; > > do > > { > > UInt32 ttt, newBound; > > - // RangeEnc_EncodeBit(p, probs + (symbol >> 8), (symbol >> 7) & 1); > > - CLzmaProb *prob = probs + (symbol >> 8); > > - UInt32 bit = (symbol >> 7) & 1; > > - symbol <<= 1; > > + // RangeEnc_EncodeBit(p, probs + (sym >> 8), (sym >> 7) & 1); > > + CLzmaProb *prob = probs + (sym >> 8); > > + UInt32 bit = (sym >> 7) & 1; > > + sym <<= 1; > > RC_BIT(p, prob, bit); > > } > > - while (symbol < 0x10000); > > + while (sym < 0x10000); > > p->range = range; > > } > > > > -static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, UInt32 > symbol, UInt32 matchByte) > > +static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, > UInt32 sym, UInt32 matchByte) > > { > > UInt32 range = p->range; > > UInt32 offs = 0x100; > > - symbol |= 0x100; > > + sym |= 0x100; > > do > > { > > UInt32 ttt, newBound; > > CLzmaProb *prob; > > UInt32 bit; > > matchByte <<= 1; > > - // RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (symbol >> > 8)), (symbol >> 7) & 1); > > - prob = probs + (offs + (matchByte & offs) + (symbol >> 8)); > > - bit = (symbol >> 7) & 1; > > - symbol <<= 1; > > - offs &= ~(matchByte ^ symbol); > > + // RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (sym >> > 8)), (sym >> 7) & 1); > > + prob = probs + (offs + (matchByte & offs) + (sym >> 8)); > > + bit = (sym >> 7) & 1; > > + sym <<= 1; > > + offs &= ~(matchByte ^ sym); > > RC_BIT(p, prob, bit); > > } > > - while (symbol < 0x10000); > > + while (sym < 0x10000); > > p->range = range; > > } > > > > @@ -739,11 +755,11 @@ static void LzmaEnc_InitPriceTables(CProbPrice > *ProbPrices) > } > > > > > > -#define GET_PRICE(prob, symbol) \ > > - p->ProbPrices[((prob) ^ (unsigned)(((-(int)(symbol))) & (kBitModelTotal - > 1))) >> kNumMoveReducingBits]; > > +#define GET_PRICE(prob, bit) \ > > + p->ProbPrices[((prob) ^ (unsigned)(((-(int)(bit))) & (kBitModelTotal - 1))) >> > kNumMoveReducingBits]; > > > > -#define GET_PRICEa(prob, symbol) \ > > - ProbPrices[((prob) ^ (unsigned)((-((int)(symbol))) & (kBitModelTotal - > 1))) >> kNumMoveReducingBits]; > > +#define GET_PRICEa(prob, bit) \ > > + ProbPrices[((prob) ^ (unsigned)((-((int)(bit))) & (kBitModelTotal - 1))) >> > kNumMoveReducingBits]; > > > > #define GET_PRICE_0(prob) p->ProbPrices[(prob) >> > kNumMoveReducingBits] > > #define GET_PRICE_1(prob) p->ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> > kNumMoveReducingBits] > > @@ -752,48 +768,48 @@ static void LzmaEnc_InitPriceTables(CProbPrice > *ProbPrices) > #define GET_PRICEa_1(prob) ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> > kNumMoveReducingBits] > > > > > > -static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 symbol, const > CProbPrice *ProbPrices) > > +static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 sym, const > CProbPrice *ProbPrices) > > { > > UInt32 price = 0; > > - symbol |= 0x100; > > + sym |= 0x100; > > do > > { > > - unsigned bit = symbol & 1; > > - symbol >>= 1; > > - price += GET_PRICEa(probs[symbol], bit); > > + unsigned bit = sym & 1; > > + sym >>= 1; > > + price += GET_PRICEa(probs[sym], bit); > > } > > - while (symbol >= 2); > > + while (sym >= 2); > > return price; > > } > > > > > > -static UInt32 LitEnc_Matched_GetPrice(const CLzmaProb *probs, UInt32 > symbol, UInt32 matchByte, const CProbPrice *ProbPrices) > > +static UInt32 LitEnc_Matched_GetPrice(const CLzmaProb *probs, UInt32 > sym, UInt32 matchByte, const CProbPrice *ProbPrices) > > { > > UInt32 price = 0; > > UInt32 offs = 0x100; > > - symbol |= 0x100; > > + sym |= 0x100; > > do > > { > > matchByte <<= 1; > > - price += GET_PRICEa(probs[offs + (matchByte & offs) + (symbol >> 8)], > (symbol >> 7) & 1); > > - symbol <<= 1; > > - offs &= ~(matchByte ^ symbol); > > + price += GET_PRICEa(probs[offs + (matchByte & offs) + (sym >> 8)], > (sym >> 7) & 1); > > + sym <<= 1; > > + offs &= ~(matchByte ^ sym); > > } > > - while (symbol < 0x10000); > > + while (sym < 0x10000); > > return price; > > } > > > > > > -static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, > unsigned numBits, UInt32 symbol) > > +static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, > unsigned numBits, unsigned sym) > > { > > UInt32 range = rc->range; > > unsigned m = 1; > > do > > { > > UInt32 ttt, newBound; > > - unsigned bit = symbol & 1; > > + unsigned bit = sym & 1; > > // RangeEnc_EncodeBit(rc, probs + m, bit); > > - symbol >>= 1; > > + sym >>= 1; > > RC_BIT(rc, probs + m, bit); > > m = (m << 1) | bit; > > } > > @@ -812,37 +828,37 @@ static void LenEnc_Init(CLenEnc *p) > p->high[i] = kProbInitValue; > > } > > > > -static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, unsigned symbol, > unsigned posState) > > +static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, unsigned sym, > unsigned posState) > > { > > UInt32 range, ttt, newBound; > > CLzmaProb *probs = p->low; > > range = rc->range; > > RC_BIT_PRE(rc, probs); > > - if (symbol >= kLenNumLowSymbols) > > + if (sym >= kLenNumLowSymbols) > > { > > RC_BIT_1(rc, probs); > > probs += kLenNumLowSymbols; > > RC_BIT_PRE(rc, probs); > > - if (symbol >= kLenNumLowSymbols * 2) > > + if (sym >= kLenNumLowSymbols * 2) > > { > > RC_BIT_1(rc, probs); > > rc->range = range; > > - // RcTree_Encode(rc, p->high, kLenNumHighBits, symbol - > kLenNumLowSymbols * 2); > > - LitEnc_Encode(rc, p->high, symbol - kLenNumLowSymbols * 2); > > + // RcTree_Encode(rc, p->high, kLenNumHighBits, sym - > kLenNumLowSymbols * 2); > > + LitEnc_Encode(rc, p->high, sym - kLenNumLowSymbols * 2); > > return; > > } > > - symbol -= kLenNumLowSymbols; > > + sym -= kLenNumLowSymbols; > > } > > > > - // RcTree_Encode(rc, probs + (posState << kLenNumLowBits), > kLenNumLowBits, symbol); > > + // RcTree_Encode(rc, probs + (posState << kLenNumLowBits), > kLenNumLowBits, sym); > > { > > unsigned m; > > unsigned bit; > > RC_BIT_0(rc, probs); > > probs += (posState << (1 + kLenNumLowBits)); > > - bit = (symbol >> 2) ; RC_BIT(rc, probs + 1, bit); m = (1 << 1) + bit; > > - bit = (symbol >> 1) & 1; RC_BIT(rc, probs + m, bit); m = (m << 1) + bit; > > - bit = symbol & 1; RC_BIT(rc, probs + m, bit); > > + bit = (sym >> 2) ; RC_BIT(rc, probs + 1, bit); m = (1 << 1) + bit; > > + bit = (sym >> 1) & 1; RC_BIT(rc, probs + m, bit); m = (m << 1) + bit; > > + bit = sym & 1; RC_BIT(rc, probs + m, bit); > > rc->range = range; > > } > > } > > @@ -863,50 +879,93 @@ static void SetPrices_3(const CLzmaProb *probs, > UInt32 startPrice, UInt32 *price > } > > > > > > -MY_NO_INLINE static void MY_FAST_CALL LenPriceEnc_UpdateTable( > > - CLenPriceEnc *p, unsigned posState, > > +MY_NO_INLINE static void MY_FAST_CALL LenPriceEnc_UpdateTables( > > + CLenPriceEnc *p, > > + unsigned numPosStates, > > const CLenEnc *enc, > > const CProbPrice *ProbPrices) > > { > > - // int y; for (y = 0; y < 100; y++) { > > - UInt32 a; > > - unsigned i, numSymbols; > > + UInt32 b; > > + > > + { > > + unsigned prob = enc->low[0]; > > + UInt32 a, c; > > + unsigned posState; > > + b = GET_PRICEa_1(prob); > > + a = GET_PRICEa_0(prob); > > + c = b + GET_PRICEa_0(enc->low[kLenNumLowSymbols]); > > + for (posState = 0; posState < numPosStates; posState++) > > + { > > + UInt32 *prices = p->prices[posState]; > > + const CLzmaProb *probs = enc->low + (posState << (1 + > kLenNumLowBits)); > > + SetPrices_3(probs, a, prices, ProbPrices); > > + SetPrices_3(probs + kLenNumLowSymbols, c, prices + > kLenNumLowSymbols, ProbPrices); > > + } > > + } > > > > - UInt32 *prices = p->prices[posState]; > > + /* > > { > > - const CLzmaProb *probs = enc->low + (posState << (1 + > kLenNumLowBits)); > > - SetPrices_3(probs, GET_PRICEa_0(enc->low[0]), prices, ProbPrices); > > + unsigned i; > > + UInt32 b; > > + a = GET_PRICEa_0(enc->low[0]); > > + for (i = 0; i < kLenNumLowSymbols; i++) > > + p->prices2[i] = a; > > a = GET_PRICEa_1(enc->low[0]); > > - SetPrices_3(probs + kLenNumLowSymbols, a + > GET_PRICEa_0(enc->low[kLenNumLowSymbols]), prices + > kLenNumLowSymbols, ProbPrices); > > + b = a + GET_PRICEa_0(enc->low[kLenNumLowSymbols]); > > + for (i = kLenNumLowSymbols; i < kLenNumLowSymbols * 2; i++) > > + p->prices2[i] = b; > > a += GET_PRICEa_1(enc->low[kLenNumLowSymbols]); > > } > > - numSymbols = p->tableSize; > > - p->counters[posState] = numSymbols; > > - for (i = kLenNumLowSymbols * 2; i < numSymbols; i += 1) > > + */ > > + > > + // p->counter = numSymbols; > > + // p->counter = 64; > > + > > { > > - prices[i] = a + > > - // RcTree_GetPrice(enc->high, kLenNumHighBits, i - > kLenNumLowSymbols * 2, ProbPrices); > > - LitEnc_GetPrice(enc->high, i - kLenNumLowSymbols * 2, > ProbPrices); > > - /* > > - unsigned sym = (i - kLenNumLowSymbols * 2) >> 1; > > - UInt32 price = a + RcTree_GetPrice(enc->high, kLenNumHighBits - 1, > sym, ProbPrices); > > - UInt32 prob = enc->high[(1 << 7) + sym]; > > - prices[i ] = price + GET_PRICEa_0(prob); > > - prices[i + 1] = price + GET_PRICEa_1(prob); > > - */ > > - } > > - // } > > -} > > + unsigned i = p->tableSize; > > + > > + if (i > kLenNumLowSymbols * 2) > > + { > > + const CLzmaProb *probs = enc->high; > > + UInt32 *prices = p->prices[0] + kLenNumLowSymbols * 2; > > + i -= kLenNumLowSymbols * 2 - 1; > > + i >>= 1; > > + b += GET_PRICEa_1(enc->low[kLenNumLowSymbols]); > > + do > > + { > > + /* > > + p->prices2[i] = a + > > + // RcTree_GetPrice(enc->high, kLenNumHighBits, i - > kLenNumLowSymbols * 2, ProbPrices); > > + LitEnc_GetPrice(probs, i - kLenNumLowSymbols * 2, ProbPrices); > > + */ > > + // UInt32 price = a + RcTree_GetPrice(probs, kLenNumHighBits - 1, > sym, ProbPrices); > > + unsigned sym = --i + (1 << (kLenNumHighBits - 1)); > > + UInt32 price = b; > > + do > > + { > > + unsigned bit = sym & 1; > > + sym >>= 1; > > + price += GET_PRICEa(probs[sym], bit); > > + } > > + while (sym >= 2); > > > > -static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, unsigned > numPosStates, > > - const CLenEnc *enc, > > - const CProbPrice *ProbPrices) > > -{ > > - unsigned posState; > > - for (posState = 0; posState < numPosStates; posState++) > > - LenPriceEnc_UpdateTable(p, posState, enc, ProbPrices); > > -} > > + { > > + unsigned prob = probs[(size_t)i + (1 << (kLenNumHighBits - 1))]; > > + prices[(size_t)i * 2 ] = price + GET_PRICEa_0(prob); > > + prices[(size_t)i * 2 + 1] = price + GET_PRICEa_1(prob); > > + } > > + } > > + while (i); > > > > + { > > + unsigned posState; > > + size_t num = (p->tableSize - kLenNumLowSymbols * 2) * > sizeof(p->prices[0][0]); > > + for (posState = 1; posState < numPosStates; posState++) > > + memcpy(p->prices[posState] + kLenNumLowSymbols * 2, > p->prices[0] + kLenNumLowSymbols * 2, num); > > + } > > + } > > + } > > +} > > > > /* > > #ifdef SHOW_STAT > > @@ -917,7 +976,7 @@ static void LenPriceEnc_UpdateTables(CLenPriceEnc > *p, unsigned numPosStates, > > > #define MOVE_POS(p, num) { \ > > p->additionalOffset += (num); \ > > - p->matchFinder.Skip(p->matchFinderObj, (num)); } > > + p->matchFinder.Skip(p->matchFinderObj, (UInt32)(num)); } > > > > > > static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes) > > @@ -954,7 +1013,8 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, > unsigned *numPairsRes) > const Byte *p2 = p1 + len; > > ptrdiff_t dif = (ptrdiff_t)-1 - p->matches[(size_t)numPairs - 1]; > > const Byte *lim = p1 + numAvail; > > - for (; p2 != lim && *p2 == p2[dif]; p2++); > > + for (; p2 != lim && *p2 == p2[dif]; p2++) > > + {} > > return (unsigned)(p2 - p1); > > } > > } > > @@ -977,7 +1037,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, > unsigned *numPairsRes) > + GET_PRICE_1(p->isRep[state]) \ > > + GET_PRICE_0(p->isRepG0[state]) > > > > - > > +MY_FORCE_INLINE > > static UInt32 GetPrice_PureRep(const CLzmaEnc *p, unsigned repIndex, > size_t state, size_t posState) > > { > > UInt32 price; > > @@ -1011,14 +1071,14 @@ static unsigned Backward(CLzmaEnc *p, > unsigned cur) > for (;;) > > { > > UInt32 dist = p->opt[cur].dist; > > - UInt32 len = p->opt[cur].len; > > - UInt32 extra = p->opt[cur].extra; > > + unsigned len = (unsigned)p->opt[cur].len; > > + unsigned extra = (unsigned)p->opt[cur].extra; > > cur -= len; > > > > if (extra) > > { > > wr--; > > - p->opt[wr].len = len; > > + p->opt[wr].len = (UInt32)len; > > cur -= extra; > > len = extra; > > if (extra == 1) > > @@ -1045,7 +1105,7 @@ static unsigned Backward(CLzmaEnc *p, unsigned > cur) > > > wr--; > > p->opt[wr].dist = dist; > > - p->opt[wr].len = len; > > + p->opt[wr].len = (UInt32)len; > > } > > } > > > > @@ -1102,7 +1162,8 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 > position) > repLens[i] = 0; > > continue; > > } > > - for (len = 2; len < numAvail && data[len] == data2[len]; len++); > > + for (len = 2; len < numAvail && data[len] == data2[len]; len++) > > + {} > > repLens[i] = len; > > if (len > repLens[repMaxIndex]) > > repMaxIndex = i; > > @@ -1111,7 +1172,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 > position) > if (repLens[repMaxIndex] >= p->numFastBytes) > > { > > unsigned len; > > - p->backRes = repMaxIndex; > > + p->backRes = (UInt32)repMaxIndex; > > len = repLens[repMaxIndex]; > > MOVE_POS(p, len - 1) > > return len; > > @@ -1128,8 +1189,12 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > > > curByte = *data; > > matchByte = *(data - reps[0]); > > + > > + last = repLens[repMaxIndex]; > > + if (last <= mainLen) > > + last = mainLen; > > > > - if (mainLen < 2 && curByte != matchByte && repLens[repMaxIndex] < > 2) > > + if (last < 2 && curByte != matchByte) > > { > > p->backRes = MARK_LIT; > > return 1; > > @@ -1146,13 +1211,14 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > LitEnc_Matched_GetPrice(probs, curByte, matchByte, > p->ProbPrices) : > > LitEnc_GetPrice(probs, curByte, p->ProbPrices)); > > } > > - > > + > > MakeAs_Lit(&p->opt[1]); > > > > matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]); > > repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]); > > > > - if (matchByte == curByte) > > + // 18.06 > > + if (matchByte == curByte && repLens[0] == 0) > > { > > UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, > p->state, posState); > > if (shortRepPrice < p->opt[1].price) > > @@ -1160,16 +1226,13 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > p->opt[1].price = shortRepPrice; > > MakeAs_ShortRep(&p->opt[1]); > > } > > + if (last < 2) > > + { > > + p->backRes = p->opt[1].dist; > > + return 1; > > + } > > } > > - > > - last = (mainLen >= repLens[repMaxIndex] ? mainLen : > repLens[repMaxIndex]); > > - > > - if (last < 2) > > - { > > - p->backRes = p->opt[1].dist; > > - return 1; > > - } > > - > > + > > p->opt[1].len = 1; > > > > p->opt[0].reps[0] = reps[0]; > > @@ -1177,13 +1240,6 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > p->opt[0].reps[2] = reps[2]; > > p->opt[0].reps[3] = reps[3]; > > > > - { > > - unsigned len = last; > > - do > > - p->opt[len--].price = kInfinityPrice; > > - while (len >= 2); > > - } > > - > > // ---------- REP ---------- > > > > for (i = 0; i < LZMA_NUM_REPS; i++) > > @@ -1195,13 +1251,13 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > price = repMatchPrice + GetPrice_PureRep(p, i, p->state, posState); > > do > > { > > - UInt32 price2 = price + > p->repLenEnc.prices[posState][(size_t)repLen - 2]; > > + UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, > repLen); > > COptimal *opt = &p->opt[repLen]; > > if (price2 < opt->price) > > { > > opt->price = price2; > > - opt->len = repLen; > > - opt->dist = i; > > + opt->len = (UInt32)repLen; > > + opt->dist = (UInt32)i; > > opt->extra = 0; > > } > > } > > @@ -1211,38 +1267,41 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > > > // ---------- MATCH ---------- > > { > > - unsigned len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2); > > + unsigned len = repLens[0] + 1; > > if (len <= mainLen) > > { > > unsigned offs = 0; > > UInt32 normalMatchPrice = matchPrice + > GET_PRICE_0(p->isRep[p->state]); > > > > - while (len > matches[offs]) > > - offs += 2; > > + if (len < 2) > > + len = 2; > > + else > > + while (len > matches[offs]) > > + offs += 2; > > > > for (; ; len++) > > { > > COptimal *opt; > > UInt32 dist = matches[(size_t)offs + 1]; > > - UInt32 price2 = normalMatchPrice + > p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN]; > > + UInt32 price = normalMatchPrice + > GET_PRICE_LEN(&p->lenEnc, posState, len); > > unsigned lenToPosState = GetLenToPosState(len); > > > > if (dist < kNumFullDistances) > > - price2 += p->distancesPrices[lenToPosState][dist & > (kNumFullDistances - 1)]; > > + price += p->distancesPrices[lenToPosState][dist & > (kNumFullDistances - 1)]; > > else > > { > > unsigned slot; > > GetPosSlot2(dist, slot); > > - price2 += p->alignPrices[dist & kAlignMask]; > > - price2 += p->posSlotPrices[lenToPosState][slot]; > > + price += p->alignPrices[dist & kAlignMask]; > > + price += p->posSlotPrices[lenToPosState][slot]; > > } > > > > opt = &p->opt[len]; > > > > - if (price2 < opt->price) > > + if (price < opt->price) > > { > > - opt->price = price2; > > - opt->len = len; > > + opt->price = price; > > + opt->len = (UInt32)len; > > opt->dist = dist + LZMA_NUM_REPS; > > opt->extra = 0; > > } > > @@ -1277,16 +1336,43 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > > > for (;;) > > { > > - UInt32 numAvail, numAvailFull; > > + unsigned numAvail; > > + UInt32 numAvailFull; > > unsigned newLen, numPairs, prev, state, posState, startLen; > > - UInt32 curPrice, litPrice, matchPrice, repMatchPrice; > > - Bool nextIsLit; > > + UInt32 litPrice, matchPrice, repMatchPrice; > > + BoolInt nextIsLit; > > Byte curByte, matchByte; > > const Byte *data; > > COptimal *curOpt, *nextOpt; > > > > if (++cur == last) > > - return Backward(p, cur); > > + break; > > + > > + // 18.06 > > + if (cur >= kNumOpts - 64) > > + { > > + unsigned j, best; > > + UInt32 price = p->opt[cur].price; > > + best = cur; > > + for (j = cur + 1; j <= last; j++) > > + { > > + UInt32 price2 = p->opt[j].price; > > + if (price >= price2) > > + { > > + price = price2; > > + best = j; > > + } > > + } > > + { > > + unsigned delta = best - cur; > > + if (delta != 0) > > + { > > + MOVE_POS(p, delta); > > + } > > + } > > + cur = best; > > + break; > > + } > > > > newLen = ReadMatchDistances(p, &numPairs); > > > > @@ -1294,15 +1380,24 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > { > > p->numPairs = numPairs; > > p->longestMatchLen = newLen; > > - return Backward(p, cur); > > + break; > > } > > > > curOpt = &p->opt[cur]; > > + > > + position++; > > + > > + // we need that check here, if skip_items in p->opt are possible > > + /* > > + if (curOpt->price >= kInfinityPrice) > > + continue; > > + */ > > + > > prev = cur - curOpt->len; > > - > > + > > if (curOpt->len == 1) > > { > > - state = p->opt[prev].state; > > + state = (unsigned)p->opt[prev].state; > > if (IsShortRep(curOpt)) > > state = kShortRepNextStates[state]; > > else > > @@ -1316,14 +1411,14 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > > > if (curOpt->extra) > > { > > - prev -= curOpt->extra; > > + prev -= (unsigned)curOpt->extra; > > state = kState_RepAfterLit; > > if (curOpt->extra == 1) > > - state = (dist < LZMA_NUM_REPS) ? kState_RepAfterLit : > kState_MatchAfterLit; > > + state = (dist < LZMA_NUM_REPS ? kState_RepAfterLit : > kState_MatchAfterLit); > > } > > else > > { > > - state = p->opt[prev].state; > > + state = (unsigned)p->opt[prev].state; > > if (dist < LZMA_NUM_REPS) > > state = kRepNextStates[state]; > > else > > @@ -1379,7 +1474,6 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 > position) > curByte = *data; > > matchByte = *(data - reps[0]); > > > > - position++; > > posState = (position & p->pbMask); > > > > /* > > @@ -1391,13 +1485,25 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > < MATCH [ : LIT : REP_0 ] > > */ > > > > - curPrice = curOpt->price; > > - litPrice = curPrice + GET_PRICE_0(p->isMatch[state][posState]); > > + { > > + UInt32 curPrice = curOpt->price; > > + unsigned prob = p->isMatch[state][posState]; > > + matchPrice = curPrice + GET_PRICE_1(prob); > > + litPrice = curPrice + GET_PRICE_0(prob); > > + } > > > > nextOpt = &p->opt[(size_t)cur + 1]; > > nextIsLit = False; > > > > - // if (litPrice >= nextOpt->price) litPrice = 0; else // 18.new > > + // here we can allow skip_items in p->opt, if we don't check > (nextOpt->price < kInfinityPrice) > > + // 18.new.06 > > + if ((nextOpt->price < kInfinityPrice > > + // && !IsLitState(state) > > + && matchByte == curByte) > > + || litPrice > nextOpt->price > > + ) > > + litPrice = 0; > > + else > > { > > const CLzmaProb *probs = LIT_PROBS(position, *(data - 1)); > > litPrice += (!IsLitState(state) ? > > @@ -1413,21 +1519,32 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > } > > } > > > > - matchPrice = curPrice + GET_PRICE_1(p->isMatch[state][posState]); > > repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[state]); > > > > + numAvailFull = p->numAvail; > > + { > > + unsigned temp = kNumOpts - 1 - cur; > > + if (numAvailFull > temp) > > + numAvailFull = (UInt32)temp; > > + } > > + > > + // 18.06 > > // ---------- SHORT_REP ---------- > > - // if (IsLitState(state)) // 18.new > > + if (IsLitState(state)) // 18.new > > if (matchByte == curByte) > > - // if (repMatchPrice < nextOpt->price) // 18.new > > - if (nextOpt->len < 2 > > + if (repMatchPrice < nextOpt->price) // 18.new > > + // if (numAvailFull < 2 || data[1] != *(data - reps[0] + 1)) > > + if ( > > + // nextOpt->price >= kInfinityPrice || > > + nextOpt->len < 2 // we can check nextOpt->len, if skip items > are not allowed in p->opt > > || (nextOpt->dist != 0 > > - && nextOpt->extra <= 1 // 17.old > > - )) > > + // && nextOpt->extra <= 1 // 17.old > > + ) > > + ) > > { > > UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, state, > posState); > > - if (shortRepPrice <= nextOpt->price) // 17.old > > - // if (shortRepPrice < nextOpt->price) // 18.new > > + // if (shortRepPrice <= nextOpt->price) // 17.old > > + if (shortRepPrice < nextOpt->price) // 18.new > > { > > nextOpt->price = shortRepPrice; > > nextOpt->len = 1; > > @@ -1436,13 +1553,6 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > } > > } > > > > - numAvailFull = p->numAvail; > > - { > > - UInt32 temp = kNumOpts - 1 - cur; > > - if (numAvailFull > temp) > > - numAvailFull = temp; > > - } > > - > > if (numAvailFull < 2) > > continue; > > numAvail = (numAvailFull <= p->numFastBytes ? numAvailFull : > p->numFastBytes); > > @@ -1451,9 +1561,8 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 > position) > > > // ---------- LIT : REP_0 ---------- > > > > - if ( > > - // litPrice != 0 && // 18.new > > - !nextIsLit > > + if (!nextIsLit > > + && litPrice != 0 // 18.new > > && matchByte != curByte > > && numAvailFull > 2) > > { > > @@ -1465,8 +1574,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 > position) > if (limit > numAvailFull) > > limit = numAvailFull; > > for (len = 3; len < limit && data[len] == data2[len]; len++) > > - { > > - } > > + {} > > > > { > > unsigned state2 = kLiteralNextStates[state]; > > @@ -1474,8 +1582,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 > position) > UInt32 price = litPrice + GetPrice_Rep_0(p, state2, posState2); > > { > > unsigned offset = cur + len; > > - while (last < offset) > > - p->opt[++last].price = kInfinityPrice; > > + > > + if (last < offset) > > + last = offset; > > > > // do > > { > > @@ -1483,14 +1592,14 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > COptimal *opt; > > len--; > > // price2 = price + GetPrice_Len_Rep_0(p, len, state2, > posState2); > > - price2 = price + p->repLenEnc.prices[posState2][len - > LZMA_MATCH_LEN_MIN]; > > + price2 = price + GET_PRICE_LEN(&p->repLenEnc, > posState2, len); > > > > opt = &p->opt[offset]; > > // offset--; > > if (price2 < opt->price) > > { > > opt->price = price2; > > - opt->len = len; > > + opt->len = (UInt32)len; > > opt->dist = 0; > > opt->extra = 1; > > } > > @@ -1502,6 +1611,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 > position) > } > > > > startLen = 2; /* speed optimization */ > > + > > { > > // ---------- REP ---------- > > unsigned repIndex = 0; // 17.old > > @@ -1514,24 +1624,28 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > if (data[0] != data2[0] || data[1] != data2[1]) > > continue; > > > > - for (len = 2; len < numAvail && data[len] == data2[len]; len++); > > + for (len = 2; len < numAvail && data[len] == data2[len]; len++) > > + {} > > > > // if (len < startLen) continue; // 18.new: speed optimization > > > > - while (last < cur + len) > > - p->opt[++last].price = kInfinityPrice; > > + { > > + unsigned offset = cur + len; > > + if (last < offset) > > + last = offset; > > + } > > { > > unsigned len2 = len; > > price = repMatchPrice + GetPrice_PureRep(p, repIndex, state, > posState); > > do > > { > > - UInt32 price2 = price + > p->repLenEnc.prices[posState][(size_t)len2 - 2]; > > + UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, > posState, len2); > > COptimal *opt = &p->opt[cur + len2]; > > if (price2 < opt->price) > > { > > opt->price = price2; > > - opt->len = len2; > > - opt->dist = repIndex; > > + opt->len = (UInt32)len2; > > + opt->dist = (UInt32)repIndex; > > opt->extra = 0; > > } > > } > > @@ -1551,15 +1665,14 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > if (limit > numAvailFull) > > limit = numAvailFull; > > > > - for (; len2 < limit && data[len2] == data2[len2]; len2++); > > - > > - len2 -= len; > > - if (len2 >= 3) > > + len2 += 2; > > + if (len2 <= limit) > > + if (data[len2 - 2] == data2[len2 - 2]) > > + if (data[len2 - 1] == data2[len2 - 1]) > > { > > unsigned state2 = kRepNextStates[state]; > > unsigned posState2 = (position + len) & p->pbMask; > > - price += > > - p->repLenEnc.prices[posState][(size_t)len - 2] > > + price += GET_PRICE_LEN(&p->repLenEnc, posState, len) > > + GET_PRICE_0(p->isMatch[state2][posState2]) > > + LitEnc_Matched_GetPrice(LIT_PROBS(position + len, > data[(size_t)len - 1]), > > data[len], data2[len], p->ProbPrices); > > @@ -1570,31 +1683,40 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > > > > > price += GetPrice_Rep_0(p, state2, posState2); > > + > > + for (; len2 < limit && data[len2] == data2[len2]; len2++) > > + {} > > + > > + len2 -= len; > > + // if (len2 >= 3) > > + { > > { > > unsigned offset = cur + len + len2; > > - while (last < offset) > > - p->opt[++last].price = kInfinityPrice; > > + > > + if (last < offset) > > + last = offset; > > // do > > { > > - unsigned price2; > > + UInt32 price2; > > COptimal *opt; > > len2--; > > // price2 = price + GetPrice_Len_Rep_0(p, len2, state2, > posState2); > > - price2 = price + p->repLenEnc.prices[posState2][len2 - > LZMA_MATCH_LEN_MIN]; > > + price2 = price + GET_PRICE_LEN(&p->repLenEnc, > posState2, len2); > > > > opt = &p->opt[offset]; > > // offset--; > > if (price2 < opt->price) > > { > > opt->price = price2; > > - opt->len = len2; > > + opt->len = (UInt32)len2; > > opt->extra = (CExtra)(len + 1); > > - opt->dist = repIndex; > > + opt->dist = (UInt32)repIndex; > > } > > } > > // while (len2 >= 3); > > } > > } > > + } > > } > > } > > } > > @@ -1606,17 +1728,23 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > { > > newLen = numAvail; > > for (numPairs = 0; newLen > matches[numPairs]; numPairs += 2); > > - matches[numPairs] = newLen; > > + matches[numPairs] = (UInt32)newLen; > > numPairs += 2; > > } > > > > + // startLen = 2; /* speed optimization */ > > + > > if (newLen >= startLen) > > { > > UInt32 normalMatchPrice = matchPrice + > GET_PRICE_0(p->isRep[state]); > > UInt32 dist; > > unsigned offs, posSlot, len; > > - while (last < cur + newLen) > > - p->opt[++last].price = kInfinityPrice; > > + > > + { > > + unsigned offset = cur + newLen; > > + if (last < offset) > > + last = offset; > > + } > > > > offs = 0; > > while (startLen > matches[offs]) > > @@ -1628,27 +1756,29 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > > > for (len = /*2*/ startLen; ; len++) > > { > > - UInt32 price = normalMatchPrice + > p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN]; > > + UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, > posState, len); > > { > > COptimal *opt; > > - unsigned lenToPosState = len - 2; lenToPosState = > GetLenToPosState2(lenToPosState); > > + unsigned lenNorm = len - 2; > > + lenNorm = GetLenToPosState2(lenNorm); > > if (dist < kNumFullDistances) > > - price += p->distancesPrices[lenToPosState][dist & > (kNumFullDistances - 1)]; > > + price += p->distancesPrices[lenNorm][dist & > (kNumFullDistances - 1)]; > > else > > - price += p->posSlotPrices[lenToPosState][posSlot] + > p->alignPrices[dist & kAlignMask]; > > + price += p->posSlotPrices[lenNorm][posSlot] + > p->alignPrices[dist & kAlignMask]; > > > > opt = &p->opt[cur + len]; > > if (price < opt->price) > > { > > opt->price = price; > > - opt->len = len; > > + opt->len = (UInt32)len; > > opt->dist = dist + LZMA_NUM_REPS; > > opt->extra = 0; > > } > > } > > > > - if (/*_maxMode && */ len == matches[offs]) > > + if (len == matches[offs]) > > { > > + // if (p->_maxMode) { > > // MATCH : LIT : REP_0 > > > > const Byte *data2 = data - dist - 1; > > @@ -1657,11 +1787,17 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > if (limit > numAvailFull) > > limit = numAvailFull; > > > > - for (; len2 < limit && data[len2] == data2[len2]; len2++); > > + len2 += 2; > > + if (len2 <= limit) > > + if (data[len2 - 2] == data2[len2 - 2]) > > + if (data[len2 - 1] == data2[len2 - 1]) > > + { > > + for (; len2 < limit && data[len2] == data2[len2]; len2++) > > + {} > > > > len2 -= len; > > > > - if (len2 >= 3) > > + // if (len2 >= 3) > > { > > unsigned state2 = kMatchNextStates[state]; > > unsigned posState2 = (position + len) & p->pbMask; > > @@ -1677,27 +1813,30 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > price += GetPrice_Rep_0(p, state2, posState2); > > > > offset = cur + len + len2; > > - while (last < offset) > > - p->opt[++last].price = kInfinityPrice; > > + > > + if (last < offset) > > + last = offset; > > // do > > { > > UInt32 price2; > > COptimal *opt; > > len2--; > > // price2 = price + GetPrice_Len_Rep_0(p, len2, state2, > posState2); > > - price2 = price + p->repLenEnc.prices[posState2][len2 - > LZMA_MATCH_LEN_MIN]; > > + price2 = price + GET_PRICE_LEN(&p->repLenEnc, > posState2, len2); > > opt = &p->opt[offset]; > > // offset--; > > if (price2 < opt->price) > > { > > opt->price = price2; > > - opt->len = len2; > > + opt->len = (UInt32)len2; > > opt->extra = (CExtra)(len + 1); > > opt->dist = dist + LZMA_NUM_REPS; > > } > > } > > // while (len2 >= 3); > > } > > + > > + } > > > > offs += 2; > > if (offs == numPairs) > > @@ -1709,6 +1848,12 @@ static unsigned GetOptimum(CLzmaEnc *p, > UInt32 position) > } > > } > > } > > + > > + do > > + p->opt[last].price = kInfinityPrice; > > + while (--last); > > + > > + return Backward(p, cur); > > } > > > > > > @@ -1735,6 +1880,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p) > p->backRes = MARK_LIT; > > if (numAvail < 2) > > return 1; > > + // if (mainLen < 2 && p->state == 0) return 1; // 18.06.notused > > if (numAvail > LZMA_MATCH_LEN_MAX) > > numAvail = LZMA_MATCH_LEN_MAX; > > data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1; > > @@ -1746,10 +1892,11 @@ static unsigned GetOptimumFast(CLzmaEnc *p) > const Byte *data2 = data - p->reps[i]; > > if (data[0] != data2[0] || data[1] != data2[1]) > > continue; > > - for (len = 2; len < numAvail && data[len] == data2[len]; len++); > > + for (len = 2; len < numAvail && data[len] == data2[len]; len++) > > + {} > > if (len >= p->numFastBytes) > > { > > - p->backRes = i; > > + p->backRes = (UInt32)i; > > MOVE_POS(p, len - 1) > > return len; > > } > > @@ -1793,7 +1940,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p) > || (repLen + 2 >= mainLen && mainDist >= (1 << 9)) > > || (repLen + 3 >= mainLen && mainDist >= (1 << 15))) > > { > > - p->backRes = repIndex; > > + p->backRes = (UInt32)repIndex; > > MOVE_POS(p, repLen - 1) > > return repLen; > > } > > @@ -1932,23 +2079,22 @@ MY_NO_INLINE static SRes Flush(CLzmaEnc *p, > UInt32 nowPos) > } > > > > > > - > > -static void FillAlignPrices(CLzmaEnc *p) > > +MY_NO_INLINE static void FillAlignPrices(CLzmaEnc *p) > > { > > unsigned i; > > const CProbPrice *ProbPrices = p->ProbPrices; > > const CLzmaProb *probs = p->posAlignEncoder; > > - p->alignPriceCount = 0; > > + // p->alignPriceCount = 0; > > for (i = 0; i < kAlignTableSize / 2; i++) > > { > > UInt32 price = 0; > > - unsigned symbol = i; > > + unsigned sym = i; > > unsigned m = 1; > > unsigned bit; > > UInt32 prob; > > - bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[m], bit); m = > (m << 1) + bit; > > - bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[m], bit); m = > (m << 1) + bit; > > - bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[m], bit); m = > (m << 1) + bit; > > + bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m > << 1) + bit; > > + bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m > << 1) + bit; > > + bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m > << 1) + bit; > > prob = probs[m]; > > p->alignPrices[i ] = price + GET_PRICEa_0(prob); > > p->alignPrices[i + 8] = price + GET_PRICEa_1(prob); > > @@ -1957,78 +2103,97 @@ static void FillAlignPrices(CLzmaEnc *p) > } > > > > > > -static void FillDistancesPrices(CLzmaEnc *p) > > +MY_NO_INLINE static void FillDistancesPrices(CLzmaEnc *p) > > { > > + // int y; for (y = 0; y < 100; y++) { > > + > > UInt32 tempPrices[kNumFullDistances]; > > - unsigned i, lenToPosState; > > + unsigned i, lps; > > > > const CProbPrice *ProbPrices = p->ProbPrices; > > p->matchPriceCount = 0; > > > > - for (i = kStartPosModelIndex; i < kNumFullDistances; i++) > > + for (i = kStartPosModelIndex / 2; i < kNumFullDistances / 2; i++) > > { > > unsigned posSlot = GetPosSlot1(i); > > - unsigned footerBits = ((posSlot >> 1) - 1); > > + unsigned footerBits = (posSlot >> 1) - 1; > > unsigned base = ((2 | (posSlot & 1)) << footerBits); > > + const CLzmaProb *probs = p->posEncoders + (size_t)base * 2; > > // tempPrices[i] = RcTree_ReverseGetPrice(p->posEncoders + base, > footerBits, i - base, p->ProbPrices); > > - > > - const CLzmaProb *probs = p->posEncoders + base; > > UInt32 price = 0; > > unsigned m = 1; > > - unsigned symbol = i - base; > > + unsigned sym = i; > > + unsigned offset = (unsigned)1 << footerBits; > > + base += i; > > + > > + if (footerBits) > > do > > { > > - unsigned bit = symbol & 1; > > - symbol >>= 1; > > + unsigned bit = sym & 1; > > + sym >>= 1; > > price += GET_PRICEa(probs[m], bit); > > m = (m << 1) + bit; > > } > > while (--footerBits); > > - tempPrices[i] = price; > > + > > + { > > + unsigned prob = probs[m]; > > + tempPrices[base ] = price + GET_PRICEa_0(prob); > > + tempPrices[base + offset] = price + GET_PRICEa_1(prob); > > + } > > } > > > > - for (lenToPosState = 0; lenToPosState < kNumLenToPosStates; > lenToPosState++) > > + for (lps = 0; lps < kNumLenToPosStates; lps++) > > { > > - unsigned posSlot; > > - const CLzmaProb *encoder = p->posSlotEncoder[lenToPosState]; > > - UInt32 *posSlotPrices = p->posSlotPrices[lenToPosState]; > > - unsigned distTableSize = p->distTableSize; > > - const CLzmaProb *probs = encoder; > > - for (posSlot = 0; posSlot < distTableSize; posSlot += 2) > > + unsigned slot; > > + unsigned distTableSize2 = (p->distTableSize + 1) >> 1; > > + UInt32 *posSlotPrices = p->posSlotPrices[lps]; > > + const CLzmaProb *probs = p->posSlotEncoder[lps]; > > + > > + for (slot = 0; slot < distTableSize2; slot++) > > { > > - // posSlotPrices[posSlot] = RcTree_GetPrice(encoder, > kNumPosSlotBits, posSlot, p->ProbPrices); > > - UInt32 price = 0; > > + // posSlotPrices[slot] = RcTree_GetPrice(encoder, kNumPosSlotBits, > slot, p->ProbPrices); > > + UInt32 price; > > unsigned bit; > > - unsigned symbol = (posSlot >> 1) + (1 << (kNumPosSlotBits - 1)); > > - UInt32 prob; > > - bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], > bit); > > - bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], > bit); > > - bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], > bit); > > - bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], > bit); > > - bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], > bit); > > - prob = probs[(posSlot >> 1) + (1 << (kNumPosSlotBits - 1))]; > > - posSlotPrices[posSlot ] = price + GET_PRICEa_0(prob); > > - posSlotPrices[posSlot + 1] = price + GET_PRICEa_1(prob); > > + unsigned sym = slot + (1 << (kNumPosSlotBits - 1)); > > + unsigned prob; > > + bit = sym & 1; sym >>= 1; price = GET_PRICEa(probs[sym], bit); > > + bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit); > > + bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit); > > + bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit); > > + bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit); > > + prob = probs[(size_t)slot + (1 << (kNumPosSlotBits - 1))]; > > + posSlotPrices[(size_t)slot * 2 ] = price + GET_PRICEa_0(prob); > > + posSlotPrices[(size_t)slot * 2 + 1] = price + GET_PRICEa_1(prob); > > } > > - for (posSlot = kEndPosModelIndex; posSlot < distTableSize; posSlot++) > > - posSlotPrices[posSlot] += ((UInt32)(((posSlot >> 1) - 1) - > kNumAlignBits) << kNumBitPriceShiftBits); > > - > > + > > { > > - UInt32 *distancesPrices = p->distancesPrices[lenToPosState]; > > + UInt32 delta = ((UInt32)((kEndPosModelIndex / 2 - 1) - > kNumAlignBits) << kNumBitPriceShiftBits); > > + for (slot = kEndPosModelIndex / 2; slot < distTableSize2; slot++) > > { > > - distancesPrices[0] = posSlotPrices[0]; > > - distancesPrices[1] = posSlotPrices[1]; > > - distancesPrices[2] = posSlotPrices[2]; > > - distancesPrices[3] = posSlotPrices[3]; > > + posSlotPrices[(size_t)slot * 2 ] += delta; > > + posSlotPrices[(size_t)slot * 2 + 1] += delta; > > + delta += ((UInt32)1 << kNumBitPriceShiftBits); > > } > > + } > > + > > + { > > + UInt32 *dp = p->distancesPrices[lps]; > > + > > + dp[0] = posSlotPrices[0]; > > + dp[1] = posSlotPrices[1]; > > + dp[2] = posSlotPrices[2]; > > + dp[3] = posSlotPrices[3]; > > + > > for (i = 4; i < kNumFullDistances; i += 2) > > { > > UInt32 slotPrice = posSlotPrices[GetPosSlot1(i)]; > > - distancesPrices[i ] = slotPrice + tempPrices[i]; > > - distancesPrices[i + 1] = slotPrice + tempPrices[i + 1]; > > + dp[i ] = slotPrice + tempPrices[i]; > > + dp[i + 1] = slotPrice + tempPrices[i + 1]; > > } > > } > > } > > + // } > > } > > > > > > @@ -2245,10 +2410,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc > *p, UInt32 maxPackSize, UInt32 maxUnpa > if (len != 1) > > { > > LenEnc_Encode(&p->repLenProbs, &p->rc, len - > LZMA_MATCH_LEN_MIN, posState); > > - if (!p->fastMode) > > - if (--p->repLenEnc.counters[posState] == 0) > > - LenPriceEnc_UpdateTable(&p->repLenEnc, posState, > &p->repLenProbs, p->ProbPrices); > > - > > + --p->repLenEncCounter; > > p->state = kRepNextStates[p->state]; > > } > > } > > @@ -2260,9 +2422,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, > UInt32 maxPackSize, UInt32 maxUnpa > p->state = kMatchNextStates[p->state]; > > > > LenEnc_Encode(&p->lenProbs, &p->rc, len - > LZMA_MATCH_LEN_MIN, posState); > > - if (!p->fastMode) > > - if (--p->lenEnc.counters[posState] == 0) > > - LenPriceEnc_UpdateTable(&p->lenEnc, posState, > &p->lenProbs, p->ProbPrices); > > + // --p->lenEnc.counter; > > > > dist -= LZMA_NUM_REPS; > > p->reps[3] = p->reps[2]; > > @@ -2274,17 +2434,17 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc > *p, UInt32 maxPackSize, UInt32 maxUnpa > GetPosSlot(dist, posSlot); > > // RcTree_Encode_PosSlot(&p->rc, > p->posSlotEncoder[GetLenToPosState(len)], posSlot); > > { > > - UInt32 symbol = posSlot + (1 << kNumPosSlotBits); > > + UInt32 sym = (UInt32)posSlot + (1 << kNumPosSlotBits); > > range = p->rc.range; > > probs = p->posSlotEncoder[GetLenToPosState(len)]; > > do > > { > > - CLzmaProb *prob = probs + (symbol >> kNumPosSlotBits); > > - UInt32 bit = (symbol >> (kNumPosSlotBits - 1)) & 1; > > - symbol <<= 1; > > + CLzmaProb *prob = probs + (sym >> kNumPosSlotBits); > > + UInt32 bit = (sym >> (kNumPosSlotBits - 1)) & 1; > > + sym <<= 1; > > RC_BIT(&p->rc, prob, bit); > > } > > - while (symbol < (1 << kNumPosSlotBits * 2)); > > + while (sym < (1 << kNumPosSlotBits * 2)); > > p->rc.range = range; > > } > > > > @@ -2295,7 +2455,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, > UInt32 maxPackSize, UInt32 maxUnpa > if (dist < kNumFullDistances) > > { > > unsigned base = ((2 | (posSlot & 1)) << footerBits); > > - RcTree_ReverseEncode(&p->rc, p->posEncoders + base, > footerBits, dist - base); > > + RcTree_ReverseEncode(&p->rc, p->posEncoders + base, > footerBits, (unsigned)(dist /* - base */)); > > } > > else > > { > > @@ -2331,14 +2491,14 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc > *p, UInt32 maxPackSize, UInt32 maxUnpa > bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, > p->posAlignEncoder + m, bit); m = (m << 1) + bit; > > bit = dist & 1; RC_BIT(&p->rc, > p->posAlignEncoder + m, bit); > > p->rc.range = range; > > - p->alignPriceCount++; > > + // p->alignPriceCount++; > > } > > } > > } > > } > > } > > > > - nowPos32 += len; > > + nowPos32 += (UInt32)len; > > p->additionalOffset -= len; > > > > if (p->additionalOffset == 0) > > @@ -2347,10 +2507,27 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc > *p, UInt32 maxPackSize, UInt32 maxUnpa > > > if (!p->fastMode) > > { > > - if (p->matchPriceCount >= (1 << 7)) > > + /* > > + if (p->alignPriceCount >= 16) // kAlignTableSize > > + FillAlignPrices(p); > > + if (p->matchPriceCount >= 128) > > FillDistancesPrices(p); > > - if (p->alignPriceCount >= kAlignTableSize) > > + if (p->lenEnc.counter <= 0) > > + LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, > &p->lenProbs, p->ProbPrices); > > + */ > > + if (p->matchPriceCount >= 64) > > + { > > FillAlignPrices(p); > > + // { int y; for (y = 0; y < 100; y++) { > > + FillDistancesPrices(p); > > + // }} > > + LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, > &p->lenProbs, p->ProbPrices); > > + } > > + if (p->repLenEncCounter <= 0) > > + { > > + p->repLenEncCounter = REP_LEN_COUNT; > > + LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, > &p->repLenProbs, p->ProbPrices); > > + } > > } > > > > if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0) > > @@ -2490,12 +2667,19 @@ void LzmaEnc_Init(CLzmaEnc *p) > > > p->optEnd = 0; > > p->optCur = 0; > > + > > + { > > + for (i = 0; i < kNumOpts; i++) > > + p->opt[i].price = kInfinityPrice; > > + } > > + > > p->additionalOffset = 0; > > > > p->pbMask = (1 << p->pb) - 1; > > p->lpMask = ((UInt32)0x100 << p->lp) - ((unsigned)0x100 >> p->lc); > > } > > > > + > > void LzmaEnc_InitPrices(CLzmaEnc *p) > > { > > if (!p->fastMode) > > @@ -2507,6 +2691,9 @@ void LzmaEnc_InitPrices(CLzmaEnc *p) > p->lenEnc.tableSize = > > p->repLenEnc.tableSize = > > p->numFastBytes + 1 - LZMA_MATCH_LEN_MIN; > > + > > + p->repLenEncCounter = REP_LEN_COUNT; > > + > > LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, > p->ProbPrices); > > LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, &p->repLenProbs, > p->ProbPrices); > > } > > @@ -2583,7 +2770,7 @@ typedef struct > ISeqOutStream vt; > > Byte *data; > > SizeT rem; > > - Bool overflow; > > + BoolInt overflow; > > } CLzmaEnc_SeqOutStreamBuf; > > > > static size_t SeqOutStreamBuf_Write(const ISeqOutStream *pp, const void > *data, size_t size) > > @@ -2615,7 +2802,7 @@ const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle > pp) > } > > > > > > -SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit, > > +SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit, > > Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 > *unpackSize) > > { > > CLzmaEnc *p = (CLzmaEnc *)pp; > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt > b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt > index d7426d38a4..04f9d98e7d 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt > @@ -1,6 +1,28 @@ > HISTORY of the LZMA SDK > > ----------------------- > > > > +19.00 2019-02-21 > > +------------------------- > > +- Encryption strength for 7z archives was increased: > > + the size of random initialization vector was increased from 64-bit to > 128-bit, > > + and the pseudo-random number generator was improved. > > +- The bug in 7zIn.c code was fixed. > > + > > + > > +18.06 2018-12-30 > > +------------------------- > > +- The speed for LZMA/LZMA2 compressing was increased by 3-10%, > > + and there are minor changes in compression ratio. > > +- Some bugs were fixed. > > +- The bug in 7-Zip 18.02-18.05 was fixed: > > + There was memory leak in multithreading xz decoder - > XzDecMt_Decode(), > > + if xz stream contains only one block. > > +- The changes for MSVS compiler makefiles: > > + - the makefiles now use "PLATFORM" macroname with values (x64, x86, > arm64) > > + instead of "CPU" macroname with values (AMD64, ARM64). > > + - the makefiles by default now use static version of the run-time library. > > + > > + > > 18.05 2018-04-30 > > ------------------------- > > - The speed for LZMA/LZMA2 compressing was increased > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt > b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt > index a3deb20943..e17cd4fe1a 100644 > --- a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt > @@ -1,4 +1,4 @@ > -LZMA SDK 18.05 > > +LZMA SDK 19.00 > > -------------- > > > > LZMA SDK provides the documentation, samples, header files, > > -- > 2.27.0.windows.1