-2021-12-25 : Igor Pavlov : Public domain */

-#ifndef __7Z_TYPES_H

-#define __7Z_TYPES_H

-// #define MY_HRES_ERROR__INTERNAL_ERROR MY_SRes_HRESULT_FROM_WRes(ERROR_INTERNAL_ERROR)

-#define MY__FACILITY_ERRNO 0x800

-#define MY__FACILITY_WIN32 7

-#define MY__FACILITY__WRes MY__FACILITY_ERRNO

- | (MY__FACILITY__WRes << 16) \

-// if (MY__FACILITY__WRes != FACILITY_WIN32),

-#define MY__E_ERROR_NEGATIVE_SEEK ((HRESULT)0x80070083L)

-#define MY__E_ERROR_NEGATIVE_SEEK MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL)

-// gcc / clang : (sizeof(long) == sizeof(void*)) in 32/64 bits

-typedef long INT_PTR;

-typedef unsigned long UINT_PTR;

-

-#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }

-#define RINOK_WRes(x) { WRes __result__ = (x); if (__result__ != 0) return __result__; }

-#ifdef _LZMA_UINT32_IS_ULONG

-#define MY_HRES_ERROR__INTERNAL_ERROR ((HRESULT)0x8007054FL)

-

-#ifdef _SZ_NO_INT_64

-/* define _SZ_NO_INT_64, if your compiler doesn't support 64-bit integers.

- NOTES: Some code will work incorrectly in that case! */

-#if defined(_MSC_VER) || defined(__BORLANDC__)

-#define UINT64_CONST(n) n

-#define UINT64_CONST(n) n ## ULL

-#ifdef _LZMA_NO_SYSTEM_SIZE_T

-typedef UInt32 SizeT;

-#define MY_STD_CALL __stdcall

-#define MY_STD_CALL

-#define MY_NO_INLINE __declspec(noinline)

-#define MY_NO_INLINE

-#define MY_FORCE_INLINE __forceinline

-#define MY_CDECL __cdecl

-#define MY_FAST_CALL __fastcall

-#define MY_NO_INLINE __attribute__((noinline))

-// #define MY_FORCE_INLINE __attribute__((always_inline)) inline

-#define MY_NO_INLINE

-#define MY_FORCE_INLINE

-

-

-#define MY_CDECL

-// #define MY_FAST_CALL __attribute__((fastcall))

-// #define MY_FAST_CALL __attribute__((cdecl))

-#define MY_FAST_CALL

-// #define MY_FAST_CALL __attribute__((ms_abi))

-#define MY_FAST_CALL

-#define MY_FAST_CALL

-typedef struct IByteIn IByteIn;

-struct IByteIn

- Byte (*Read)(const IByteIn *p); /* reads one byte, returns 0 in case of EOF or error */

-typedef struct IByteOut IByteOut;

-struct IByteOut

- void (*Write)(const IByteOut *p, Byte b);

-typedef struct ISeqInStream ISeqInStream;

-struct ISeqInStream

- SRes (*Read)(const ISeqInStream *p, void *buf, size_t *size);

-SRes SeqInStream_Read(const ISeqInStream *stream, void *buf, size_t size);

-SRes SeqInStream_Read2(const ISeqInStream *stream, void *buf, size_t size, SRes errorType);

-SRes SeqInStream_ReadByte(const ISeqInStream *stream, Byte *buf);

-typedef struct ISeqOutStream ISeqOutStream;

-struct ISeqOutStream

- size_t (*Write)(const ISeqOutStream *p, const void *buf, size_t size);

-typedef struct ISeekInStream ISeekInStream;

-struct ISeekInStream

- SRes (*Read)(const ISeekInStream *p, void *buf, size_t *size); /* same as ISeqInStream::Read */

- SRes (*Seek)(const ISeekInStream *p, Int64 *pos, ESzSeek origin);

-typedef struct ILookInStream ILookInStream;

-struct ILookInStream

- SRes (*Look)(const ILookInStream *p, const void **buf, size_t *size);

- SRes (*Skip)(const ILookInStream *p, size_t offset);

-

- SRes (*Read)(const ILookInStream *p, void *buf, size_t *size);

- SRes (*Seek)(const ILookInStream *p, Int64 *pos, ESzSeek origin);

-SRes LookInStream_LookRead(const ILookInStream *stream, void *buf, size_t *size);

-SRes LookInStream_SeekTo(const ILookInStream *stream, UInt64 offset);

-SRes LookInStream_Read2(const ILookInStream *stream, void *buf, size_t size, SRes errorType);

-SRes LookInStream_Read(const ILookInStream *stream, void *buf, size_t size);

-

- const ISeekInStream *realStream;

-#define LookToRead2_Init(p) { (p)->pos = (p)->size = 0; }

- const ILookInStream *realStream;

- const ILookInStream *realStream;

-typedef struct ICompressProgress ICompressProgress;

-

-struct ICompressProgress

- SRes (*Progress)(const ICompressProgress *p, UInt64 inSize, UInt64 outSize);

-#ifndef MY_container_of

-#define MY_container_of(ptr, type, m) container_of(ptr, type, m)

-#define MY_container_of(ptr, type, m) CONTAINING_RECORD(ptr, type, m)

-#define MY_container_of(ptr, type, m) ((type *)((char *)(ptr) - offsetof(type, m)))

-#define MY_container_of(ptr, type, m) (&((type *)0)->m == (ptr), ((type *)(((char *)(ptr)) - MY_offsetof(type, m))))

-#define MY_container_of(ptr, type, m) ((type *)(void *)((char *)(void *)(1 ? (ptr) : &((type *)0)->m) - MY_offsetof(type, m)))

-#endif

-

-#define CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ((type *)(void *)(ptr))

-#define CONTAINER_FROM_VTBL(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)

-#define CONTAINER_FROM_VTBL(ptr, type, m) MY_container_of(ptr, type, m)

-#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)

-#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL(ptr, type, m)

-#define MY_memset_0_ARRAY(a) memset((a), 0, sizeof(a))

-2021-07-13 : Igor Pavlov : Public domain */

-#include <stdio.h>

-

-#include <Windows.h>

-/* #define _SZ_ALLOC_DEBUG */

-/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */

-#ifdef _SZ_ALLOC_DEBUG

-int g_allocCount = 0;

-int g_allocCountMid = 0;

-int g_allocCountBig = 0;

- unsigned char temp[tempSize]; unsigned i = 0; \

- while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \

- CONVERT_INT_TO_STR(char, 24);

-static void PrintLn()

-static void PrintDec(UInt64 v, size_t align)

- ConvertUInt64ToString(v, s);

-#define PRINT_ALLOC(name, cnt, size, ptr) \

- PrintLn();

- PRINT_ALLOC("Alloc ", g_allocCount, size, NULL);

- #ifdef _SZ_ALLOC_DEBUG

- // PRINT_ALLOC("Alloc ", g_allocCount, size, p);

- PRINT_FREE("Free ", g_allocCount, address);

-

- PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, NULL);

-

- PRINT_FREE("Free-Mid", g_allocCountMid, address);

-#ifdef _7ZIP_LARGE_PAGES

-typedef SIZE_T (WINAPI *GetLargePageMinimumP)(VOID);

-#endif // _7ZIP_LARGE_PAGES

-

-void SetLargePageSize()

- #ifdef _7ZIP_LARGE_PAGES

- GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)

- GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");

- if (!largePageMinimum)

- size = largePageMinimum();

- PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL);

-

- #ifdef _7ZIP_LARGE_PAGES

- void *res = VirtualAlloc(NULL, size2, MEM_COMMIT | MY__MEM_LARGE_PAGES, PAGE_READWRITE);

- if (res)

- return res;

- return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);

- PRINT_FREE("Free-Big", g_allocCountBig, address);

-

- if (!address)

- return;

- VirtualFree(address, 0, MEM_RELEASE);

-#endif

-static void *SzAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MyAlloc(size); }

-static void SzFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MyFree(address); }

-static void *SzMidAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MidAlloc(size); }

-static void SzMidFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MidFree(address); }

-static void *SzBigAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return BigAlloc(size); }

-static void SzBigFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); BigFree(address); }

- UNUSED_VAR(pp);

- UNUSED_VAR(pp);

- UNUSED_VAR(pp);

- CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);

- CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);

-2021-07-13 : Igor Pavlov : Public domain */

-#ifndef __COMMON_ALLOC_H

-#define __COMMON_ALLOC_H

-/* Compiler.h

-2021-01-05 : Igor Pavlov : Public domain */

-#ifndef __7Z_COMPILER_H

-#define __7Z_COMPILER_H

- #ifdef __clang__

- #pragma clang diagnostic ignored "-Wunused-private-field"

- #endif

- #if _MSC_VER >= 1300

- #pragma warning(disable : 4996) // This function or variable may be unsafe

- #else

- #pragma warning(disable : 4511) // copy constructor could not be generated

- #pragma warning(disable : 4512) // assignment operator could not be generated

- #pragma warning(disable : 4514) // unreferenced inline function has been removed

- #pragma warning(disable : 4702) // unreachable code

- #pragma warning(disable : 4710) // not inlined

- #pragma warning(disable : 4714) // function marked as __forceinline not inlined

- #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information

- #endif

- #ifdef __clang__

- #pragma clang diagnostic ignored "-Wdeprecated-declarations"

- #pragma clang diagnostic ignored "-Wmicrosoft-exception-spec"

- // #pragma clang diagnostic ignored "-Wreserved-id-macro"

- #endif

-2021-07-13 : Igor Pavlov : Public domain */

-#if (defined(_MSC_VER) && !defined(MY_CPU_AMD64)) || defined(__GNUC__)

-#define USE_ASM

-#if !defined(USE_ASM) && _MSC_VER >= 1500

-#include <intrin.h>

-#if defined(USE_ASM) && !defined(MY_CPU_AMD64)

-static UInt32 CheckFlag(UInt32 flag)

-{

- #ifdef _MSC_VER

- __asm pushfd;

- __asm pop EAX;

- __asm mov EDX, EAX;

- __asm xor EAX, flag;

- __asm push EAX;

- __asm popfd;

- __asm pushfd;

- __asm pop EAX;

- __asm xor EAX, EDX;

- __asm push EDX;

- __asm popfd;

- __asm and flag, EAX;

- #else

- "pushf\n\t"

- "pop %%EAX\n\t"

- "movl %%EAX,%%EDX\n\t"

- "xorl %0,%%EAX\n\t"

- "push %%EAX\n\t"

- "popf\n\t"

- "pushf\n\t"

- "pop %%EAX\n\t"

- "xorl %%EDX,%%EAX\n\t"

- "push %%EDX\n\t"

- "popf\n\t"

- "andl %%EAX, %0\n\t":

- "=c" (flag) : "c" (flag) :

- "%eax", "%edx");

- return flag;

-#define CHECK_CPUID_IS_SUPPORTED if (CheckFlag(1 << 18) == 0 || CheckFlag(1 << 21) == 0) return False;

-#else

-#define CHECK_CPUID_IS_SUPPORTED

-#endif

-#ifndef USE_ASM

- #ifdef _MSC_VER

- #define MY__cpuidex __cpuidex

-

- __cpuid (function == 4) requires subfunction number in ECX.

- __cpuid() in old MSVC (14.00) doesn't clear ECX

- We still can use __cpuid for low (function) values that don't require ECX,

- but __cpuid() in old MSVC will be incorrect for some function values: (function == 4).

- where ECX value is first parameter for FAST_CALL / NO_INLINE function,

- So the caller of MY__cpuidex_HACK() sets ECX as subFunction, and

- DON'T remove MY_NO_INLINE and MY_FAST_CALL for MY__cpuidex_HACK() !!!

-

-MY_NO_INLINE

-void MY_FAST_CALL MY__cpuidex_HACK(UInt32 subFunction, int *CPUInfo, UInt32 function)

- UNUSED_VAR(subFunction);

- __cpuid(CPUInfo, function);

-

- #define MY__cpuidex(info, func, func2) MY__cpuidex_HACK(func2, info, func)

- #pragma message("======== MY__cpuidex_HACK WAS USED ========")

- #endif

- #else

- #define MY__cpuidex(info, func, func2) __cpuid(info, func)

- #pragma message("======== (INCORRECT ?) cpuid WAS USED ========")

- #endif

-

-

-

-

-void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d)

- #ifdef USE_ASM

-

- #ifdef _MSC_VER

-

- UInt32 a2, b2, c2, d2;

- __asm xor EBX, EBX;

- __asm xor ECX, ECX;

- __asm xor EDX, EDX;

- __asm mov EAX, function;

- __asm cpuid;

- __asm mov a2, EAX;

- __asm mov b2, EBX;

- __asm mov c2, ECX;

- __asm mov d2, EDX;

-

- *a = a2;

- *b = b2;

- *c = c2;

- *d = d2;

-

- #else

-

- __asm__ __volatile__ (

- #if defined(MY_CPU_AMD64) && defined(__PIC__)

- "mov %%rbx, %%rdi;"

- "cpuid;"

- "xchg %%rbx, %%rdi;"

- : "=a" (*a) ,

- "=D" (*b) ,

- #elif defined(MY_CPU_X86) && defined(__PIC__)

- "mov %%ebx, %%edi;"

- "cpuid;"

- "xchgl %%ebx, %%edi;"

- : "=a" (*a) ,

- "=D" (*b) ,

- #else

- "cpuid"

- : "=a" (*a) ,

- "=b" (*b) ,

- #endif

- "=c" (*c) ,

- "=d" (*d)

- : "0" (function), "c"(0) ) ;

-

- #endif

-

- #else

- int CPUInfo[4];

- MY__cpuidex(CPUInfo, (int)function, 0);

- *a = (UInt32)CPUInfo[0];

- *b = (UInt32)CPUInfo[1];

- *c = (UInt32)CPUInfo[2];

- *d = (UInt32)CPUInfo[3];

- #endif

-}

-BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p)

- MyCPUID(0, &p->maxFunc, &p->vendor[0], &p->vendor[2], &p->vendor[1]);

- MyCPUID(1, &p->ver, &p->b, &p->c, &p->d);

-static const UInt32 kVendors[][3] =

- { 0x756E6547, 0x49656E69, 0x6C65746E},

- { 0x68747541, 0x69746E65, 0x444D4163},

- { 0x746E6543, 0x48727561, 0x736C7561}

- for (i = 0; i < sizeof(kVendors) / sizeof(kVendors[i]); i++)

- if (v[0] == p->vendor[0] &&

- v[1] == p->vendor[1] &&

- v[2] == p->vendor[2])

- int firm;

- family = x86cpuid_GetFamily(p.ver);

- model = x86cpuid_GetModel(p.ver);

-

- firm = x86cpuid_GetFirm(&p);

- switch (firm)

- /* In-Order Atom CPU */

- model == 0x1C /* 45 nm, N4xx, D4xx, N5xx, D5xx, 230, 330 */

- || model == 0x26 /* 45 nm, Z6xx */

- || model == 0x27 /* 32 nm, Z2460 */

- || model == 0x35 /* 32 nm, Z2760 */

- || model == 0x36 /* 32 nm, N2xxx, D2xxx */

- return True;

-#include <Windows.h>

-static BoolInt CPU_Sys_Is_SSE_Supported()

- OSVERSIONINFO vi;

- vi.dwOSVersionInfoSize = sizeof(vi);

- if (!GetVersionEx(&vi))

- return False;

- return (vi.dwMajorVersion >= 5);

-static UInt32 X86_CPUID_ECX_Get_Flags()

- Cx86cpuid p;

- if (!x86cpuid_CheckAndRead(&p))

- return p.c;

-BoolInt CPU_IsSupported_AES()

- return (X86_CPUID_ECX_Get_Flags() >> 25) & 1;

-BoolInt CPU_IsSupported_SSSE3()

- return (X86_CPUID_ECX_Get_Flags() >> 9) & 1;

-BoolInt CPU_IsSupported_SSE41()

- return (X86_CPUID_ECX_Get_Flags() >> 19) & 1;

-BoolInt CPU_IsSupported_SHA()

- Cx86cpuid p;

- if (!x86cpuid_CheckAndRead(&p))

- return False;

- if (p.maxFunc < 7)

- UInt32 d[4] = { 0 };

- MyCPUID(7, &d[0], &d[1], &d[2], &d[3]);

-// #include <stdio.h>

-#ifdef _WIN32

-#include <Windows.h>

-BoolInt CPU_IsSupported_AVX2()

- Cx86cpuid p;

- CHECK_SYS_SSE_SUPPORT

- #define MY__PF_XSAVE_ENABLED 17

- if (!IsProcessorFeaturePresent(MY__PF_XSAVE_ENABLED))

- if (!x86cpuid_CheckAndRead(&p))

- if (p.maxFunc < 7)

- UInt32 d[4] = { 0 };

- MyCPUID(7, &d[0], &d[1], &d[2], &d[3]);

-BoolInt CPU_IsSupported_VAES_AVX2()

- Cx86cpuid p;

- CHECK_SYS_SSE_SUPPORT

-

- #ifdef _WIN32

- #define MY__PF_XSAVE_ENABLED 17

- if (!IsProcessorFeaturePresent(MY__PF_XSAVE_ENABLED))

- #endif

-

- if (!x86cpuid_CheckAndRead(&p))

- return False;

- if (p.maxFunc < 7)

- UInt32 d[4] = { 0 };

- MyCPUID(7, &d[0], &d[1], &d[2], &d[3]);

-BoolInt CPU_IsSupported_PageGB()

- Cx86cpuid cpuid;

- if (!x86cpuid_CheckAndRead(&cpuid))

- return False;

- UInt32 d[4] = { 0 };

- MyCPUID(0x80000000, &d[0], &d[1], &d[2], &d[3]);

- }

- {

- UInt32 d[4] = { 0 };

- MyCPUID(0x80000001, &d[0], &d[1], &d[2], &d[3]);

-#include <Windows.h>

-BoolInt CPU_IsSupported_CRC32() { return IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }

-BoolInt CPU_IsSupported_CRYPTO() { return IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }

-BoolInt CPU_IsSupported_NEON() { return IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }

-static BoolInt My_sysctlbyname_Get_BoolInt(const char *name)

- if (My_sysctlbyname_Get_UInt32(name, &val) == 0 && val == 1)

- /*

- Print_sysctlbyname("hw.pagesize");

- Print_sysctlbyname("machdep.cpu.brand_string");

- */

-

- return My_sysctlbyname_Get_BoolInt("hw.optional.armv8_crc32");

- return My_sysctlbyname_Get_BoolInt("hw.optional.neon");

-int My_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize)

-int My_sysctlbyname_Get_UInt32(const char *name, UInt32 *val)

- int res = My_sysctlbyname_Get(name, val, &bufSize);

-2021-07-13 : Igor Pavlov : Public domain */

-#ifndef __CPU_ARCH_H

-#define __CPU_ARCH_H

- #define MY_CPU_NAME "arm64"

-#if defined(__sparc64__)

- #define MY_CPU_NAME "sparc64"

- #define MY_CPU_64BIT

-#elif defined(__sparc__)

- #define MY_CPU_NAME "sparc"

- /* #define MY_CPU_32BIT */

-#ifdef MY_CPU_LE_UNALIGN_64

-#define SetUi64(p, v) { *(UInt64 *)(void *)(p) = (v); }

-#endif

-#ifndef MY_CPU_LE_UNALIGN_64

-

- SetUi32(_ppp2_ , (UInt32)_vvv2_); \

- SetUi32(_ppp2_ + 4, (UInt32)(_vvv2_ >> 32)); }

-

-#ifdef __has_builtin

- #define MY__has_builtin(x) __has_builtin(x)

-#else

- #define MY__has_builtin(x) 0

-#if defined(MY_CPU_LE_UNALIGN) && /* defined(_WIN64) && */ defined(_MSC_VER) && (_MSC_VER >= 1300)

-

-/* Note: we use bswap instruction, that is unsupported in 386 cpu */

-

-#include <stdlib.h>

-

-#pragma intrinsic(_byteswap_ushort)

-#pragma intrinsic(_byteswap_ulong)

-#pragma intrinsic(_byteswap_uint64)

-

-/* #define GetBe16(p) _byteswap_ushort(*(const UInt16 *)(const Byte *)(p)) */

-#define GetBe32(p) _byteswap_ulong (*(const UInt32 *)(const void *)(p))

-#define GetBe64(p) _byteswap_uint64(*(const UInt64 *)(const void *)(p))

-

-#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = _byteswap_ulong(v)

-

-#elif defined(MY_CPU_LE_UNALIGN) && ( \

- (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) \

- || (defined(__clang__) && MY__has_builtin(__builtin_bswap16)) )

-

-/* #define GetBe16(p) __builtin_bswap16(*(const UInt16 *)(const void *)(p)) */

-#define GetBe32(p) __builtin_bswap32(*(const UInt32 *)(const void *)(p))

-#define GetBe64(p) __builtin_bswap64(*(const UInt64 *)(const void *)(p))

-

-#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = __builtin_bswap32(v)

-

-#define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4))

-

-

-#ifdef MY_CPU_X86_OR_AMD64

-typedef struct

-{

- UInt32 maxFunc;

- UInt32 vendor[3];

- UInt32 ver;

- UInt32 b;

- UInt32 c;

- UInt32 d;

-} Cx86cpuid;

-enum

-{

- CPU_FIRM_INTEL,

- CPU_FIRM_AMD,

- CPU_FIRM_VIA

-};

-void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d);

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

-BoolInt CPU_Is_InOrder(void);

-int My_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize);

-int My_sysctlbyname_Get_UInt32(const char *name, UInt32 *val);

-2021-11-29 : Igor Pavlov : Public domain */

-// #define kMaxValForNormalize ((UInt32)(1 << 20) + 0xFFF) // for debug

- if (!p->directInput)

- ISzAlloc_Free(alloc, p->bufferBase);

- p->bufferBase = NULL;

- if (!p->bufferBase || p->blockSize != blockSize)

- p->bufferBase = (Byte *)ISzAlloc_Alloc(alloc, blockSize);

- // printf("\nbufferBase = %p\n", p->bufferBase);

- return (p->bufferBase != NULL);

-MY_NO_INLINE

- p->directInputRem -= curSize;

- Byte *dest = p->buffer + GET_AVAIL_BYTES(p);

- size_t size = (size_t)(p->bufferBase + p->blockSize - dest);

- p->result = ISeqInStream_Read(p->stream, dest, &size);

-MY_NO_INLINE

- const size_t offset = (size_t)(p->buffer - p->bufferBase) - p->keepSizeBefore;

- p->buffer = p->bufferBase + keepBefore;

- memmove(p->bufferBase,

- p->bufferBase + (offset & ~((size_t)kBlockMoveAlign - 1)),

- return ((size_t)(p->bufferBase + p->blockSize - p->buffer) <= p->keepSizeAfter);

- p->bufferBase = NULL;

- size_t sizeInBytes = (size_t)num * sizeof(CLzRef);

- const UInt32 newCyclicBufferSize = historySize + 1; // do not change it

- UInt32 hs;

- p->matchMaxLen = matchMaxLen;

- // UInt32 hs4;

- p->fixedHashSize = 0;

- hs = (1 << 16) - 1;

- if (p->numHashBytes != 2)

- hs = historySize;

- if (hs > p->expectedDataSize)

- hs = (UInt32)p->expectedDataSize;

- if (hs != 0)

- hs--;

- hs |= (hs >> 1);

- hs |= (hs >> 2);

- hs |= (hs >> 4);

- hs |= (hs >> 8);

- // we propagated 16 bits in (hs). Low 16 bits must be set later

- hs >>= 1;

- if (hs >= (1 << 24))

- {

- if (p->numHashBytes == 3)

- hs = (1 << 24) - 1;

- else

- hs >>= 1;

- /* if (bigHash) mode, GetHeads4b() in LzFindMt.c needs (hs >= ((1 << 24) - 1))) */

- }

-

- // hs = ((UInt32)1 << 25) - 1; // for test

-

-

- // bt5: we adjust the size with recommended minimum size

- p->hashMask = hs;

- hs++;

-

- /*

- hs4 = (1 << 20);

- if (hs4 > hs)

- hs4 = hs;

- // hs4 = (1 << 16); // for test

- p->hash4Mask = hs4 - 1;

- */

- if (p->numHashBytes > 2) p->fixedHashSize += kHash2Size;

- if (p->numHashBytes > 3) p->fixedHashSize += kHash3Size;

- // if (p->numHashBytes > 4) p->fixedHashSize += hs4; // kHash4Size;

- hs += p->fixedHashSize;

- p->hashSizeSum = hs;

- newSize = hs + numSons;

- if (p->hash && p->numRefs == newSize)

- p->son = p->hash + p->hashSizeSum;

- p->buffer = p->bufferBase;

- #if defined(__clang__) && (__clang_major__ >= 8) \

- || defined(__GNUC__) && (__GNUC__ >= 8) \

- || defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1900)

- #define USE_SATUR_SUB_128

- #define USE_AVX2

- #define ATTRIB_SSE41 __attribute__((__target__("sse4.1")))

- #define ATTRIB_AVX2 __attribute__((__target__("avx2")))

- #define USE_SATUR_SUB_128

- #if (_MSC_VER >= 1900)

- #define USE_AVX2

- #include <immintrin.h> // avx

- #endif

- #define USE_SATUR_SUB_128

- // #define ATTRIB_SSE41 __attribute__((__target__("")))

- // #define ATTRIB_SSE41 __attribute__((__target__("fpu=crypto-neon-fp-armv8")))

- #define USE_SATUR_SUB_128

-/*

-#ifndef ATTRIB_SSE41

- #define ATTRIB_SSE41

-#endif

-#ifndef ATTRIB_AVX2

- #define ATTRIB_AVX2

-#endif

-*/

-#ifdef USE_SATUR_SUB_128

-// #define _SHOW_HW_STATUS

-#ifdef _SHOW_HW_STATUS

-#define _PRF(x) x

-_PRF(;)

-#define _PRF(x)

-// #define FORCE_SATUR_SUB_128

-typedef uint32x4_t v128;

-#define SASUB_128(i) \

- *(v128 *)(void *)(items + (i) * 4) = \

- vsubq_u32(vmaxq_u32(*(const v128 *)(const void *)(items + (i) * 4), sub2), sub2);

-

-#else

-typedef __m128i v128;

-#define SASUB_128(i) \

- *(v128 *)(void *)(items + (i) * 4) = \

- _mm_sub_epi32(_mm_max_epu32(*(const v128 *)(const void *)(items + (i) * 4), sub2), sub2); // SSE 4.1

-#endif

-MY_NO_INLINE

-#ifdef ATTRIB_SSE41

-ATTRIB_SSE41

-MY_FAST_CALL

- v128 sub2 =

- SASUB_128(0)

- SASUB_128(1)

- SASUB_128(2)

- SASUB_128(3)

- items += 4 * 4;

-#ifdef USE_AVX2

-#define SASUB_256(i) *(__m256i *)(void *)(items + (i) * 8) = _mm256_sub_epi32(_mm256_max_epu32(*(const __m256i *)(const void *)(items + (i) * 8), sub2), sub2); // AVX2

-MY_NO_INLINE

-#ifdef ATTRIB_AVX2

-ATTRIB_AVX2

-MY_FAST_CALL

- __m256i sub2 = _mm256_set_epi32(

- SASUB_256(0)

- SASUB_256(1)

- items += 2 * 8;

-#endif // USE_AVX2

-#ifndef FORCE_SATUR_SUB_128

-typedef void (MY_FAST_CALL *LZFIND_SATUR_SUB_CODE_FUNC)(

-#endif // FORCE_SATUR_SUB_128

-#endif // USE_SATUR_SUB_128

-// #define SASUB_32(i) v = items[i]; m = v - subValue; if (v < subValue) m = kEmptyHashValue; items[i] = m;

-#define SASUB_32(i) v = items[i]; if (v < subValue) v = subValue; items[i] = v - subValue;

-#ifdef FORCE_SATUR_SUB_128

-MY_NO_INLINE

-MY_FAST_CALL

- UInt32 v;

- SASUB_32(0)

- SASUB_32(1)

- SASUB_32(2)

- SASUB_32(3)

- SASUB_32(4)

- SASUB_32(5)

- SASUB_32(6)

- SASUB_32(7)

- items += 8;

-MY_NO_INLINE

- #define K_NORM_ALIGN_BLOCK_SIZE (1 << 6)

-

- CLzRef *lim;

-

- for (; numItems != 0 && ((unsigned)(ptrdiff_t)items & (K_NORM_ALIGN_BLOCK_SIZE - 1)) != 0; numItems--)

- UInt32 v;

- SASUB_32(0);

-

- #define K_NORM_ALIGN_MASK (K_NORM_ALIGN_BLOCK_SIZE / 4 - 1)

- lim = items + (numItems & ~(size_t)K_NORM_ALIGN_MASK);

- numItems &= K_NORM_ALIGN_MASK;

- #if defined(USE_SATUR_SUB_128) && !defined(FORCE_SATUR_SUB_128)

-

-

- UInt32 v;

- SASUB_32(0);

-MY_NO_INLINE

- size_t numSonRefs = p->cyclicBufferSize;

- if (p->btMode)

- numSonRefs <<= 1;

- Inline_MatchFinder_ReduceOffsets(p, subValue);

- MatchFinder_Normalize3(subValue, p->hash, (size_t)p->hashSizeSum + numSonRefs);

-MY_FORCE_INLINE

-MY_FORCE_INLINE

-MY_NO_INLINE

- MOVE_POS;

- unsigned lenLimit; UInt32 hv; Byte *cur; UInt32 curMatch; \

-#define SKIP_FOOTER SkipMatchesSpec(MF_PARAMS(p)); MOVE_POS; } while (--num);

- distances, (UInt32)_maxLen_); MOVE_POS_RET;

- HASH2_CALC;

- HASH_ZIP_CALC;

- HASH3_CALC;

- MOVE_POS_RET;

- HASH4_CALC;

- HASH5_CALC;

- MOVE_POS_RET;

- HASH4_CALC;

- MOVE_POS_RET;

- GET_MATCHES_FOOTER_HC(maxLen);

- HASH5_CALC;

- MOVE_POS_RET;

- GET_MATCHES_FOOTER_HC(maxLen);

- HASH_ZIP_CALC;

- HASH2_CALC;

- HASH_ZIP_CALC;

- HASH3_CALC;

- HASH4_CALC;

- HASH5_CALC;

- Byte *cur; \

- HASH4_CALC;

- HASH_ZIP_CALC;

-void LzFindPrepare()

- #ifndef FORCE_SATUR_SUB_128

- #ifdef USE_SATUR_SUB_128

- _PRF(printf("\n=== LzFind NEON\n"));

- _PRF(printf("\n=== LzFind SSE41\n"));

- #ifdef USE_AVX2

- _PRF(printf("\n=== LzFind AVX2\n"));

- #endif // USE_SATUR_SUB_128

- #endif // FORCE_SATUR_SUB_128

-2021-07-13 : Igor Pavlov : Public domain */

-#ifndef __LZ_FIND_H

-#define __LZ_FIND_H

-typedef struct _CMatchFinder

- Byte *buffer;

- Byte *bufferBase;

- ISeqInStream *stream;

- UInt32 hashSizeSum;

-/* Conditions:

- historySize <= 3 GB

- keepAddBufferBefore + matchMaxLen + keepAddBufferAfter < 511MB

-// void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);

-#define Inline_MatchFinder_InitPos(p, val) \

-#define Inline_MatchFinder_ReduceOffsets(p, subValue) \

-typedef struct _IMatchFinder

-2021-12-21 : Igor Pavlov : Public domain */

-#define __MT_HASH4_CALC { \

-MY_NO_INLINE

- Thread_Construct(&p->thread);

-MY_NO_INLINE

- LOCK_BUFFER(p);

-MY_NO_INLINE

-MY_NO_INLINE

-#define RINOK_THREAD(x) RINOK(x)

-MY_NO_INLINE

- RINOK_THREAD(CriticalSection_Init(&p->cs));

- RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canStart));

- RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStopped));

- RINOK_THREAD(wres);

-MY_NO_INLINE

- Inline_MatchFinder_ReduceOffsets(mf, subValue);

-UInt32 * MY_FAST_CALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,

-MY_NO_INLINE

- RINOK(MtSync_Create(&p->hashSync, HashThreadFunc2, p));

- RINOK(MtSync_Create(&p->btSync, BtThreadFunc2, p));

- RINOK(MtSync_Init(&p->hashSync, kMtHashNumBlocks));

-MY_NO_INLINE

-static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *d)

- #define _USE_H2

-

- #ifdef _USE_H2

-

- #ifdef _USE_H4

- #endif

- #ifdef _USE_H4

-static UInt32* MatchFinderMt2_GetMatches(CMatchFinderMt *p, UInt32 *d)

-static UInt32* MatchFinderMt_GetMatches(CMatchFinderMt *p, UInt32 *d)

-2021-07-12 : Igor Pavlov : Public domain */

-#ifndef __LZ_FIND_MT_H

-#define __LZ_FIND_MT_H

-typedef struct _CMtSync

-typedef struct _CMatchFinderMt

-2021-07-13 : Igor Pavlov : Public domain */

-MY_NO_INLINE

-UInt32 * MY_FAST_CALL GetMatchesSpecN_1(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,

-UInt32 * MY_FAST_CALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,

-MY_NO_INLINE

-UInt32 * MY_FAST_CALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,

-UInt32 * MY_FAST_CALL GetMatchesSpecN_3(uint32plus lenLimit, size_t pos, const Byte *cur, CLzRef *son,

-/* LzHash.h -- HASH functions for LZ algorithms

-2019-10-30 : Igor Pavlov : Public domain */

-#ifndef __LZ_HASH_H

-#define __LZ_HASH_H

-2021-04-01 : Igor Pavlov : Public domain */

-#define kNumTopBits 24

-#define kTopValue ((UInt32)1 << kNumTopBits)

-#ifndef _LZMA_DEC_OPT

- { UPDATE_0(p); i = (i + i); A0; } else \

- { UPDATE_1(p); i = (i + i) + 1; A1; }

- { UPDATE_0(p + i); A0; } else \

- { UPDATE_1(p + i); A1; }

-/* #define _LZMA_SIZE_OPT */

-#ifdef _LZMA_SIZE_OPT

- TREE_GET_BIT(probs, i); \

- TREE_GET_BIT(probs, i); \

- TREE_GET_BIT(probs, i); \

- TREE_GET_BIT(probs, i); \

- TREE_GET_BIT(probs, i); \

- TREE_GET_BIT(probs, i); \

-#endif // _LZMA_DEC_OPT

-#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)

- { UPDATE_0_CHECK; i = (i + i); A0; } else \

- { UPDATE_1_CHECK; i = (i + i) + 1; A1; }

- { UPDATE_0_CHECK; i += m; m += m; } else \

- { UPDATE_1_CHECK; m += m; i += m; }

-#ifdef _LZMA_DEC_OPT

-int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit);

-int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit)

- UPDATE_0(prob);

- #ifdef _LZMA_SIZE_OPT

- #ifdef _LZMA_SIZE_OPT

- UPDATE_1(prob);

- UPDATE_0(prob);

- UPDATE_1(prob);

- UPDATE_0(prob);

- UPDATE_0(prob);

- UPDATE_1(prob);

- UPDATE_1(prob);

- UPDATE_0(prob);

- UPDATE_1(prob);

- UPDATE_0(prob);

- UPDATE_1(prob);

- #ifdef _LZMA_SIZE_OPT

- UPDATE_0(probLen);

- UPDATE_1(probLen);

- UPDATE_0(probLen);

- UPDATE_1(probLen);

- TREE_DECODE(probLen, lim, len);

- UPDATE_0(probLen);

- TREE_GET_BIT(probLen, len);

- TREE_GET_BIT(probLen, len);

- TREE_GET_BIT(probLen, len);

- UPDATE_1(probLen);

- UPDATE_0(probLen);

- TREE_GET_BIT(probLen, len);

- TREE_GET_BIT(probLen, len);

- TREE_GET_BIT(probLen, len);

- UPDATE_1(probLen);

- TREE_DECODE(probLen, (1 << kLenNumHighBits), len);

- TREE_6_DECODE(prob, distance);

- REV_BIT_VAR(prob, distance, m);

- REV_BIT_CONST(prob, i, 1);

- REV_BIT_CONST(prob, i, 2);

- REV_BIT_CONST(prob, i, 4);

- REV_BIT_LAST (prob, i, 8);

- NORMALIZE;

-static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)

-static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)

- UPDATE_1_CHECK;

- UPDATE_0_CHECK;

- UPDATE_1_CHECK;

- UPDATE_0_CHECK;

- UPDATE_0_CHECK;

- UPDATE_1_CHECK;

- UPDATE_1_CHECK;

- UPDATE_0_CHECK;

- UPDATE_1_CHECK;

- UPDATE_0_CHECK;

- UPDATE_1_CHECK;

- UPDATE_0_CHECK;

- UPDATE_1_CHECK;

- UPDATE_0_CHECK;

- UPDATE_1_CHECK;

- TREE_DECODE_CHECK(probLen, limit, len);

- TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot);

- REV_BIT_CHECK(prob, i, m);

- NORMALIZE_CHECK;

-#define RETURN__NOT_FINISHED__FOR_FINISH \

- RETURN__NOT_FINISHED__FOR_FINISH;

- RETURN__NOT_FINISHED__FOR_FINISH;

- RETURN__NOT_FINISHED__FOR_FINISH;

- RINOK(LzmaProps_Decode(&propNew, props, propsSize));

- RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));

- RINOK(LzmaProps_Decode(&propNew, props, propsSize));

- RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));

- else if (dictSize >= ((UInt32)1 << 22)) mask = ((UInt32)1 << 20) - 1;;

- LzmaDec_Construct(&p);

- RINOK(LzmaDec_AllocateProbs(&p, propData, propSize, alloc));

-2020-03-19 : Igor Pavlov : Public domain */

-#ifndef __LZMA_DEC_H

-#define __LZMA_DEC_H

-/* #define _LZMA_PROB32 */

-/* _LZMA_PROB32 can increase the speed on some CPUs,

-#ifdef _LZMA_PROB32

-typedef struct _CLzmaProps

-#define LzmaDec_Construct(p) { (p)->dic = NULL; (p)->probs = NULL; }

-2021-11-18: Igor Pavlov : Public domain */

-#ifndef _7ZIP_ST

-SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp, ISeqInStream *inStream, UInt32 keepWindowSize,

-SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,

-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit,

-const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp);

-void LzmaEnc_Finish(CLzmaEncHandle pp);

-void LzmaEnc_SaveState(CLzmaEncHandle pp);

-void LzmaEnc_RestoreState(CLzmaEncHandle pp);

-#define kNumTopBits 24

-#define kTopValue ((UInt32)1 << kNumTopBits)

- #ifndef _7ZIP_ST

-#ifdef _LZMA_PROB32

- ISeqOutStream *outStream;

-typedef struct

- #ifndef _7ZIP_ST

- #ifndef _7ZIP_ST

- #ifndef _7ZIP_ST

-} CLzmaEnc;

-#ifndef _7ZIP_ST

-#define COPY_ARR(dest, src, arr) memcpy(dest->arr, src->arr, sizeof(src->arr));

-

-void LzmaEnc_SaveState(CLzmaEncHandle pp)

-{

- CLzmaEnc *p = (CLzmaEnc *)pp;

- CSaveState *dest = &p->saveState;

-

- dest->state = p->state;

-

- dest->lenProbs = p->lenProbs;

- dest->repLenProbs = p->repLenProbs;

-

- COPY_ARR(dest, p, reps);

-

- COPY_ARR(dest, p, posAlignEncoder);

- COPY_ARR(dest, p, isRep);

- COPY_ARR(dest, p, isRepG0);

- COPY_ARR(dest, p, isRepG1);

- COPY_ARR(dest, p, isRepG2);

- COPY_ARR(dest, p, isMatch);

- COPY_ARR(dest, p, isRep0Long);

- COPY_ARR(dest, p, posSlotEncoder);

- COPY_ARR(dest, p, posEncoders);

-

- memcpy(dest->litProbs, p->litProbs, ((UInt32)0x300 << p->lclp) * sizeof(CLzmaProb));

-

-void LzmaEnc_RestoreState(CLzmaEncHandle pp)

- CLzmaEnc *dest = (CLzmaEnc *)pp;

- const CSaveState *p = &dest->saveState;

-

- dest->state = p->state;

-

- dest->lenProbs = p->lenProbs;

- dest->repLenProbs = p->repLenProbs;

-

- COPY_ARR(dest, p, reps);

-

- COPY_ARR(dest, p, posAlignEncoder);

- COPY_ARR(dest, p, isRep);

- COPY_ARR(dest, p, isRepG0);

- COPY_ARR(dest, p, isRepG1);

- COPY_ARR(dest, p, isRepG2);

- COPY_ARR(dest, p, isMatch);

- COPY_ARR(dest, p, isRep0Long);

- COPY_ARR(dest, p, posSlotEncoder);

- COPY_ARR(dest, p, posEncoders);

-

- memcpy(dest->litProbs, p->litProbs, ((UInt32)0x300 << dest->lclp) * sizeof(CLzmaProb));

-

-SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)

- CLzmaEnc *p = (CLzmaEnc *)pp;

- #ifndef _7ZIP_ST

-void LzmaEnc_SetDataSize(CLzmaEncHandle pp, UInt64 expectedDataSiize)

- CLzmaEnc *p = (CLzmaEnc *)pp;

-MY_NO_INLINE static void RangeEnc_FlushStream(CRangeEnc *p)

-MY_NO_INLINE static void MY_FAST_CALL RangeEnc_ShiftLow(CRangeEnc *p)

-// #define _LZMA_ENC_USE_BRANCH

-#ifdef _LZMA_ENC_USE_BRANCH

- RC_BIT(p, prob, bit);

- RC_BIT(p, prob, bit);

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

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

- RC_BIT(rc, probs + m, bit);

- RC_BIT_PRE(rc, probs);

- RC_BIT_1(rc, probs);

- RC_BIT_PRE(rc, probs);

- RC_BIT_1(rc, probs);

- RC_BIT_0(rc, probs);

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

-MY_NO_INLINE static void MY_FAST_CALL LenPriceEnc_UpdateTables(

-MY_FORCE_INLINE

- MakeAs_Lit(&p->opt[1]);

- MakeAs_ShortRep(&p->opt[1]);

- GetPosSlot2(dist, slot);

- MOVE_POS(p, delta);

- MakeAs_Lit(nextOpt);

- MakeAs_ShortRep(nextOpt);

- GetPosSlot2(dist, posSlot);

- GetPosSlot2(dist, posSlot);

- RC_BIT_1(&p->rc, probs + m);

- RC_BIT_1(&p->rc, probs + m);

- #ifndef _7ZIP_ST

- p->result = MY_HRES_ERROR__INTERNAL_ERROR;

-MY_NO_INLINE static SRes Flush(CLzmaEnc *p, UInt32 nowPos)

-MY_NO_INLINE static void FillAlignPrices(CLzmaEnc *p)

-MY_NO_INLINE static void FillDistancesPrices(CLzmaEnc *p)

- #ifndef _7ZIP_ST

- LzmaEnc_SetProps(p, &props);

- #ifndef _7ZIP_ST

- LzmaEnc_Destruct((CLzmaEnc *)p, alloc, allocBig);

-MY_NO_INLINE

- #ifndef _7ZIP_ST

- RINOK(MatchFinderMt_InitMt(&p->matchFinderMt));

- RINOK(CheckErrors(p));

- RC_BIT_0(&p->rc, probs);

- RC_BIT_1(&p->rc, probs);

- RC_BIT_1(&p->rc, probs);

- RC_BIT_0(&p->rc, probs);

- RC_BIT_1_BASE(&p->rc, probs);

- RC_BIT_0_BASE(&p->rc, probs);

- RC_BIT_1(&p->rc, probs);

- RC_BIT_0_BASE(&p->rc, probs);

- RC_BIT_1(&p->rc, probs);

- RC_BIT_0_BASE(&p->rc, probs);

- RC_BIT_1_BASE(&p->rc, probs);

- RC_BIT_0(&p->rc, probs);

- GetPosSlot(dist, posSlot);

- RC_BIT(&p->rc, prob, bit);

- bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;

- bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;

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

- #ifndef _7ZIP_ST

- #ifndef _7ZIP_ST

- , allocBig));

- MFB.bigHash = (Byte)(

- (p->dictSize > kBigHashDicLimit && MFB.hashMask >= 0xFFFFFF) ? 1 : 0);

- RINOK(LzmaEnc_Alloc(p, keepWindowSize, alloc, allocBig));

- p->nowPos64 = 0;

-static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream,

- CLzmaEnc *p = (CLzmaEnc *)pp;

- MFB.stream = inStream;

- p->needInit = 1;

-SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp,

- ISeqInStream *inStream, UInt32 keepWindowSize,

- CLzmaEnc *p = (CLzmaEnc *)pp;

- MFB.stream = inStream;

- p->needInit = 1;

-static void LzmaEnc_SetInputBuf(CLzmaEnc *p, const Byte *src, SizeT srcLen)

-{

- MFB.directInput = 1;

- MFB.bufferBase = (Byte *)src;

- MFB.directInputRem = srcLen;

-}

-

-SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,

- UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)

- CLzmaEnc *p = (CLzmaEnc *)pp;

- LzmaEnc_SetInputBuf(p, src, srcLen);

- p->needInit = 1;

-

- LzmaEnc_SetDataSize(pp, srcLen);

-void LzmaEnc_Finish(CLzmaEncHandle pp)

- #ifndef _7ZIP_ST

- CLzmaEnc *p = (CLzmaEnc *)pp;

- UNUSED_VAR(pp);

- SizeT rem;

-static size_t SeqOutStreamBuf_Write(const ISeqOutStream *pp, const void *data, size_t size)

- CLzmaEnc_SeqOutStreamBuf *p = CONTAINER_FROM_VTBL(pp, CLzmaEnc_SeqOutStreamBuf, vt);

-UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp)

- const CLzmaEnc *p = (CLzmaEnc *)pp;

-const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp)

- const CLzmaEnc *p = (CLzmaEnc *)pp;

-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit,

- CLzmaEnc *p = (CLzmaEnc *)pp;

-

- nowPos64 = p->nowPos64;

-

- if (desiredPackSize == 0)

- return SZ_ERROR_OUTPUT_EOF;

-

-MY_NO_INLINE

-static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)

- #ifndef _7ZIP_ST

- LzmaEnc_Finish(p);

-SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,

- RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));

- return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);

-SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, Byte *props, SizeT *size)

- const CLzmaEnc *p = (const CLzmaEnc *)pp;

- SetUi32(props + 1, v);

-unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle pp)

- return (unsigned)((CLzmaEnc *)pp)->writeEndMark;

-SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,

- int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)

- CLzmaEnc *p = (CLzmaEnc *)pp;

- res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);

- *destLen -= outStream.rem;

- ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)

- CLzmaEnc *p = (CLzmaEnc *)LzmaEnc_Create(alloc);

-#ifndef _7ZIP_ST

-void LzmaEnc_GetLzThreads(CLzmaEncHandle pp, HANDLE lz_threads[2])

- const CLzmaEnc *p = (CLzmaEnc *)pp;

-2019-10-30 : Igor Pavlov : Public domain */

-#ifndef __LZMA_ENC_H

-#define __LZMA_ENC_H

-typedef struct _CLzmaEncProps

-typedef void * CLzmaEncHandle;

-SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream,

- ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);

- int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);

- ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);

-2015-06-13 : Igor Pavlov : Public domain */

-MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,

-MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,

-2021-04-03 : Igor Pavlov : Public domain */

-#ifndef __LZMA_LIB_H

-#define __LZMA_LIB_H

-#define MY_STDAPI int MY_STD_CALL

-MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,

-MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,

-2013-11-12 : Igor Pavlov : Public domain */

-#ifndef __7Z_PRECOMP_H

-#define __7Z_PRECOMP_H

-2021-12-21 : Igor Pavlov : Public domain */

-static WRes GetError()

- DWORD res = GetLastError();

-#ifndef _7ZIP_AFFINITY_DISABLE

-#endif

-#endif

-#ifdef _7ZIP_AFFINITY_SUPPORTED

-

-#define Print(s) PRF(printf("\n%s\n", s))

-

-// #include <stdio.h>

- Print("Thread_Create_With_CpuSet");

- RINOK(pthread_attr_init(&attr));

- #ifdef _7ZIP_AFFINITY_SUPPORTED

- Print("Thread_Create_WithAffinity");

- // Print("Thread_Close");

- // Print("Thread_Wait_Close");

- RINOK(pthread_mutex_init(&p->_mutex, NULL));

- RINOK(pthread_cond_init(&p->_cond, NULL));

- RINOK(pthread_mutex_lock(&p->_mutex));

- RINOK(pthread_mutex_lock(&p->_mutex));

- RINOK(pthread_mutex_lock(&p->_mutex));

- RINOK(pthread_mutex_init(&p->_mutex, NULL));

- RINOK(pthread_cond_init(&p->_cond, NULL));

- RINOK(pthread_mutex_lock(&p->_mutex));

- RINOK(pthread_mutex_unlock(&p->_mutex));

- RINOK(pthread_mutex_lock(&p->_mutex));

- // Print("CriticalSection_Init");

- // Print("CriticalSection_Enter");

- // Print("CriticalSection_Leave");

- // Print("CriticalSection_Delete");

- // Print("InterlockedIncrement");

-2021-12-21 : Igor Pavlov : Public domain */

-#ifndef __7Z_THREADS_H

-#define __7Z_THREADS_H

-#include <Windows.h>

-#ifndef _7ZIP_AFFINITY_DISABLE

-#define _7ZIP_AFFINITY_SUPPORTED

-// #pragma message(" ==== _7ZIP_AFFINITY_SUPPORTED")

-#define Thread_Construct(p) { *(p) = NULL; }

-#define CpuSet_Zero(p) { *(p) = 0; }

-#define CpuSet_Set(p, cpu) { *(p) |= ((DWORD_PTR)1 << (cpu)); }

-typedef struct _CThread

-#define Thread_Construct(p) { (p)->_tid = 0; (p)->_created = 0; }

-#define Thread_WasCreated(p) ((p)->_created != 0)

-#ifdef _7ZIP_AFFINITY_SUPPORTED

-#define CpuSet_Zero(p) CPU_ZERO(p)

-#define CpuSet_Set(p, cpu) CPU_SET(cpu, p)

-#define CpuSet_IsSet(p, cpu) CPU_ISSET(cpu, p)

-#define CpuSet_Zero(p) { *(p) = 0; }

-#define CpuSet_Set(p, cpu) { *(p) |= ((UInt64)1 << (cpu)); }

-#define CpuSet_IsSet(p, cpu) ((*(p) & ((UInt64)1 << (cpu))) != 0)

-#define THREAD_FUNC_CALL_TYPE MY_STD_CALL

-LZMA SDK 21.07