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 <gaoliming@byosoft.com.cn>
Sent: 2020年12月17日 9:30
To: Liu, WeiX C <weix.c.liu@intel.com>; devel@edk2.groups.io
Cc: 'Laszlo Ersek' <lersek@redhat.com>
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 <weix.c.liu@intel.com>
> 发送时间: 2020年12月15日
10:07
> 收件人: devel@edk2.groups.io
> 抄送: Wei Liu <weix.c.liu@intel.com>; Liming Gao
> <gaoliming@byosoft.com.cn>; Laszlo Ersek <lersek@redhat.com>
> 主题: [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 <gaoliming@byosoft.com.cn>
>
> Cc: Laszlo Ersek <lersek@redhat.com>
> Signed-off-by: Wei Liu <weix.c.liu@intel.com>
> ---
> 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.<BR>
>
> 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 <string.h>
>
> +
>
> /* #include "CpuArch.h" */
>
> #include "LzmaDec.h"
>
>
>
> -#include <string.h>
>
> -
>
> #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