From b80be10c4dc2c1f27917cd68a2c4c47819ee5fe5 Mon Sep 17 00:00:00 2001 From: Amos <48657826+Mauler125@users.noreply.github.com> Date: Thu, 6 Jan 2022 15:08:39 +0100 Subject: [PATCH] Compile LZHAM with the solution. Fix missing detours files for sdklauncher --- r5dev/core/stdafx.h | 7 +- r5dev/dedicated.vcxproj | 115 +- r5dev/dedicated.vcxproj.filters | 168 +- r5dev/r5dev.vcxproj | 115 +- r5dev/r5dev.vcxproj.filters | 168 +- r5dev/sdklauncher.vcxproj | 23 +- r5dev/sdklauncher.vcxproj.filters | 27 + r5dev/thirdparty/detours/src/creatwth.cpp | 1783 +++++++++++++++ r5dev/thirdparty/detours/src/uimports.cpp | 335 +++ r5dev/thirdparty/lzham/include/lzham_assert.h | 40 + .../thirdparty/lzham/include/lzham_checksum.h | 13 + r5dev/thirdparty/lzham/include/lzham_config.h | 23 + r5dev/thirdparty/lzham/include/lzham_core.h | 170 ++ .../thirdparty/lzham/include/lzham_helpers.h | 54 + .../lzham/include/lzham_huffman_codes.h | 14 + r5dev/thirdparty/lzham/include/lzham_lzbase.h | 45 + .../lzham/include/lzham_match_accel.h | 146 ++ r5dev/thirdparty/lzham/include/lzham_math.h | 113 + r5dev/thirdparty/lzham/include/lzham_mem.h | 112 + .../lzham/include/lzham_null_threading.h | 97 + .../thirdparty/lzham/include/lzham_platform.h | 284 +++ .../lzham/include/lzham_polar_codes.h | 14 + .../lzham/include/lzham_prefix_coding.h | 144 ++ .../lzham/include/lzham_pthreads_threading.h | 383 ++++ .../lzham/include/lzham_symbol_codec.h | 556 +++++ .../lzham/include/lzham_threading.h | 12 + r5dev/thirdparty/lzham/include/lzham_timer.h | 99 + r5dev/thirdparty/lzham/include/lzham_traits.h | 137 ++ r5dev/thirdparty/lzham/include/lzham_types.h | 74 + r5dev/thirdparty/lzham/include/lzham_utils.h | 58 + r5dev/thirdparty/lzham/include/lzham_vector.h | 588 +++++ .../lzham/include/lzham_win32_threading.h | 368 +++ r5dev/thirdparty/lzham/libs/lzhamcomp_x64.lib | Bin 556410 -> 0 bytes .../thirdparty/lzham/libs/lzhamcomp_x64D.lib | Bin 824648 -> 0 bytes .../thirdparty/lzham/libs/lzhamdecomp_x64.lib | Bin 599642 -> 0 bytes .../lzham/libs/lzhamdecomp_x64D.lib | Bin 588216 -> 0 bytes r5dev/thirdparty/lzham/libs/lzhamlib_x64.lib | Bin 26576 -> 0 bytes r5dev/thirdparty/lzham/libs/lzhamlib_x64D.lib | Bin 24960 -> 0 bytes r5dev/thirdparty/lzham/lzham_api.cpp | 179 ++ r5dev/thirdparty/lzham/lzham_assert.cpp | 66 + r5dev/thirdparty/lzham/lzham_checksum.cpp | 73 + .../thirdparty/lzham/lzham_huffman_codes.cpp | 390 ++++ r5dev/thirdparty/lzham/lzham_lzbase.cpp | 71 + r5dev/thirdparty/lzham/lzham_match_accel.cpp | 562 +++++ r5dev/thirdparty/lzham/lzham_mem.cpp | 272 +++ r5dev/thirdparty/lzham/lzham_platform.cpp | 146 ++ r5dev/thirdparty/lzham/lzham_polar_codes.cpp | 414 ++++ .../thirdparty/lzham/lzham_prefix_coding.cpp | 350 +++ .../lzham/lzham_pthreads_threading.cpp | 227 ++ r5dev/thirdparty/lzham/lzham_symbol_codec.cpp | 1453 ++++++++++++ r5dev/thirdparty/lzham/lzham_timer.cpp | 147 ++ r5dev/thirdparty/lzham/lzham_vector.cpp | 74 + .../lzham/lzham_win32_threading.cpp | 220 ++ r5dev/thirdparty/lzham/lzhamcomp/lzham_comp.h | 38 + .../lzham/lzhamcomp/lzham_lzcomp.cpp | 611 +++++ .../lzham/lzhamcomp/lzham_lzcomp_internal.cpp | 1972 +++++++++++++++++ .../lzham/lzhamcomp/lzham_lzcomp_internal.h | 481 ++++ .../lzham/lzhamcomp/lzham_lzcomp_state.cpp | 1463 ++++++++++++ .../lzham/lzhamdecomp/lzham_decomp.h | 37 + .../lzham/lzhamdecomp/lzham_lzdecomp.cpp | 1590 +++++++++++++ .../lzham/lzhamdecomp/lzham_lzdecompbase.cpp | 46 + .../lzham/lzhamdecomp/lzham_lzdecompbase.h | 90 + 62 files changed, 17238 insertions(+), 19 deletions(-) create mode 100644 r5dev/thirdparty/detours/src/creatwth.cpp create mode 100644 r5dev/thirdparty/detours/src/uimports.cpp create mode 100644 r5dev/thirdparty/lzham/include/lzham_assert.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_checksum.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_config.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_core.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_helpers.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_huffman_codes.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_lzbase.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_match_accel.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_math.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_mem.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_null_threading.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_platform.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_polar_codes.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_prefix_coding.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_pthreads_threading.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_symbol_codec.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_threading.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_timer.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_traits.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_types.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_utils.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_vector.h create mode 100644 r5dev/thirdparty/lzham/include/lzham_win32_threading.h delete mode 100644 r5dev/thirdparty/lzham/libs/lzhamcomp_x64.lib delete mode 100644 r5dev/thirdparty/lzham/libs/lzhamcomp_x64D.lib delete mode 100644 r5dev/thirdparty/lzham/libs/lzhamdecomp_x64.lib delete mode 100644 r5dev/thirdparty/lzham/libs/lzhamdecomp_x64D.lib delete mode 100644 r5dev/thirdparty/lzham/libs/lzhamlib_x64.lib delete mode 100644 r5dev/thirdparty/lzham/libs/lzhamlib_x64D.lib create mode 100644 r5dev/thirdparty/lzham/lzham_api.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_assert.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_checksum.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_huffman_codes.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_lzbase.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_match_accel.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_mem.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_platform.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_polar_codes.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_prefix_coding.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_pthreads_threading.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_symbol_codec.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_timer.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_vector.cpp create mode 100644 r5dev/thirdparty/lzham/lzham_win32_threading.cpp create mode 100644 r5dev/thirdparty/lzham/lzhamcomp/lzham_comp.h create mode 100644 r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp.cpp create mode 100644 r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.cpp create mode 100644 r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.h create mode 100644 r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_state.cpp create mode 100644 r5dev/thirdparty/lzham/lzhamdecomp/lzham_decomp.h create mode 100644 r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecomp.cpp create mode 100644 r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.cpp create mode 100644 r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.h diff --git a/r5dev/core/stdafx.h b/r5dev/core/stdafx.h index 1637be75..ee52eac0 100644 --- a/r5dev/core/stdafx.h +++ b/r5dev/core/stdafx.h @@ -36,6 +36,11 @@ #include "thirdparty/imgui/include/imgui_impl_win32.h" #endif // !DEDICATED +#if !defined(SDKLAUNCHER) +#include "thirdparty/lzham/include/lzham_types.h" +#include "thirdparty/lzham/include/lzham.h" +#endif // !SDKLAUNCHER + #include "thirdparty/spdlog/include/spdlog.h" #include "thirdparty/spdlog/include/sinks/basic_file_sink.h" #include "thirdparty/spdlog/include/sinks/stdout_sinks.h" @@ -57,4 +62,4 @@ namespace MODULE g_mRadAudioDecoderDll = MODULE("binkawin64.dll"); MODULE g_mRadAudioSystemDll = MODULE("mileswin64.dll"); } -#endif // SDKLAUNCHER +#endif // !SDKLAUNCHER diff --git a/r5dev/dedicated.vcxproj b/r5dev/dedicated.vcxproj index 30414412..017a8898 100644 --- a/r5dev/dedicated.vcxproj +++ b/r5dev/dedicated.vcxproj @@ -135,7 +135,7 @@ Console true - lzhamlib_x64D.lib;lzhamcomp_x64D.lib;lzhamdecomp_x64D.lib;d3d11.lib;bcrypt.lib;%(AdditionalDependencies) + d3d11.lib;bcrypt.lib;%(AdditionalDependencies) del "..\..\..\$(ProjectName)" && copy /Y "$(TargetPath)" "..\..\..\ @@ -162,7 +162,7 @@ true true true - lzhamlib_x64.lib;lzhamcomp_x64.lib;lzhamdecomp_x64.lib;d3d11.lib;bcrypt.lib;%(AdditionalDependencies) + d3d11.lib;bcrypt.lib;%(AdditionalDependencies) del "..\..\..\$(ProjectName)" && copy /Y "$(TargetPath)" "..\..\..\ @@ -215,7 +215,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -360,6 +387,10 @@ + + NotUsing + NotUsing + NotUsing NotUsing @@ -372,6 +403,86 @@ NotUsing NotUsing + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + diff --git a/r5dev/dedicated.vcxproj.filters b/r5dev/dedicated.vcxproj.filters index 3bee9887..c110b5a1 100644 --- a/r5dev/dedicated.vcxproj.filters +++ b/r5dev/dedicated.vcxproj.filters @@ -97,6 +97,18 @@ {8288ba1a-7609-42ef-af3b-850727635a99} + + {8736d047-b4af-4c17-99ee-454cc96ec1ba} + + + {e84ad150-2358-4146-971a-02c5f045437c} + + + {eb98cd2b-4508-43a0-95e1-feacc7c83a8d} + + + {463e0739-1e5f-47a0-94d1-6cf5b6bf3ea6} + @@ -540,12 +552,6 @@ sdk\public\include - - thirdparty\lzham\include - - - thirdparty\lzham\include - sdk\mathlib @@ -564,6 +570,93 @@ windows + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\lzhamcomp\include + + + thirdparty\lzham\lzhamcomp\include + + + thirdparty\lzham\lzhamdecomp\include + + + thirdparty\lzham\lzhamdecomp\include + @@ -701,6 +794,69 @@ thirdparty\detours + + thirdparty\detours + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham\lzhamcomp + + + thirdparty\lzham\lzhamcomp + + + thirdparty\lzham\lzhamcomp + + + thirdparty\lzham\lzhamdecomp + + + thirdparty\lzham\lzhamdecomp + diff --git a/r5dev/r5dev.vcxproj b/r5dev/r5dev.vcxproj index dcab8624..8d942be3 100644 --- a/r5dev/r5dev.vcxproj +++ b/r5dev/r5dev.vcxproj @@ -58,6 +58,10 @@ + + NotUsing + NotUsing + NotUsing NotUsing @@ -106,6 +110,86 @@ NotUsing NotUsing + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + @@ -192,7 +276,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -452,7 +563,7 @@ true false r5dev.def - lzhamlib_x64D.lib;lzhamcomp_x64D.lib;lzhamdecomp_x64D.lib;d3d11.lib;bcrypt.lib;%(AdditionalDependencies) + d3d11.lib;bcrypt.lib;%(AdditionalDependencies) copy /Y "$(TargetPath)" "..\..\..\bin\$(TargetFileName)" @@ -488,7 +599,7 @@ true false r5dev.def - lzhamlib_x64.lib;lzhamcomp_x64.lib;lzhamdecomp_x64.lib;d3d11.lib;bcrypt.lib;%(AdditionalDependencies) + d3d11.lib;bcrypt.lib;%(AdditionalDependencies) copy /Y "$(TargetPath)" "..\..\..\$(TargetFileName)" && del "..\..\..\r5apexsdkd64.dll" && rename "..\..\..\$(TargetFileName)" "r5apexsdkd64.dll" diff --git a/r5dev/r5dev.vcxproj.filters b/r5dev/r5dev.vcxproj.filters index 4bd5cd1c..818da70f 100644 --- a/r5dev/r5dev.vcxproj.filters +++ b/r5dev/r5dev.vcxproj.filters @@ -127,6 +127,18 @@ {f52dfb17-f5bd-4258-91a2-500587bee708} + + {f450ee50-7010-49e2-9f91-05a74fcb6a8b} + + + {11645361-fd70-462f-ab8b-8a78283a5fc7} + + + {785353c2-6417-4213-b55f-3007a0b79801} + + + {5beb12b5-0422-4337-9be6-2e6c0a05a69b} + @@ -321,6 +333,69 @@ thirdparty\detours + + thirdparty\detours + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham + + + thirdparty\lzham\lzhamcomp + + + thirdparty\lzham\lzhamcomp + + + thirdparty\lzham\lzhamcomp + + + thirdparty\lzham\lzhamdecomp + + + thirdparty\lzham\lzhamdecomp + @@ -836,12 +911,6 @@ sdk\public\include - - thirdparty\lzham\include - - - thirdparty\lzham\include - sdk\mathlib @@ -872,6 +941,93 @@ sdk\milessdk + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\include + + + thirdparty\lzham\lzhamcomp\include + + + thirdparty\lzham\lzhamcomp\include + + + thirdparty\lzham\lzhamdecomp\include + + + thirdparty\lzham\lzhamdecomp\include + diff --git a/r5dev/sdklauncher.vcxproj b/r5dev/sdklauncher.vcxproj index 99e6e9fb..d5260590 100644 --- a/r5dev/sdklauncher.vcxproj +++ b/r5dev/sdklauncher.vcxproj @@ -140,7 +140,7 @@ Console true - detours.lib;%(AdditionalDependencies) + %(AdditionalDependencies) del "..\..\..\r5reloaded.exe" && copy /Y "$(TargetPath)" "..\..\..\$(TargetFileName)" @@ -174,7 +174,7 @@ true true true - detours.lib;%(AdditionalDependencies) + %(AdditionalDependencies) del "..\..\..\r5reloaded.exe" && copy /Y "$(TargetPath)" "..\..\..\$(TargetFileName)" @@ -186,6 +186,22 @@ Create + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + + + NotUsing + NotUsing + @@ -198,6 +214,9 @@ + + + diff --git a/r5dev/sdklauncher.vcxproj.filters b/r5dev/sdklauncher.vcxproj.filters index 5a7f2de0..70394cc2 100644 --- a/r5dev/sdklauncher.vcxproj.filters +++ b/r5dev/sdklauncher.vcxproj.filters @@ -13,6 +13,12 @@ {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + {82b18787-373d-42ce-8d8d-1e3adba8d3a0} + + + {dc968871-7ca2-452b-a5b1-350a12dd54aa} + @@ -21,6 +27,18 @@ Source Files + + Detours Files + + + Detours Files + + + Detours Files + + + Detours Files + @@ -37,6 +55,15 @@ Header Files + + Detours Files\include + + + Detours Files\include + + + Detours Files\include + diff --git a/r5dev/thirdparty/detours/src/creatwth.cpp b/r5dev/thirdparty/detours/src/creatwth.cpp new file mode 100644 index 00000000..f6720d7b --- /dev/null +++ b/r5dev/thirdparty/detours/src/creatwth.cpp @@ -0,0 +1,1783 @@ +////////////////////////////////////////////////////////////////////////////// +// +// Create a process with a DLL (creatwth.cpp of detours.lib) +// +// Microsoft Research Detours Package, Version 4.0.1 +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// + +// #define DETOUR_DEBUG 1 +#define DETOURS_INTERNAL +#include "../include/detours.h" +#include + +#if DETOURS_VERSION != 0x4c0c1 // 0xMAJORcMINORcPATCH +#error detours.h version mismatch +#endif + +#define IMPORT_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT] +#define BOUND_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT] +#define CLR_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR] +#define IAT_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT] + +////////////////////////////////////////////////////////////////////////////// +// +const GUID DETOUR_EXE_HELPER_GUID = { /* ea0251b9-5cde-41b5-98d0-2af4a26b0fee */ + 0xea0251b9, 0x5cde, 0x41b5, + { 0x98, 0xd0, 0x2a, 0xf4, 0xa2, 0x6b, 0x0f, 0xee }}; + +////////////////////////////////////////////////////////////////////////////// +// +// Enumerate through modules in the target process. +// +static PVOID LoadNtHeaderFromProcess(_In_ HANDLE hProcess, + _In_ HMODULE hModule, + _Out_ PIMAGE_NT_HEADERS32 pNtHeader) +{ + ZeroMemory(pNtHeader, sizeof(*pNtHeader)); + PBYTE pbModule = (PBYTE)hModule; + + if (pbModule == NULL) { + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } + + MEMORY_BASIC_INFORMATION mbi; + ZeroMemory(&mbi, sizeof(mbi)); + + if (VirtualQueryEx(hProcess, hModule, &mbi, sizeof(mbi)) == 0) { + return NULL; + } + + IMAGE_DOS_HEADER idh; + if (!ReadProcessMemory(hProcess, pbModule, &idh, sizeof(idh), NULL)) { + DETOUR_TRACE(("ReadProcessMemory(idh@%p..%p) failed: %lu\n", + pbModule, pbModule + sizeof(idh), GetLastError())); + return NULL; + } + + if (idh.e_magic != IMAGE_DOS_SIGNATURE || + (DWORD)idh.e_lfanew > mbi.RegionSize || + (DWORD)idh.e_lfanew < sizeof(idh)) { + + SetLastError(ERROR_BAD_EXE_FORMAT); + return NULL; + } + + if (!ReadProcessMemory(hProcess, pbModule + idh.e_lfanew, + pNtHeader, sizeof(*pNtHeader), NULL)) { + DETOUR_TRACE(("ReadProcessMemory(inh@%p..%p:%p) failed: %lu\n", + pbModule + idh.e_lfanew, + pbModule + idh.e_lfanew + sizeof(*pNtHeader), + pbModule, + GetLastError())); + return NULL; + } + + if (pNtHeader->Signature != IMAGE_NT_SIGNATURE) { + SetLastError(ERROR_BAD_EXE_FORMAT); + return NULL; + } + + return pbModule + idh.e_lfanew; +} + +static HMODULE EnumerateModulesInProcess(_In_ HANDLE hProcess, + _In_opt_ HMODULE hModuleLast, + _Out_ PIMAGE_NT_HEADERS32 pNtHeader, + _Out_opt_ PVOID *pRemoteNtHeader) +{ + ZeroMemory(pNtHeader, sizeof(*pNtHeader)); + if (pRemoteNtHeader) { + *pRemoteNtHeader = NULL; + } + + PBYTE pbLast = (PBYTE)hModuleLast + MM_ALLOCATION_GRANULARITY; + + MEMORY_BASIC_INFORMATION mbi; + ZeroMemory(&mbi, sizeof(mbi)); + + // Find the next memory region that contains a mapped PE image. + // + + for (;; pbLast = (PBYTE)mbi.BaseAddress + mbi.RegionSize) { + if (VirtualQueryEx(hProcess, (PVOID)pbLast, &mbi, sizeof(mbi)) == 0) { + break; + } + + // Usermode address space has such an unaligned region size always at the + // end and only at the end. + // + if ((mbi.RegionSize & 0xfff) == 0xfff) { + break; + } + if (((PBYTE)mbi.BaseAddress + mbi.RegionSize) < pbLast) { + break; + } + + // Skip uncommitted regions and guard pages. + // + if ((mbi.State != MEM_COMMIT) || + ((mbi.Protect & 0xff) == PAGE_NOACCESS) || + (mbi.Protect & PAGE_GUARD)) { + continue; + } + + PVOID remoteHeader + = LoadNtHeaderFromProcess(hProcess, (HMODULE)pbLast, pNtHeader); + if (remoteHeader) { + if (pRemoteNtHeader) { + *pRemoteNtHeader = remoteHeader; + } + + return (HMODULE)pbLast; + } + } + return NULL; +} + +////////////////////////////////////////////////////////////////////////////// +// +// Find payloads in target process. +// + +static PVOID FindDetourSectionInRemoteModule(_In_ HANDLE hProcess, + _In_ HMODULE hModule, + _In_ const IMAGE_NT_HEADERS32 *pNtHeader, + _In_ PVOID pRemoteNtHeader) +{ + if (pNtHeader->FileHeader.SizeOfOptionalHeader == 0) { + SetLastError(ERROR_EXE_MARKED_INVALID); + return NULL; + } + + PIMAGE_SECTION_HEADER pRemoteSectionHeaders + = (PIMAGE_SECTION_HEADER)((PBYTE)pRemoteNtHeader + + sizeof(pNtHeader->Signature) + + sizeof(pNtHeader->FileHeader) + + pNtHeader->FileHeader.SizeOfOptionalHeader); + + IMAGE_SECTION_HEADER header; + for (DWORD n = 0; n < pNtHeader->FileHeader.NumberOfSections; ++n) { + if (!ReadProcessMemory(hProcess, pRemoteSectionHeaders + n, &header, sizeof(header), NULL)) { + DETOUR_TRACE(("ReadProcessMemory(ish@%p..%p) failed: %lu\n", + pRemoteSectionHeaders + n, + (PBYTE)(pRemoteSectionHeaders + n) + sizeof(header), + GetLastError())); + + return NULL; + } + + if (strcmp((PCHAR)header.Name, ".detour") == 0) { + if (header.VirtualAddress == 0 || + header.SizeOfRawData == 0) { + + break; + } + + SetLastError(NO_ERROR); + return (PBYTE)hModule + header.VirtualAddress; + } + } + + SetLastError(ERROR_EXE_MARKED_INVALID); + return NULL; +} + +static PVOID FindPayloadInRemoteDetourSection(_In_ HANDLE hProcess, + _In_ REFGUID rguid, + _Out_opt_ DWORD *pcbData, + _In_ PVOID pvRemoteDetoursSection) +{ + if (pcbData) { + *pcbData = 0; + } + + PBYTE pbData = (PBYTE)pvRemoteDetoursSection; + + DETOUR_SECTION_HEADER header; + if (!ReadProcessMemory(hProcess, pbData, &header, sizeof(header), NULL)) { + DETOUR_TRACE(("ReadProcessMemory(dsh@%p..%p) failed: %lu\n", + pbData, + pbData + sizeof(header), + GetLastError())); + return NULL; + } + + if (header.cbHeaderSize < sizeof(DETOUR_SECTION_HEADER) || + header.nSignature != DETOUR_SECTION_HEADER_SIGNATURE) { + SetLastError(ERROR_EXE_MARKED_INVALID); + return NULL; + } + + if (header.nDataOffset == 0) { + header.nDataOffset = header.cbHeaderSize; + } + + for (PVOID pvSection = pbData + header.nDataOffset; pvSection < pbData + header.cbDataSize;) { + DETOUR_SECTION_RECORD section; + if (!ReadProcessMemory(hProcess, pvSection, §ion, sizeof(section), NULL)) { + DETOUR_TRACE(("ReadProcessMemory(dsr@%p..%p) failed: %lu\n", + pvSection, + (PBYTE)pvSection + sizeof(section), + GetLastError())); + return NULL; + } + + if (DetourAreSameGuid(section.guid, rguid)) { + if (pcbData) { + *pcbData = section.cbBytes - sizeof(section); + } + SetLastError(NO_ERROR); + return (DETOUR_SECTION_RECORD *)pvSection + 1; + } + + pvSection = (PBYTE)pvSection + section.cbBytes; + } + + return NULL; +} + +_Success_(return != NULL) +PVOID WINAPI DetourFindRemotePayload(_In_ HANDLE hProcess, + _In_ REFGUID rguid, + _Out_opt_ DWORD *pcbData) +{ + if (hProcess == NULL) { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } + + IMAGE_NT_HEADERS32 header; + PVOID pvRemoteHeader; + for (HMODULE hMod = NULL; (hMod = EnumerateModulesInProcess(hProcess, hMod, &header, &pvRemoteHeader)) != NULL;) { + PVOID pvData = FindDetourSectionInRemoteModule(hProcess, hMod, &header, pvRemoteHeader); + if (pvData != NULL) { + pvData = FindPayloadInRemoteDetourSection(hProcess, rguid, pcbData, pvData); + if (pvData != NULL) { + return pvData; + } + } + } + + SetLastError(ERROR_MOD_NOT_FOUND); + return NULL; +} + +////////////////////////////////////////////////////////////////////////////// +// +// Find a region of memory in which we can create a replacement import table. +// +static PBYTE FindAndAllocateNearBase(HANDLE hProcess, PBYTE pbModule, PBYTE pbBase, DWORD cbAlloc) +{ + MEMORY_BASIC_INFORMATION mbi; + ZeroMemory(&mbi, sizeof(mbi)); + + PBYTE pbLast = pbBase; + for (;; pbLast = (PBYTE)mbi.BaseAddress + mbi.RegionSize) { + + ZeroMemory(&mbi, sizeof(mbi)); + if (VirtualQueryEx(hProcess, (PVOID)pbLast, &mbi, sizeof(mbi)) == 0) { + if (GetLastError() == ERROR_INVALID_PARAMETER) { + break; + } + DETOUR_TRACE(("VirtualQueryEx(%p) failed: %lu\n", + pbLast, GetLastError())); + break; + } + // Usermode address space has such an unaligned region size always at the + // end and only at the end. + // + if ((mbi.RegionSize & 0xfff) == 0xfff) { + break; + } + + // Skip anything other than a pure free region. + // + if (mbi.State != MEM_FREE) { + continue; + } + + // Use the max of mbi.BaseAddress and pbBase, in case mbi.BaseAddress < pbBase. + PBYTE pbAddress = (PBYTE)mbi.BaseAddress > pbBase ? (PBYTE)mbi.BaseAddress : pbBase; + + // Round pbAddress up to the nearest MM allocation boundary. + const DWORD_PTR mmGranularityMinusOne = (DWORD_PTR)(MM_ALLOCATION_GRANULARITY -1); + pbAddress = (PBYTE)(((DWORD_PTR)pbAddress + mmGranularityMinusOne) & ~mmGranularityMinusOne); + +#ifdef _WIN64 + // The offset from pbModule to any replacement import must fit into 32 bits. + // For simplicity, we check that the offset to the last byte fits into 32 bits, + // instead of the largest offset we'll actually use. The values are very similar. + const size_t GB4 = ((((size_t)1) << 32) - 1); + if ((size_t)(pbAddress + cbAlloc - 1 - pbModule) > GB4) { + DETOUR_TRACE(("FindAndAllocateNearBase(1) failing due to distance >4GB %p\n", pbAddress)); + return NULL; + } +#else + UNREFERENCED_PARAMETER(pbModule); +#endif + + DETOUR_TRACE(("Free region %p..%p\n", + mbi.BaseAddress, + (PBYTE)mbi.BaseAddress + mbi.RegionSize)); + + for (; pbAddress < (PBYTE)mbi.BaseAddress + mbi.RegionSize; pbAddress += MM_ALLOCATION_GRANULARITY) { + PBYTE pbAlloc = (PBYTE)VirtualAllocEx(hProcess, pbAddress, cbAlloc, + MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); + if (pbAlloc == NULL) { + DETOUR_TRACE(("VirtualAllocEx(%p) failed: %lu\n", pbAddress, GetLastError())); + continue; + } +#ifdef _WIN64 + // The offset from pbModule to any replacement import must fit into 32 bits. + if ((size_t)(pbAddress + cbAlloc - 1 - pbModule) > GB4) { + DETOUR_TRACE(("FindAndAllocateNearBase(2) failing due to distance >4GB %p\n", pbAddress)); + return NULL; + } +#endif + DETOUR_TRACE(("[%p..%p] Allocated for import table.\n", + pbAlloc, pbAlloc + cbAlloc)); + return pbAlloc; + } + } + return NULL; +} + +static inline DWORD PadToDword(DWORD dw) +{ + return (dw + 3) & ~3u; +} + +static inline DWORD PadToDwordPtr(DWORD dw) +{ + return (dw + 7) & ~7u; +} + +static inline HRESULT ReplaceOptionalSizeA(_Inout_z_count_(cchDest) LPSTR pszDest, + _In_ size_t cchDest, + _In_z_ LPCSTR pszSize) +{ + if (cchDest == 0 || pszDest == NULL || pszSize == NULL || + pszSize[0] == '\0' || pszSize[1] == '\0' || pszSize[2] != '\0') { + + // can not write into empty buffer or with string other than two chars. + return ERROR_INVALID_PARAMETER; + } + + for (; cchDest >= 2; cchDest--, pszDest++) { + if (pszDest[0] == '?' && pszDest[1] == '?') { + pszDest[0] = pszSize[0]; + pszDest[1] = pszSize[1]; + break; + } + } + + return S_OK; +} + +static BOOL RecordExeRestore(HANDLE hProcess, HMODULE hModule, DETOUR_EXE_RESTORE& der) +{ + // Save the various headers for DetourRestoreAfterWith. + ZeroMemory(&der, sizeof(der)); + der.cb = sizeof(der); + + der.pidh = (PBYTE)hModule; + der.cbidh = sizeof(der.idh); + if (!ReadProcessMemory(hProcess, der.pidh, &der.idh, sizeof(der.idh), NULL)) { + DETOUR_TRACE(("ReadProcessMemory(idh@%p..%p) failed: %lu\n", + der.pidh, der.pidh + der.cbidh, GetLastError())); + return FALSE; + } + DETOUR_TRACE(("IDH: %p..%p\n", der.pidh, der.pidh + der.cbidh)); + + // We read the NT header in two passes to get the full size. + // First we read just the Signature and FileHeader. + der.pinh = der.pidh + der.idh.e_lfanew; + der.cbinh = FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader); + if (!ReadProcessMemory(hProcess, der.pinh, &der.inh, der.cbinh, NULL)) { + DETOUR_TRACE(("ReadProcessMemory(inh@%p..%p) failed: %lu\n", + der.pinh, der.pinh + der.cbinh, GetLastError())); + return FALSE; + } + + // Second we read the OptionalHeader and Section headers. + der.cbinh = (FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + + der.inh.FileHeader.SizeOfOptionalHeader + + der.inh.FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER)); + + if (der.cbinh > sizeof(der.raw)) { + return FALSE; + } + + if (!ReadProcessMemory(hProcess, der.pinh, &der.inh, der.cbinh, NULL)) { + DETOUR_TRACE(("ReadProcessMemory(inh@%p..%p) failed: %lu\n", + der.pinh, der.pinh + der.cbinh, GetLastError())); + return FALSE; + } + DETOUR_TRACE(("INH: %p..%p\n", der.pinh, der.pinh + der.cbinh)); + + // Third, we read the CLR header + + if (der.inh.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) { + if (der.inh32.CLR_DIRECTORY.VirtualAddress != 0 && + der.inh32.CLR_DIRECTORY.Size != 0) { + + DETOUR_TRACE(("CLR32.VirtAddr=%08lx, CLR.Size=%lu\n", + der.inh32.CLR_DIRECTORY.VirtualAddress, + der.inh32.CLR_DIRECTORY.Size)); + + der.pclr = ((PBYTE)hModule) + der.inh32.CLR_DIRECTORY.VirtualAddress; + } + } + else if (der.inh.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) { + if (der.inh64.CLR_DIRECTORY.VirtualAddress != 0 && + der.inh64.CLR_DIRECTORY.Size != 0) { + + DETOUR_TRACE(("CLR64.VirtAddr=%08lx, CLR.Size=%lu\n", + der.inh64.CLR_DIRECTORY.VirtualAddress, + der.inh64.CLR_DIRECTORY.Size)); + + der.pclr = ((PBYTE)hModule) + der.inh64.CLR_DIRECTORY.VirtualAddress; + } + } + + if (der.pclr != 0) { + der.cbclr = sizeof(der.clr); + if (!ReadProcessMemory(hProcess, der.pclr, &der.clr, der.cbclr, NULL)) { + DETOUR_TRACE(("ReadProcessMemory(clr@%p..%p) failed: %lu\n", + der.pclr, der.pclr + der.cbclr, GetLastError())); + return FALSE; + } + DETOUR_TRACE(("CLR: %p..%p\n", der.pclr, der.pclr + der.cbclr)); + } + + return TRUE; +} + +////////////////////////////////////////////////////////////////////////////// +// +#if DETOURS_32BIT +#define DWORD_XX DWORD32 +#define IMAGE_NT_HEADERS_XX IMAGE_NT_HEADERS32 +#define IMAGE_NT_OPTIONAL_HDR_MAGIC_XX IMAGE_NT_OPTIONAL_HDR32_MAGIC +#define IMAGE_ORDINAL_FLAG_XX IMAGE_ORDINAL_FLAG32 +#define IMAGE_THUNK_DATAXX IMAGE_THUNK_DATA32 +#define UPDATE_IMPORTS_XX UpdateImports32 +#define DETOURS_BITS_XX 32 +#include "uimports.cpp" +#undef DETOUR_EXE_RESTORE_FIELD_XX +#undef DWORD_XX +#undef IMAGE_NT_HEADERS_XX +#undef IMAGE_NT_OPTIONAL_HDR_MAGIC_XX +#undef IMAGE_ORDINAL_FLAG_XX +#undef UPDATE_IMPORTS_XX +#endif // DETOURS_32BIT + +#if DETOURS_64BIT +#define DWORD_XX DWORD64 +#define IMAGE_NT_HEADERS_XX IMAGE_NT_HEADERS64 +#define IMAGE_NT_OPTIONAL_HDR_MAGIC_XX IMAGE_NT_OPTIONAL_HDR64_MAGIC +#define IMAGE_ORDINAL_FLAG_XX IMAGE_ORDINAL_FLAG64 +#define IMAGE_THUNK_DATAXX IMAGE_THUNK_DATA64 +#define UPDATE_IMPORTS_XX UpdateImports64 +#define DETOURS_BITS_XX 64 +#include "uimports.cpp" +#undef DETOUR_EXE_RESTORE_FIELD_XX +#undef DWORD_XX +#undef IMAGE_NT_HEADERS_XX +#undef IMAGE_NT_OPTIONAL_HDR_MAGIC_XX +#undef IMAGE_ORDINAL_FLAG_XX +#undef UPDATE_IMPORTS_XX +#endif // DETOURS_64BIT + +////////////////////////////////////////////////////////////////////////////// +// +#if DETOURS_64BIT + +C_ASSERT(sizeof(IMAGE_NT_HEADERS64) == sizeof(IMAGE_NT_HEADERS32) + 16); + +static BOOL UpdateFrom32To64(HANDLE hProcess, HMODULE hModule, WORD machine, + DETOUR_EXE_RESTORE& der) +{ + IMAGE_DOS_HEADER idh; + IMAGE_NT_HEADERS32 inh32; + IMAGE_NT_HEADERS64 inh64; + IMAGE_SECTION_HEADER sects[32]; + PBYTE pbModule = (PBYTE)hModule; + DWORD n; + + ZeroMemory(&inh32, sizeof(inh32)); + ZeroMemory(&inh64, sizeof(inh64)); + ZeroMemory(sects, sizeof(sects)); + + DETOUR_TRACE(("UpdateFrom32To64(%04x)\n", machine)); + //////////////////////////////////////////////////////// Read old headers. + // + if (!ReadProcessMemory(hProcess, pbModule, &idh, sizeof(idh), NULL)) { + DETOUR_TRACE(("ReadProcessMemory(idh@%p..%p) failed: %lu\n", + pbModule, pbModule + sizeof(idh), GetLastError())); + return FALSE; + } + DETOUR_TRACE(("ReadProcessMemory(idh@%p..%p)\n", + pbModule, pbModule + sizeof(idh))); + + PBYTE pnh = pbModule + idh.e_lfanew; + if (!ReadProcessMemory(hProcess, pnh, &inh32, sizeof(inh32), NULL)) { + DETOUR_TRACE(("ReadProcessMemory(inh@%p..%p) failed: %lu\n", + pnh, pnh + sizeof(inh32), GetLastError())); + return FALSE; + } + DETOUR_TRACE(("ReadProcessMemory(inh@%p..%p)\n", pnh, pnh + sizeof(inh32))); + + if (inh32.FileHeader.NumberOfSections > (sizeof(sects)/sizeof(sects[0]))) { + return FALSE; + } + + PBYTE psects = pnh + + FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + + inh32.FileHeader.SizeOfOptionalHeader; + ULONG cb = inh32.FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER); + if (!ReadProcessMemory(hProcess, psects, §s, cb, NULL)) { + DETOUR_TRACE(("ReadProcessMemory(ish@%p..%p) failed: %lu\n", + psects, psects + cb, GetLastError())); + return FALSE; + } + DETOUR_TRACE(("ReadProcessMemory(ish@%p..%p)\n", psects, psects + cb)); + + ////////////////////////////////////////////////////////// Convert header. + // + inh64.Signature = inh32.Signature; + inh64.FileHeader = inh32.FileHeader; + inh64.FileHeader.Machine = machine; + inh64.FileHeader.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER64); + + inh64.OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC; + inh64.OptionalHeader.MajorLinkerVersion = inh32.OptionalHeader.MajorLinkerVersion; + inh64.OptionalHeader.MinorLinkerVersion = inh32.OptionalHeader.MinorLinkerVersion; + inh64.OptionalHeader.SizeOfCode = inh32.OptionalHeader.SizeOfCode; + inh64.OptionalHeader.SizeOfInitializedData = inh32.OptionalHeader.SizeOfInitializedData; + inh64.OptionalHeader.SizeOfUninitializedData = inh32.OptionalHeader.SizeOfUninitializedData; + inh64.OptionalHeader.AddressOfEntryPoint = inh32.OptionalHeader.AddressOfEntryPoint; + inh64.OptionalHeader.BaseOfCode = inh32.OptionalHeader.BaseOfCode; + inh64.OptionalHeader.ImageBase = inh32.OptionalHeader.ImageBase; + inh64.OptionalHeader.SectionAlignment = inh32.OptionalHeader.SectionAlignment; + inh64.OptionalHeader.FileAlignment = inh32.OptionalHeader.FileAlignment; + inh64.OptionalHeader.MajorOperatingSystemVersion + = inh32.OptionalHeader.MajorOperatingSystemVersion; + inh64.OptionalHeader.MinorOperatingSystemVersion + = inh32.OptionalHeader.MinorOperatingSystemVersion; + inh64.OptionalHeader.MajorImageVersion = inh32.OptionalHeader.MajorImageVersion; + inh64.OptionalHeader.MinorImageVersion = inh32.OptionalHeader.MinorImageVersion; + inh64.OptionalHeader.MajorSubsystemVersion = inh32.OptionalHeader.MajorSubsystemVersion; + inh64.OptionalHeader.MinorSubsystemVersion = inh32.OptionalHeader.MinorSubsystemVersion; + inh64.OptionalHeader.Win32VersionValue = inh32.OptionalHeader.Win32VersionValue; + inh64.OptionalHeader.SizeOfImage = inh32.OptionalHeader.SizeOfImage; + inh64.OptionalHeader.SizeOfHeaders = inh32.OptionalHeader.SizeOfHeaders; + inh64.OptionalHeader.CheckSum = inh32.OptionalHeader.CheckSum; + inh64.OptionalHeader.Subsystem = inh32.OptionalHeader.Subsystem; + inh64.OptionalHeader.DllCharacteristics = inh32.OptionalHeader.DllCharacteristics; + inh64.OptionalHeader.SizeOfStackReserve = inh32.OptionalHeader.SizeOfStackReserve; + inh64.OptionalHeader.SizeOfStackCommit = inh32.OptionalHeader.SizeOfStackCommit; + inh64.OptionalHeader.SizeOfHeapReserve = inh32.OptionalHeader.SizeOfHeapReserve; + inh64.OptionalHeader.SizeOfHeapCommit = inh32.OptionalHeader.SizeOfHeapCommit; + inh64.OptionalHeader.LoaderFlags = inh32.OptionalHeader.LoaderFlags; + inh64.OptionalHeader.NumberOfRvaAndSizes = inh32.OptionalHeader.NumberOfRvaAndSizes; + for (n = 0; n < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; n++) { + inh64.OptionalHeader.DataDirectory[n] = inh32.OptionalHeader.DataDirectory[n]; + } + + /////////////////////////////////////////////////////// Write new headers. + // + DWORD dwProtect = 0; + if (!DetourVirtualProtectSameExecuteEx(hProcess, pbModule, inh64.OptionalHeader.SizeOfHeaders, + PAGE_EXECUTE_READWRITE, &dwProtect)) { + return FALSE; + } + + if (!WriteProcessMemory(hProcess, pnh, &inh64, sizeof(inh64), NULL)) { + DETOUR_TRACE(("WriteProcessMemory(inh@%p..%p) failed: %lu\n", + pnh, pnh + sizeof(inh64), GetLastError())); + return FALSE; + } + DETOUR_TRACE(("WriteProcessMemory(inh@%p..%p)\n", pnh, pnh + sizeof(inh64))); + + psects = pnh + + FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) + + inh64.FileHeader.SizeOfOptionalHeader; + cb = inh64.FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER); + if (!WriteProcessMemory(hProcess, psects, §s, cb, NULL)) { + DETOUR_TRACE(("WriteProcessMemory(ish@%p..%p) failed: %lu\n", + psects, psects + cb, GetLastError())); + return FALSE; + } + DETOUR_TRACE(("WriteProcessMemory(ish@%p..%p)\n", psects, psects + cb)); + + // Record the updated headers. + if (!RecordExeRestore(hProcess, hModule, der)) { + return FALSE; + } + + // Remove the import table. + if (der.pclr != NULL && (der.clr.Flags & COMIMAGE_FLAGS_ILONLY)) { + inh64.IMPORT_DIRECTORY.VirtualAddress = 0; + inh64.IMPORT_DIRECTORY.Size = 0; + + if (!WriteProcessMemory(hProcess, pnh, &inh64, sizeof(inh64), NULL)) { + DETOUR_TRACE(("WriteProcessMemory(inh@%p..%p) failed: %lu\n", + pnh, pnh + sizeof(inh64), GetLastError())); + return FALSE; + } + } + + DWORD dwOld = 0; + if (!VirtualProtectEx(hProcess, pbModule, inh64.OptionalHeader.SizeOfHeaders, + dwProtect, &dwOld)) { + return FALSE; + } + + return TRUE; +} +#endif // DETOURS_64BIT + +typedef BOOL(WINAPI *LPFN_ISWOW64PROCESS)(HANDLE, PBOOL); + +static BOOL IsWow64ProcessHelper(HANDLE hProcess, + PBOOL Wow64Process) +{ +#ifdef _X86_ + if (Wow64Process == NULL) { + return FALSE; + } + + // IsWow64Process is not available on all supported versions of Windows. + // + HMODULE hKernel32 = LoadLibraryW(L"KERNEL32.DLL"); + if (hKernel32 == NULL) { + DETOUR_TRACE(("LoadLibraryW failed: %lu\n", GetLastError())); + return FALSE; + } + + LPFN_ISWOW64PROCESS pfnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress( + hKernel32, "IsWow64Process"); + + if (pfnIsWow64Process == NULL) { + DETOUR_TRACE(("GetProcAddress failed: %lu\n", GetLastError())); + return FALSE; + } + return pfnIsWow64Process(hProcess, Wow64Process); +#else + return IsWow64Process(hProcess, Wow64Process); +#endif +} + +////////////////////////////////////////////////////////////////////////////// +// +BOOL WINAPI DetourUpdateProcessWithDll(_In_ HANDLE hProcess, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_ DWORD nDlls) +{ + // Find the next memory region that contains a mapped PE image. + // + BOOL bIs32BitProcess; + BOOL bIs64BitOS = FALSE; + HMODULE hModule = NULL; + HMODULE hLast = NULL; + + DETOUR_TRACE(("DetourUpdateProcessWithDll(%p,dlls=%lu)\n", hProcess, nDlls)); + + for (;;) { + IMAGE_NT_HEADERS32 inh; + + if ((hLast = EnumerateModulesInProcess(hProcess, hLast, &inh, NULL)) == NULL) { + break; + } + + DETOUR_TRACE(("%p machine=%04x magic=%04x\n", + hLast, inh.FileHeader.Machine, inh.OptionalHeader.Magic)); + + if ((inh.FileHeader.Characteristics & IMAGE_FILE_DLL) == 0) { + hModule = hLast; + DETOUR_TRACE(("%p Found EXE\n", hLast)); + } + } + + if (hModule == NULL) { + SetLastError(ERROR_INVALID_OPERATION); + return FALSE; + } + + // Determine if the target process is 32bit or 64bit. This is a two-stop process: + // + // 1. First, determine if we're running on a 64bit operating system. + // - If we're running 64bit code (i.e. _WIN64 is defined), this is trivially true. + // - If we're running 32bit code (i.e. _WIN64 is not defined), test if + // we're running under Wow64. If so, it implies that the operating system + // is 64bit. + // +#ifdef _WIN64 + bIs64BitOS = TRUE; +#else + if (!IsWow64ProcessHelper(GetCurrentProcess(), &bIs64BitOS)) { + return FALSE; + } +#endif + + // 2. With the operating system bitness known, we can now consider the target process: + // - If we're running on a 64bit OS, the target process is 32bit in case + // it is running under Wow64. Otherwise, it's 64bit, running natively + // (without Wow64). + // - If we're running on a 32bit OS, the target process must be 32bit, too. + // + if (bIs64BitOS) { + if (!IsWow64ProcessHelper(hProcess, &bIs32BitProcess)) { + return FALSE; + } + } else { + bIs32BitProcess = TRUE; + } + + DETOUR_TRACE((" 32BitProcess=%d\n", bIs32BitProcess)); + + return DetourUpdateProcessWithDllEx(hProcess, + hModule, + bIs32BitProcess, + rlpDlls, + nDlls); +} + +BOOL WINAPI DetourUpdateProcessWithDllEx(_In_ HANDLE hProcess, + _In_ HMODULE hModule, + _In_ BOOL bIs32BitProcess, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_ DWORD nDlls) +{ + // Find the next memory region that contains a mapped PE image. + // + BOOL bIs32BitExe = FALSE; + + DETOUR_TRACE(("DetourUpdateProcessWithDllEx(%p,%p,dlls=%lu)\n", hProcess, hModule, nDlls)); + + IMAGE_NT_HEADERS32 inh; + + if (hModule == NULL || !LoadNtHeaderFromProcess(hProcess, hModule, &inh)) { + SetLastError(ERROR_INVALID_OPERATION); + return FALSE; + } + + if (inh.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC + && inh.FileHeader.Machine != 0) { + + bIs32BitExe = TRUE; + } + + DETOUR_TRACE((" 32BitExe=%d\n", bIs32BitExe)); + + if (hModule == NULL) { + SetLastError(ERROR_INVALID_OPERATION); + return FALSE; + } + + // Save the various headers for DetourRestoreAfterWith. + // + DETOUR_EXE_RESTORE der; + + if (!RecordExeRestore(hProcess, hModule, der)) { + return FALSE; + } + +#if defined(DETOURS_64BIT) + // Try to convert a neutral 32-bit managed binary to a 64-bit managed binary. + if (bIs32BitExe && !bIs32BitProcess) { + if (!der.pclr // Native binary + || (der.clr.Flags & COMIMAGE_FLAGS_ILONLY) == 0 // Or mixed-mode MSIL + || (der.clr.Flags & COMIMAGE_FLAGS_32BITREQUIRED) != 0) { // Or 32BIT Required MSIL + + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + + if (!UpdateFrom32To64(hProcess, hModule, +#if defined(DETOURS_X64) + IMAGE_FILE_MACHINE_AMD64, +#elif defined(DETOURS_IA64) + IMAGE_FILE_MACHINE_IA64, +#elif defined(DETOURS_ARM64) + IMAGE_FILE_MACHINE_ARM64, +#else +#error Must define one of DETOURS_X64 or DETOURS_IA64 or DETOURS_ARM64 on 64-bit. +#endif + der)) { + return FALSE; + } + bIs32BitExe = FALSE; + } +#endif // DETOURS_64BIT + + // Now decide if we can insert the detour. + +#if defined(DETOURS_32BIT) + if (bIs32BitProcess) { + // 32-bit native or 32-bit managed process on any platform. + if (!UpdateImports32(hProcess, hModule, rlpDlls, nDlls)) { + return FALSE; + } + } + else { + // 64-bit native or 64-bit managed process. + // + // Can't detour a 64-bit process with 32-bit code. + // Note: This happens for 32-bit PE binaries containing only + // manage code that have been marked as 64-bit ready. + // + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } +#elif defined(DETOURS_64BIT) + if (bIs32BitProcess || bIs32BitExe) { + // Can't detour a 32-bit process with 64-bit code. + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + else { + // 64-bit native or 64-bit managed process on any platform. + if (!UpdateImports64(hProcess, hModule, rlpDlls, nDlls)) { + return FALSE; + } + } +#else +#pragma Must define one of DETOURS_32BIT or DETOURS_64BIT. +#endif // DETOURS_64BIT + + /////////////////////////////////////////////////// Update the CLR header. + // + if (der.pclr != NULL) { + DETOUR_CLR_HEADER clr; + CopyMemory(&clr, &der.clr, sizeof(clr)); + clr.Flags &= ~COMIMAGE_FLAGS_ILONLY; // Clear the IL_ONLY flag. + + DWORD dwProtect; + if (!DetourVirtualProtectSameExecuteEx(hProcess, der.pclr, sizeof(clr), PAGE_READWRITE, &dwProtect)) { + DETOUR_TRACE(("VirtualProtectEx(clr) write failed: %lu\n", GetLastError())); + return FALSE; + } + + if (!WriteProcessMemory(hProcess, der.pclr, &clr, sizeof(clr), NULL)) { + DETOUR_TRACE(("WriteProcessMemory(clr) failed: %lu\n", GetLastError())); + return FALSE; + } + + if (!VirtualProtectEx(hProcess, der.pclr, sizeof(clr), dwProtect, &dwProtect)) { + DETOUR_TRACE(("VirtualProtectEx(clr) restore failed: %lu\n", GetLastError())); + return FALSE; + } + DETOUR_TRACE(("CLR: %p..%p\n", der.pclr, der.pclr + der.cbclr)); + +#if DETOURS_64BIT + if (der.clr.Flags & COMIMAGE_FLAGS_32BITREQUIRED) { // Is the 32BIT Required Flag set? + // X64 never gets here because the process appears as a WOW64 process. + // However, on IA64, it doesn't appear to be a WOW process. + DETOUR_TRACE(("CLR Requires 32-bit\n")); + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } +#endif // DETOURS_64BIT + } + + //////////////////////////////// Save the undo data to the target process. + // + if (!DetourCopyPayloadToProcess(hProcess, DETOUR_EXE_RESTORE_GUID, &der, sizeof(der))) { + DETOUR_TRACE(("DetourCopyPayloadToProcess failed: %lu\n", GetLastError())); + return FALSE; + } + return TRUE; +} + +////////////////////////////////////////////////////////////////////////////// +// +BOOL WINAPI DetourCreateProcessWithDllA(_In_opt_ LPCSTR lpApplicationName, + _Inout_opt_ LPSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOA lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ LPCSTR lpDllName, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA) +{ + DWORD dwMyCreationFlags = (dwCreationFlags | CREATE_SUSPENDED); + PROCESS_INFORMATION pi; + BOOL fResult = FALSE; + + if (pfCreateProcessA == NULL) { + pfCreateProcessA = CreateProcessA; + } + + fResult = pfCreateProcessA(lpApplicationName, + lpCommandLine, + lpProcessAttributes, + lpThreadAttributes, + bInheritHandles, + dwMyCreationFlags, + lpEnvironment, + lpCurrentDirectory, + lpStartupInfo, + &pi); + + if (lpProcessInformation != NULL) { + CopyMemory(lpProcessInformation, &pi, sizeof(pi)); + } + + if (!fResult) { + return FALSE; + } + + LPCSTR rlpDlls[2]; + DWORD nDlls = 0; + if (lpDllName != NULL) { + rlpDlls[nDlls++] = lpDllName; + } + + if (!DetourUpdateProcessWithDll(pi.hProcess, rlpDlls, nDlls)) { + TerminateProcess(pi.hProcess, ~0u); + return FALSE; + } + + if (!(dwCreationFlags & CREATE_SUSPENDED)) { + ResumeThread(pi.hThread); + } + return TRUE; +} + + +BOOL WINAPI DetourCreateProcessWithDllW(_In_opt_ LPCWSTR lpApplicationName, + _Inout_opt_ LPWSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCWSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOW lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ LPCSTR lpDllName, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW) +{ + DWORD dwMyCreationFlags = (dwCreationFlags | CREATE_SUSPENDED); + PROCESS_INFORMATION pi; + + if (pfCreateProcessW == NULL) { + pfCreateProcessW = CreateProcessW; + } + + BOOL fResult = pfCreateProcessW(lpApplicationName, + lpCommandLine, + lpProcessAttributes, + lpThreadAttributes, + bInheritHandles, + dwMyCreationFlags, + lpEnvironment, + lpCurrentDirectory, + lpStartupInfo, + &pi); + + if (lpProcessInformation) { + CopyMemory(lpProcessInformation, &pi, sizeof(pi)); + } + + if (!fResult) { + return FALSE; + } + + LPCSTR rlpDlls[2]; + DWORD nDlls = 0; + if (lpDllName != NULL) { + rlpDlls[nDlls++] = lpDllName; + } + + if (!DetourUpdateProcessWithDll(pi.hProcess, rlpDlls, nDlls)) { + TerminateProcess(pi.hProcess, ~0u); + return FALSE; + } + + if (!(dwCreationFlags & CREATE_SUSPENDED)) { + ResumeThread(pi.hThread); + } + return TRUE; +} + +BOOL WINAPI DetourCopyPayloadToProcess(_In_ HANDLE hProcess, + _In_ REFGUID rguid, + _In_reads_bytes_(cbData) LPCVOID pvData, + _In_ DWORD cbData) +{ + return DetourCopyPayloadToProcessEx(hProcess, rguid, pvData, cbData) != NULL; +} + +_Success_(return != NULL) +PVOID WINAPI DetourCopyPayloadToProcessEx(_In_ HANDLE hProcess, + _In_ REFGUID rguid, + _In_reads_bytes_(cbData) LPCVOID pvData, + _In_ DWORD cbData) +{ + if (hProcess == NULL) { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } + + DWORD cbTotal = (sizeof(IMAGE_DOS_HEADER) + + sizeof(IMAGE_NT_HEADERS) + + sizeof(IMAGE_SECTION_HEADER) + + sizeof(DETOUR_SECTION_HEADER) + + sizeof(DETOUR_SECTION_RECORD) + + cbData); + + PBYTE pbBase = (PBYTE)VirtualAllocEx(hProcess, NULL, cbTotal, + MEM_COMMIT, PAGE_READWRITE); + if (pbBase == NULL) { + DETOUR_TRACE(("VirtualAllocEx(%lu) failed: %lu\n", cbTotal, GetLastError())); + return NULL; + } + + // As you can see in the following code, + // the memory layout of the payload range "[pbBase, pbBase+cbTotal]" is a PE executable file, + // so DetourFreePayload can use "DetourGetContainingModule(Payload pointer)" to get the above "pbBase" pointer, + // pbBase: the memory block allocated by VirtualAllocEx will be released in DetourFreePayload by VirtualFree. + + PBYTE pbTarget = pbBase; + IMAGE_DOS_HEADER idh; + IMAGE_NT_HEADERS inh; + IMAGE_SECTION_HEADER ish; + DETOUR_SECTION_HEADER dsh; + DETOUR_SECTION_RECORD dsr; + SIZE_T cbWrote = 0; + + ZeroMemory(&idh, sizeof(idh)); + idh.e_magic = IMAGE_DOS_SIGNATURE; + idh.e_lfanew = sizeof(idh); + if (!WriteProcessMemory(hProcess, pbTarget, &idh, sizeof(idh), &cbWrote) || + cbWrote != sizeof(idh)) { + DETOUR_TRACE(("WriteProcessMemory(idh) failed: %lu\n", GetLastError())); + return NULL; + } + pbTarget += sizeof(idh); + + ZeroMemory(&inh, sizeof(inh)); + inh.Signature = IMAGE_NT_SIGNATURE; + inh.FileHeader.SizeOfOptionalHeader = sizeof(inh.OptionalHeader); + inh.FileHeader.Characteristics = IMAGE_FILE_DLL; + inh.FileHeader.NumberOfSections = 1; + inh.OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; + if (!WriteProcessMemory(hProcess, pbTarget, &inh, sizeof(inh), &cbWrote) || + cbWrote != sizeof(inh)) { + return NULL; + } + pbTarget += sizeof(inh); + + ZeroMemory(&ish, sizeof(ish)); + memcpy(ish.Name, ".detour", sizeof(ish.Name)); + ish.VirtualAddress = (DWORD)((pbTarget + sizeof(ish)) - pbBase); + ish.SizeOfRawData = (sizeof(DETOUR_SECTION_HEADER) + + sizeof(DETOUR_SECTION_RECORD) + + cbData); + if (!WriteProcessMemory(hProcess, pbTarget, &ish, sizeof(ish), &cbWrote) || + cbWrote != sizeof(ish)) { + return NULL; + } + pbTarget += sizeof(ish); + + ZeroMemory(&dsh, sizeof(dsh)); + dsh.cbHeaderSize = sizeof(dsh); + dsh.nSignature = DETOUR_SECTION_HEADER_SIGNATURE; + dsh.nDataOffset = sizeof(DETOUR_SECTION_HEADER); + dsh.cbDataSize = (sizeof(DETOUR_SECTION_HEADER) + + sizeof(DETOUR_SECTION_RECORD) + + cbData); + if (!WriteProcessMemory(hProcess, pbTarget, &dsh, sizeof(dsh), &cbWrote) || + cbWrote != sizeof(dsh)) { + return NULL; + } + pbTarget += sizeof(dsh); + + ZeroMemory(&dsr, sizeof(dsr)); + dsr.cbBytes = cbData + sizeof(DETOUR_SECTION_RECORD); + dsr.nReserved = 0; + dsr.guid = rguid; + if (!WriteProcessMemory(hProcess, pbTarget, &dsr, sizeof(dsr), &cbWrote) || + cbWrote != sizeof(dsr)) { + return NULL; + } + pbTarget += sizeof(dsr); + + if (!WriteProcessMemory(hProcess, pbTarget, pvData, cbData, &cbWrote) || + cbWrote != cbData) { + return NULL; + } + + DETOUR_TRACE(("Copied %lu byte payload into target process at %p\n", + cbData, pbTarget)); + + SetLastError(NO_ERROR); + return pbTarget; +} + +static BOOL s_fSearchedForHelper = FALSE; +static PDETOUR_EXE_HELPER s_pHelper = NULL; + +VOID CALLBACK DetourFinishHelperProcess(_In_ HWND, + _In_ HINSTANCE, + _In_ LPSTR, + _In_ INT) +{ + LPCSTR * rlpDlls = NULL; + DWORD Result = 9900; + DWORD cOffset = 0; + DWORD cSize = 0; + HANDLE hProcess = NULL; + + if (s_pHelper == NULL) { + DETOUR_TRACE(("DetourFinishHelperProcess called with s_pHelper = NULL.\n")); + Result = 9905; + goto Cleanup; + } + + hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, s_pHelper->pid); + if (hProcess == NULL) { + DETOUR_TRACE(("OpenProcess(pid=%lu) failed: %lu\n", + s_pHelper->pid, GetLastError())); + Result = 9901; + goto Cleanup; + } + + rlpDlls = new NOTHROW LPCSTR [s_pHelper->nDlls]; + cSize = s_pHelper->cb - sizeof(DETOUR_EXE_HELPER); + for (DWORD n = 0; n < s_pHelper->nDlls; n++) { + size_t cchDest = 0; + HRESULT hr = StringCchLengthA(&s_pHelper->rDlls[cOffset], cSize - cOffset, &cchDest); + if (!SUCCEEDED(hr)) { + Result = 9902; + goto Cleanup; + } + + rlpDlls[n] = &s_pHelper->rDlls[cOffset]; + cOffset += (DWORD)cchDest + 1; + } + + if (!DetourUpdateProcessWithDll(hProcess, rlpDlls, s_pHelper->nDlls)) { + DETOUR_TRACE(("DetourUpdateProcessWithDll(pid=%lu) failed: %lu\n", + s_pHelper->pid, GetLastError())); + Result = 9903; + goto Cleanup; + } + Result = 0; + + Cleanup: + if (rlpDlls != NULL) { + delete[] rlpDlls; + rlpDlls = NULL; + } + + // Note: s_pHelper is allocated as part of injecting the payload in DetourCopyPayloadToProcess(..), + // it's a fake section and not data allocated by the system PE loader. + + // Delete the payload after execution to release the memory occupied by it + if (s_pHelper != NULL) { + DetourFreePayload(s_pHelper); + s_pHelper = NULL; + } + + ExitProcess(Result); +} + +BOOL WINAPI DetourIsHelperProcess(VOID) +{ + PVOID pvData; + DWORD cbData; + + if (s_fSearchedForHelper) { + return (s_pHelper != NULL); + } + + s_fSearchedForHelper = TRUE; + pvData = DetourFindPayloadEx(DETOUR_EXE_HELPER_GUID, &cbData); + + if (pvData == NULL || cbData < sizeof(DETOUR_EXE_HELPER)) { + return FALSE; + } + + s_pHelper = (PDETOUR_EXE_HELPER)pvData; + if (s_pHelper->cb < sizeof(*s_pHelper)) { + s_pHelper = NULL; + return FALSE; + } + + return TRUE; +} + +static +BOOL WINAPI AllocExeHelper(_Out_ PDETOUR_EXE_HELPER *pHelper, + _In_ DWORD dwTargetPid, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls) +{ + PDETOUR_EXE_HELPER Helper = NULL; + BOOL Result = FALSE; + _Field_range_(0, cSize - 4) DWORD cOffset = 0; + DWORD cSize = 4; + + if (pHelper == NULL) { + goto Cleanup; + } + *pHelper = NULL; + + if (nDlls < 1 || nDlls > 4096) { + SetLastError(ERROR_INVALID_PARAMETER); + goto Cleanup; + } + + for (DWORD n = 0; n < nDlls; n++) { + HRESULT hr; + size_t cchDest = 0; + + hr = StringCchLengthA(rlpDlls[n], 4096, &cchDest); + if (!SUCCEEDED(hr)) { + goto Cleanup; + } + + cSize += (DWORD)cchDest + 1; + } + + Helper = (PDETOUR_EXE_HELPER) new NOTHROW BYTE[sizeof(DETOUR_EXE_HELPER) + cSize]; + if (Helper == NULL) { + goto Cleanup; + } + + Helper->cb = sizeof(DETOUR_EXE_HELPER) + cSize; + Helper->pid = dwTargetPid; + Helper->nDlls = nDlls; + + for (DWORD n = 0; n < nDlls; n++) { + HRESULT hr; + size_t cchDest = 0; + + if (cOffset > 0x10000 || cSize > 0x10000 || cOffset + 2 >= cSize) { + goto Cleanup; + } + + if (cOffset + 2 >= cSize || cOffset + 65536 < cSize) { + goto Cleanup; + } + + _Analysis_assume_(cOffset + 1 < cSize); + _Analysis_assume_(cOffset < 0x10000); + _Analysis_assume_(cSize < 0x10000); + + PCHAR psz = &Helper->rDlls[cOffset]; + + hr = StringCchCopyA(psz, cSize - cOffset, rlpDlls[n]); + if (!SUCCEEDED(hr)) { + goto Cleanup; + } + +// REVIEW 28020 The expression '1<=_Param_(2)& &_Param_(2)<=2147483647' is not true at this call. +// REVIEW 28313 Analysis will not proceed past this point because of annotation evaluation. The annotation expression *_Param_(3)<_Param_(2)&&*_Param_(3)<=stringLength$(_Param_(1)) cannot be true under any assumptions at this point in the program. +#pragma warning(suppress:28020 28313) + hr = StringCchLengthA(psz, cSize - cOffset, &cchDest); + if (!SUCCEEDED(hr)) { + goto Cleanup; + } + + // Replace "32." with "64." or "64." with "32." + + for (DWORD c = (DWORD)cchDest + 1; c > 3; c--) { +#if DETOURS_32BIT + if (psz[c - 3] == '3' && psz[c - 2] == '2' && psz[c - 1] == '.') { + psz[c - 3] = '6'; psz[c - 2] = '4'; + break; + } +#else + if (psz[c - 3] == '6' && psz[c - 2] == '4' && psz[c - 1] == '.') { + psz[c - 3] = '3'; psz[c - 2] = '2'; + break; + } +#endif + } + + cOffset += (DWORD)cchDest + 1; + } + + *pHelper = Helper; + Helper = NULL; + Result = TRUE; + + Cleanup: + if (Helper != NULL) { + delete[] (PBYTE)Helper; + Helper = NULL; + } + return Result; +} + +static +VOID WINAPI FreeExeHelper(PDETOUR_EXE_HELPER *pHelper) +{ + if (*pHelper != NULL) { + delete[] (PBYTE)*pHelper; + *pHelper = NULL; + } +} + +BOOL WINAPI DetourProcessViaHelperA(_In_ DWORD dwTargetPid, + _In_ LPCSTR lpDllName, + _In_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA) +{ + return DetourProcessViaHelperDllsA(dwTargetPid, 1, &lpDllName, pfCreateProcessA); +} + + +BOOL WINAPI DetourProcessViaHelperDllsA(_In_ DWORD dwTargetPid, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA) +{ + BOOL Result = FALSE; + PROCESS_INFORMATION pi; + STARTUPINFOA si; + CHAR szExe[MAX_PATH]; + CHAR szCommand[MAX_PATH]; + PDETOUR_EXE_HELPER helper = NULL; + HRESULT hr; + DWORD nLen = GetEnvironmentVariableA("WINDIR", szExe, ARRAYSIZE(szExe)); + + DETOUR_TRACE(("DetourProcessViaHelperDlls(pid=%lu,dlls=%lu)\n", dwTargetPid, nDlls)); + if (nDlls < 1 || nDlls > 4096) { + SetLastError(ERROR_INVALID_PARAMETER); + goto Cleanup; + } + if (!AllocExeHelper(&helper, dwTargetPid, nDlls, rlpDlls)) { + goto Cleanup; + } + + if (nLen == 0 || nLen >= ARRAYSIZE(szExe)) { + goto Cleanup; + } + +#if DETOURS_OPTION_BITS +#if DETOURS_32BIT + hr = StringCchCatA(szExe, ARRAYSIZE(szExe), "\\sysnative\\rundll32.exe"); +#else // !DETOURS_32BIT + hr = StringCchCatA(szExe, ARRAYSIZE(szExe), "\\syswow64\\rundll32.exe"); +#endif // !DETOURS_32BIT +#else // DETOURS_OPTIONS_BITS + hr = StringCchCatA(szExe, ARRAYSIZE(szExe), "\\system32\\rundll32.exe"); +#endif // DETOURS_OPTIONS_BITS + if (!SUCCEEDED(hr)) { + goto Cleanup; + } + + //for East Asia languages and so on, like Chinese, print format with "%hs" can not work fine before user call _tsetlocale(LC_ALL,_T(".ACP")); + //so we can't use "%hs" in format string, because the dll that contain this code would inject to any process, even not call _tsetlocale(LC_ALL,_T(".ACP")) before + hr = StringCchPrintfA(szCommand, ARRAYSIZE(szCommand), + "rundll32.exe \"%s\",#1", &helper->rDlls[0]); + if (!SUCCEEDED(hr)) { + goto Cleanup; + } + + ZeroMemory(&pi, sizeof(pi)); + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + + DETOUR_TRACE(("DetourProcessViaHelperDlls(\"%hs\", \"%hs\")\n", szExe, szCommand)); + if (pfCreateProcessA(szExe, szCommand, NULL, NULL, FALSE, CREATE_SUSPENDED, + NULL, NULL, &si, &pi)) { + + if (!DetourCopyPayloadToProcess(pi.hProcess, + DETOUR_EXE_HELPER_GUID, + helper, helper->cb)) { + DETOUR_TRACE(("DetourCopyPayloadToProcess failed: %lu\n", GetLastError())); + TerminateProcess(pi.hProcess, ~0u); + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + goto Cleanup; + } + + ResumeThread(pi.hThread); + WaitForSingleObject(pi.hProcess, INFINITE); + + DWORD dwResult = 500; + GetExitCodeProcess(pi.hProcess, &dwResult); + + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + + if (dwResult != 0) { + DETOUR_TRACE(("Rundll32.exe failed: result=%lu\n", dwResult)); + goto Cleanup; + } + Result = TRUE; + } + else { + DETOUR_TRACE(("CreateProcess failed: %lu\n", GetLastError())); + goto Cleanup; + } + + Cleanup: + FreeExeHelper(&helper); + return Result; +} + +BOOL WINAPI DetourProcessViaHelperW(_In_ DWORD dwTargetPid, + _In_ LPCSTR lpDllName, + _In_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW) +{ + return DetourProcessViaHelperDllsW(dwTargetPid, 1, &lpDllName, pfCreateProcessW); +} + +BOOL WINAPI DetourProcessViaHelperDllsW(_In_ DWORD dwTargetPid, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW) +{ + BOOL Result = FALSE; + PROCESS_INFORMATION pi; + STARTUPINFOW si; + WCHAR szExe[MAX_PATH]; + WCHAR szCommand[MAX_PATH]; + PDETOUR_EXE_HELPER helper = NULL; + HRESULT hr; + WCHAR szDllName[MAX_PATH]; + int cchWrittenWideChar; + DWORD nLen = GetEnvironmentVariableW(L"WINDIR", szExe, ARRAYSIZE(szExe)); + + DETOUR_TRACE(("DetourProcessViaHelperDlls(pid=%lu,dlls=%lu)\n", dwTargetPid, nDlls)); + if (nDlls < 1 || nDlls > 4096) { + SetLastError(ERROR_INVALID_PARAMETER); + goto Cleanup; + } + if (!AllocExeHelper(&helper, dwTargetPid, nDlls, rlpDlls)) { + goto Cleanup; + } + + if (nLen == 0 || nLen >= ARRAYSIZE(szExe)) { + goto Cleanup; + } + +#if DETOURS_OPTION_BITS +#if DETOURS_32BIT + hr = StringCchCatW(szExe, ARRAYSIZE(szExe), L"\\sysnative\\rundll32.exe"); +#else // !DETOURS_32BIT + hr = StringCchCatW(szExe, ARRAYSIZE(szExe), L"\\syswow64\\rundll32.exe"); +#endif // !DETOURS_32BIT +#else // DETOURS_OPTIONS_BITS + hr = StringCchCatW(szExe, ARRAYSIZE(szExe), L"\\system32\\rundll32.exe"); +#endif // DETOURS_OPTIONS_BITS + if (!SUCCEEDED(hr)) { + goto Cleanup; + } + + //for East Asia languages and so on, like Chinese, print format with "%hs" can not work fine before user call _tsetlocale(LC_ALL,_T(".ACP")); + //so we can't use "%hs" in format string, because the dll that contain this code would inject to any process, even not call _tsetlocale(LC_ALL,_T(".ACP")) before + + cchWrittenWideChar = MultiByteToWideChar(CP_ACP, 0, &helper->rDlls[0], -1, szDllName, ARRAYSIZE(szDllName)); + if (cchWrittenWideChar >= ARRAYSIZE(szDllName) || cchWrittenWideChar <= 0) { + goto Cleanup; + } + hr = StringCchPrintfW(szCommand, ARRAYSIZE(szCommand), + L"rundll32.exe \"%s\",#1", szDllName); + if (!SUCCEEDED(hr)) { + goto Cleanup; + } + + ZeroMemory(&pi, sizeof(pi)); + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + + DETOUR_TRACE(("DetourProcessViaHelperDlls(\"%ls\", \"%ls\")\n", szExe, szCommand)); + if (pfCreateProcessW(szExe, szCommand, NULL, NULL, FALSE, CREATE_SUSPENDED, + NULL, NULL, &si, &pi)) { + + if (!DetourCopyPayloadToProcess(pi.hProcess, + DETOUR_EXE_HELPER_GUID, + helper, helper->cb)) { + DETOUR_TRACE(("DetourCopyPayloadToProcess failed: %lu\n", GetLastError())); + TerminateProcess(pi.hProcess, ~0u); + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + goto Cleanup; + } + + ResumeThread(pi.hThread); + WaitForSingleObject(pi.hProcess, INFINITE); + + DWORD dwResult = 500; + GetExitCodeProcess(pi.hProcess, &dwResult); + + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + + if (dwResult != 0) { + DETOUR_TRACE(("Rundll32.exe failed: result=%lu\n", dwResult)); + goto Cleanup; + } + Result = TRUE; + } + else { + DETOUR_TRACE(("CreateProcess failed: %lu\n", GetLastError())); + goto Cleanup; + } + + Cleanup: + FreeExeHelper(&helper); + return Result; +} + +BOOL WINAPI DetourCreateProcessWithDllExA(_In_opt_ LPCSTR lpApplicationName, + _Inout_opt_ LPSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOA lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ LPCSTR lpDllName, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA) +{ + if (pfCreateProcessA == NULL) { + pfCreateProcessA = CreateProcessA; + } + + PROCESS_INFORMATION backup; + if (lpProcessInformation == NULL) { + lpProcessInformation = &backup; + ZeroMemory(&backup, sizeof(backup)); + } + + if (!pfCreateProcessA(lpApplicationName, + lpCommandLine, + lpProcessAttributes, + lpThreadAttributes, + bInheritHandles, + dwCreationFlags | CREATE_SUSPENDED, + lpEnvironment, + lpCurrentDirectory, + lpStartupInfo, + lpProcessInformation)) { + return FALSE; + } + + LPCSTR szDll = lpDllName; + + if (!DetourUpdateProcessWithDll(lpProcessInformation->hProcess, &szDll, 1) && + !DetourProcessViaHelperA(lpProcessInformation->dwProcessId, + lpDllName, + pfCreateProcessA)) { + + TerminateProcess(lpProcessInformation->hProcess, ~0u); + CloseHandle(lpProcessInformation->hProcess); + CloseHandle(lpProcessInformation->hThread); + return FALSE; + } + + if (!(dwCreationFlags & CREATE_SUSPENDED)) { + ResumeThread(lpProcessInformation->hThread); + } + + if (lpProcessInformation == &backup) { + CloseHandle(lpProcessInformation->hProcess); + CloseHandle(lpProcessInformation->hThread); + } + + return TRUE; +} + +BOOL WINAPI DetourCreateProcessWithDllExW(_In_opt_ LPCWSTR lpApplicationName, + _Inout_opt_ LPWSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCWSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOW lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ LPCSTR lpDllName, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW) +{ + if (pfCreateProcessW == NULL) { + pfCreateProcessW = CreateProcessW; + } + + PROCESS_INFORMATION backup; + if (lpProcessInformation == NULL) { + lpProcessInformation = &backup; + ZeroMemory(&backup, sizeof(backup)); + } + + if (!pfCreateProcessW(lpApplicationName, + lpCommandLine, + lpProcessAttributes, + lpThreadAttributes, + bInheritHandles, + dwCreationFlags | CREATE_SUSPENDED, + lpEnvironment, + lpCurrentDirectory, + lpStartupInfo, + lpProcessInformation)) { + return FALSE; + } + + + LPCSTR sz = lpDllName; + + if (!DetourUpdateProcessWithDll(lpProcessInformation->hProcess, &sz, 1) && + !DetourProcessViaHelperW(lpProcessInformation->dwProcessId, + lpDllName, + pfCreateProcessW)) { + + TerminateProcess(lpProcessInformation->hProcess, ~0u); + CloseHandle(lpProcessInformation->hProcess); + CloseHandle(lpProcessInformation->hThread); + return FALSE; + } + + if (!(dwCreationFlags & CREATE_SUSPENDED)) { + ResumeThread(lpProcessInformation->hThread); + } + + if (lpProcessInformation == &backup) { + CloseHandle(lpProcessInformation->hProcess); + CloseHandle(lpProcessInformation->hThread); + } + return TRUE; +} + +BOOL WINAPI DetourCreateProcessWithDllsA(_In_opt_ LPCSTR lpApplicationName, + _Inout_opt_ LPSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOA lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA) +{ + if (pfCreateProcessA == NULL) { + pfCreateProcessA = CreateProcessA; + } + + PROCESS_INFORMATION backup; + if (lpProcessInformation == NULL) { + lpProcessInformation = &backup; + ZeroMemory(&backup, sizeof(backup)); + } + + if (!pfCreateProcessA(lpApplicationName, + lpCommandLine, + lpProcessAttributes, + lpThreadAttributes, + bInheritHandles, + dwCreationFlags | CREATE_SUSPENDED, + lpEnvironment, + lpCurrentDirectory, + lpStartupInfo, + lpProcessInformation)) { + return FALSE; + } + + if (!DetourUpdateProcessWithDll(lpProcessInformation->hProcess, rlpDlls, nDlls) && + !DetourProcessViaHelperDllsA(lpProcessInformation->dwProcessId, + nDlls, + rlpDlls, + pfCreateProcessA)) { + + TerminateProcess(lpProcessInformation->hProcess, ~0u); + CloseHandle(lpProcessInformation->hProcess); + CloseHandle(lpProcessInformation->hThread); + return FALSE; + } + + if (!(dwCreationFlags & CREATE_SUSPENDED)) { + ResumeThread(lpProcessInformation->hThread); + } + + if (lpProcessInformation == &backup) { + CloseHandle(lpProcessInformation->hProcess); + CloseHandle(lpProcessInformation->hThread); + } + + return TRUE; +} + +BOOL WINAPI DetourCreateProcessWithDllsW(_In_opt_ LPCWSTR lpApplicationName, + _Inout_opt_ LPWSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCWSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOW lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW) +{ + if (pfCreateProcessW == NULL) { + pfCreateProcessW = CreateProcessW; + } + + PROCESS_INFORMATION backup; + if (lpProcessInformation == NULL) { + lpProcessInformation = &backup; + ZeroMemory(&backup, sizeof(backup)); + } + + if (!pfCreateProcessW(lpApplicationName, + lpCommandLine, + lpProcessAttributes, + lpThreadAttributes, + bInheritHandles, + dwCreationFlags | CREATE_SUSPENDED, + lpEnvironment, + lpCurrentDirectory, + lpStartupInfo, + lpProcessInformation)) { + return FALSE; + } + + + if (!DetourUpdateProcessWithDll(lpProcessInformation->hProcess, rlpDlls, nDlls) && + !DetourProcessViaHelperDllsW(lpProcessInformation->dwProcessId, + nDlls, + rlpDlls, + pfCreateProcessW)) { + + TerminateProcess(lpProcessInformation->hProcess, ~0u); + CloseHandle(lpProcessInformation->hProcess); + CloseHandle(lpProcessInformation->hThread); + return FALSE; + } + + if (!(dwCreationFlags & CREATE_SUSPENDED)) { + ResumeThread(lpProcessInformation->hThread); + } + + if (lpProcessInformation == &backup) { + CloseHandle(lpProcessInformation->hProcess); + CloseHandle(lpProcessInformation->hThread); + } + return TRUE; +} + +// +///////////////////////////////////////////////////////////////// End of File. diff --git a/r5dev/thirdparty/detours/src/uimports.cpp b/r5dev/thirdparty/detours/src/uimports.cpp new file mode 100644 index 00000000..cd1fe0f8 --- /dev/null +++ b/r5dev/thirdparty/detours/src/uimports.cpp @@ -0,0 +1,335 @@ +////////////////////////////////////////////////////////////////////////////// +// +// Add DLLs to a module import table (uimports.cpp of detours.lib) +// +// Microsoft Research Detours Package, Version 4.0.1 +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +// Note that this file is included into creatwth.cpp one or more times +// (once for each supported module format). +// + +#include "../include/detours.h" + +#if DETOURS_VERSION != 0x4c0c1 // 0xMAJORcMINORcPATCH +#error detours.h version mismatch +#endif + +// UpdateImports32 aka UpdateImports64 +static BOOL UPDATE_IMPORTS_XX(HANDLE hProcess, + HMODULE hModule, + __in_ecount(nDlls) LPCSTR *plpDlls, + DWORD nDlls) +{ + BOOL fSucceeded = FALSE; + DWORD cbNew = 0; + + BYTE * pbNew = NULL; + DWORD i; + SIZE_T cbRead; + DWORD n; + + PBYTE pbModule = (PBYTE)hModule; + + IMAGE_DOS_HEADER idh; + ZeroMemory(&idh, sizeof(idh)); + if (!ReadProcessMemory(hProcess, pbModule, &idh, sizeof(idh), &cbRead) + || cbRead < sizeof(idh)) { + + DETOUR_TRACE(("ReadProcessMemory(idh@%p..%p) failed: %lu\n", + pbModule, pbModule + sizeof(idh), GetLastError())); + + finish: + if (pbNew != NULL) { + delete[] pbNew; + pbNew = NULL; + } + return fSucceeded; + } + + IMAGE_NT_HEADERS_XX inh; + ZeroMemory(&inh, sizeof(inh)); + + if (!ReadProcessMemory(hProcess, pbModule + idh.e_lfanew, &inh, sizeof(inh), &cbRead) + || cbRead < sizeof(inh)) { + DETOUR_TRACE(("ReadProcessMemory(inh@%p..%p) failed: %lu\n", + pbModule + idh.e_lfanew, + pbModule + idh.e_lfanew + sizeof(inh), + GetLastError())); + goto finish; + } + + if (inh.OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC_XX) { + DETOUR_TRACE(("Wrong size image (%04x != %04x).\n", + inh.OptionalHeader.Magic, IMAGE_NT_OPTIONAL_HDR_MAGIC_XX)); + SetLastError(ERROR_INVALID_BLOCK); + goto finish; + } + + // Zero out the bound table so loader doesn't use it instead of our new table. + inh.BOUND_DIRECTORY.VirtualAddress = 0; + inh.BOUND_DIRECTORY.Size = 0; + + // Find the size of the mapped file. + DWORD dwSec = idh.e_lfanew + + FIELD_OFFSET(IMAGE_NT_HEADERS_XX, OptionalHeader) + + inh.FileHeader.SizeOfOptionalHeader; + + for (i = 0; i < inh.FileHeader.NumberOfSections; i++) { + IMAGE_SECTION_HEADER ish; + ZeroMemory(&ish, sizeof(ish)); + + if (!ReadProcessMemory(hProcess, pbModule + dwSec + sizeof(ish) * i, &ish, + sizeof(ish), &cbRead) + || cbRead < sizeof(ish)) { + + DETOUR_TRACE(("ReadProcessMemory(ish@%p..%p) failed: %lu\n", + pbModule + dwSec + sizeof(ish) * i, + pbModule + dwSec + sizeof(ish) * (i + 1), + GetLastError())); + goto finish; + } + + DETOUR_TRACE(("ish[%lu] : va=%08lx sr=%lu\n", i, ish.VirtualAddress, ish.SizeOfRawData)); + + // If the linker didn't suggest an IAT in the data directories, the + // loader will look for the section of the import directory to be used + // for this instead. Since we put out new IMPORT_DIRECTORY outside any + // section boundary, the loader will not find it. So we provide one + // explicitly to avoid the search. + // + if (inh.IAT_DIRECTORY.VirtualAddress == 0 && + inh.IMPORT_DIRECTORY.VirtualAddress >= ish.VirtualAddress && + inh.IMPORT_DIRECTORY.VirtualAddress < ish.VirtualAddress + ish.SizeOfRawData) { + + inh.IAT_DIRECTORY.VirtualAddress = ish.VirtualAddress; + inh.IAT_DIRECTORY.Size = ish.SizeOfRawData; + } + } + + if (inh.IMPORT_DIRECTORY.VirtualAddress != 0 && inh.IMPORT_DIRECTORY.Size == 0) { + + // Don't worry about changing the PE file, + // because the load information of the original PE header has been saved and will be restored. + // The change here is just for the following code to work normally + + PIMAGE_IMPORT_DESCRIPTOR pImageImport = (PIMAGE_IMPORT_DESCRIPTOR)(pbModule + inh.IMPORT_DIRECTORY.VirtualAddress); + + do { + IMAGE_IMPORT_DESCRIPTOR ImageImport; + if (!ReadProcessMemory(hProcess, pImageImport, &ImageImport, sizeof(ImageImport), NULL)) { + DETOUR_TRACE(("ReadProcessMemory failed: %lu\n", GetLastError())); + goto finish; + } + inh.IMPORT_DIRECTORY.Size += sizeof(IMAGE_IMPORT_DESCRIPTOR); + if (!ImageImport.Name) { + break; + } + ++pImageImport; + } while (TRUE); + + DWORD dwLastError = GetLastError(); + OutputDebugString(TEXT("[This PE file has an import table, but the import table size is marked as 0. This is an error.") + TEXT("If it is not repaired, the launched program will not work properly, Detours has automatically repaired its import table size for you! ! !]\r\n")); + if (GetLastError() != dwLastError) { + SetLastError(dwLastError); + } + } + + DETOUR_TRACE((" Imports: %p..%p\n", + pbModule + inh.IMPORT_DIRECTORY.VirtualAddress, + pbModule + inh.IMPORT_DIRECTORY.VirtualAddress + + inh.IMPORT_DIRECTORY.Size)); + + // Calculate new import directory size. Note that since inh is from another + // process, inh could have been corrupted. We need to protect against + // integer overflow in allocation calculations. + DWORD nOldDlls = inh.IMPORT_DIRECTORY.Size / sizeof(IMAGE_IMPORT_DESCRIPTOR); + DWORD obRem; + if (DWordMult(sizeof(IMAGE_IMPORT_DESCRIPTOR), nDlls, &obRem) != S_OK) { + DETOUR_TRACE(("too many new DLLs.\n")); + goto finish; + } + DWORD obOld; + if (DWordAdd(obRem, sizeof(IMAGE_IMPORT_DESCRIPTOR) * nOldDlls, &obOld) != S_OK) { + DETOUR_TRACE(("DLL entries overflow.\n")); + goto finish; + } + DWORD obTab = PadToDwordPtr(obOld); + // Check for integer overflow. + if (obTab < obOld) { + DETOUR_TRACE(("DLL entries padding overflow.\n")); + goto finish; + } + DWORD stSize; + if (DWordMult(sizeof(DWORD_XX) * 4, nDlls, &stSize) != S_OK) { + DETOUR_TRACE(("String table overflow.\n")); + goto finish; + } + DWORD obDll; + if (DWordAdd(obTab, stSize, &obDll) != S_OK) { + DETOUR_TRACE(("Import table size overflow\n")); + goto finish; + } + DWORD obStr = obDll; + cbNew = obStr; + for (n = 0; n < nDlls; n++) { + if (DWordAdd(cbNew, PadToDword((DWORD)strlen(plpDlls[n]) + 1), &cbNew) != S_OK) { + DETOUR_TRACE(("Overflow adding string table entry\n")); + goto finish; + } + } + pbNew = new BYTE [cbNew]; + if (pbNew == NULL) { + DETOUR_TRACE(("new BYTE [cbNew] failed.\n")); + goto finish; + } + ZeroMemory(pbNew, cbNew); + + PBYTE pbBase = pbModule; + PBYTE pbNext = pbBase + + inh.OptionalHeader.BaseOfCode + + inh.OptionalHeader.SizeOfCode + + inh.OptionalHeader.SizeOfInitializedData + + inh.OptionalHeader.SizeOfUninitializedData; + if (pbBase < pbNext) { + pbBase = pbNext; + } + DETOUR_TRACE(("pbBase = %p\n", pbBase)); + + PBYTE pbNewIid = FindAndAllocateNearBase(hProcess, pbModule, pbBase, cbNew); + if (pbNewIid == NULL) { + DETOUR_TRACE(("FindAndAllocateNearBase failed.\n")); + goto finish; + } + + PIMAGE_IMPORT_DESCRIPTOR piid = (PIMAGE_IMPORT_DESCRIPTOR)pbNew; + IMAGE_THUNK_DATAXX *pt = NULL; + + DWORD obBase = (DWORD)(pbNewIid - pbModule); + DWORD dwProtect = 0; + + if (inh.IMPORT_DIRECTORY.VirtualAddress != 0) { + // Read the old import directory if it exists. + DETOUR_TRACE(("IMPORT_DIRECTORY perms=%lx\n", dwProtect)); + + if (!ReadProcessMemory(hProcess, + pbModule + inh.IMPORT_DIRECTORY.VirtualAddress, + &piid[nDlls], + nOldDlls * sizeof(IMAGE_IMPORT_DESCRIPTOR), &cbRead) + || cbRead < nOldDlls * sizeof(IMAGE_IMPORT_DESCRIPTOR)) { + + DETOUR_TRACE(("ReadProcessMemory(imports) failed: %lu\n", GetLastError())); + goto finish; + } + } + + for (n = 0; n < nDlls; n++) { + HRESULT hrRet = StringCchCopyA((char*)pbNew + obStr, cbNew - obStr, plpDlls[n]); + if (FAILED(hrRet)) { + DETOUR_TRACE(("StringCchCopyA failed: %08lx\n", hrRet)); + goto finish; + } + + // After copying the string, we patch up the size "??" bits if any. + hrRet = ReplaceOptionalSizeA((char*)pbNew + obStr, + cbNew - obStr, + DETOURS_STRINGIFY(DETOURS_BITS_XX)); + if (FAILED(hrRet)) { + DETOUR_TRACE(("ReplaceOptionalSizeA failed: %08lx\n", hrRet)); + goto finish; + } + + DWORD nOffset = obTab + (sizeof(IMAGE_THUNK_DATAXX) * (4 * n)); + piid[n].OriginalFirstThunk = obBase + nOffset; + + // We need 2 thunks for the import table and 2 thunks for the IAT. + // One for an ordinal import and one to mark the end of the list. + pt = ((IMAGE_THUNK_DATAXX*)(pbNew + nOffset)); + pt[0].u1.Ordinal = IMAGE_ORDINAL_FLAG_XX + 1; + pt[1].u1.Ordinal = 0; + + nOffset = obTab + (sizeof(IMAGE_THUNK_DATAXX) * ((4 * n) + 2)); + piid[n].FirstThunk = obBase + nOffset; + pt = ((IMAGE_THUNK_DATAXX*)(pbNew + nOffset)); + pt[0].u1.Ordinal = IMAGE_ORDINAL_FLAG_XX + 1; + pt[1].u1.Ordinal = 0; + piid[n].TimeDateStamp = 0; + piid[n].ForwarderChain = 0; + piid[n].Name = obBase + obStr; + + obStr += PadToDword((DWORD)strlen(plpDlls[n]) + 1); + } + _Analysis_assume_(obStr <= cbNew); + +#if 0 + for (i = 0; i < nDlls + nOldDlls; i++) { + DETOUR_TRACE(("%8d. Look=%08x Time=%08x Fore=%08x Name=%08x Addr=%08x\n", + i, + piid[i].OriginalFirstThunk, + piid[i].TimeDateStamp, + piid[i].ForwarderChain, + piid[i].Name, + piid[i].FirstThunk)); + if (piid[i].OriginalFirstThunk == 0 && piid[i].FirstThunk == 0) { + break; + } + } +#endif + + if (!WriteProcessMemory(hProcess, pbNewIid, pbNew, obStr, NULL)) { + DETOUR_TRACE(("WriteProcessMemory(iid) failed: %lu\n", GetLastError())); + goto finish; + } + + DETOUR_TRACE(("obBaseBef = %08lx..%08lx\n", + inh.IMPORT_DIRECTORY.VirtualAddress, + inh.IMPORT_DIRECTORY.VirtualAddress + inh.IMPORT_DIRECTORY.Size)); + DETOUR_TRACE(("obBaseAft = %08lx..%08lx\n", obBase, obBase + obStr)); + + // In this case the file didn't have an import directory in first place, + // so we couldn't fix the missing IAT above. We still need to explicitly + // provide an IAT to prevent to loader from looking for one. + // + if (inh.IAT_DIRECTORY.VirtualAddress == 0) { + inh.IAT_DIRECTORY.VirtualAddress = obBase; + inh.IAT_DIRECTORY.Size = cbNew; + } + + inh.IMPORT_DIRECTORY.VirtualAddress = obBase; + inh.IMPORT_DIRECTORY.Size = cbNew; + + /////////////////////// Update the NT header for the new import directory. + // + if (!DetourVirtualProtectSameExecuteEx(hProcess, pbModule, inh.OptionalHeader.SizeOfHeaders, + PAGE_EXECUTE_READWRITE, &dwProtect)) { + DETOUR_TRACE(("VirtualProtectEx(inh) write failed: %lu\n", GetLastError())); + goto finish; + } + + inh.OptionalHeader.CheckSum = 0; + + if (!WriteProcessMemory(hProcess, pbModule, &idh, sizeof(idh), NULL)) { + DETOUR_TRACE(("WriteProcessMemory(idh) failed: %lu\n", GetLastError())); + goto finish; + } + DETOUR_TRACE(("WriteProcessMemory(idh:%p..%p)\n", pbModule, pbModule + sizeof(idh))); + + if (!WriteProcessMemory(hProcess, pbModule + idh.e_lfanew, &inh, sizeof(inh), NULL)) { + DETOUR_TRACE(("WriteProcessMemory(inh) failed: %lu\n", GetLastError())); + goto finish; + } + DETOUR_TRACE(("WriteProcessMemory(inh:%p..%p)\n", + pbModule + idh.e_lfanew, + pbModule + idh.e_lfanew + sizeof(inh))); + + if (!VirtualProtectEx(hProcess, pbModule, inh.OptionalHeader.SizeOfHeaders, + dwProtect, &dwProtect)) { + DETOUR_TRACE(("VirtualProtectEx(idh) restore failed: %lu\n", GetLastError())); + goto finish; + } + + fSucceeded = TRUE; + goto finish; +} diff --git a/r5dev/thirdparty/lzham/include/lzham_assert.h b/r5dev/thirdparty/lzham/include/lzham_assert.h new file mode 100644 index 00000000..d8a68515 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_assert.h @@ -0,0 +1,40 @@ +// File: lzham_assert.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +const unsigned int LZHAM_FAIL_EXCEPTION_CODE = 256U; +void lzham_enable_fail_exceptions(bool enabled); + +void lzham_assert(const char* pExp, const char* pFile, unsigned line); +void lzham_fail(const char* pExp, const char* pFile, unsigned line); + +#ifdef NDEBUG + #define LZHAM_ASSERT(x) ((void)0) +#else + #define LZHAM_ASSERT(_exp) (void)( (!!(_exp)) || (lzham_assert(#_exp, __FILE__, __LINE__), 0) ) + #define LZHAM_ASSERTS_ENABLED 1 +#endif + +#define LZHAM_VERIFY(_exp) (void)( (!!(_exp)) || (lzham_assert(#_exp, __FILE__, __LINE__), 0) ) + +#define LZHAM_FAIL(msg) do { lzham_fail(#msg, __FILE__, __LINE__); } while(0) + +#define LZHAM_ASSERT_OPEN_RANGE(x, l, h) LZHAM_ASSERT((x >= l) && (x < h)) +#define LZHAM_ASSERT_CLOSED_RANGE(x, l, h) LZHAM_ASSERT((x >= l) && (x <= h)) + +void lzham_trace(const char* pFmt, va_list args); +void lzham_trace(const char* pFmt, ...); + +// Borrowed from boost libraries. +template struct assume_failure; +template <> struct assume_failure { enum { blah = 1 }; }; +template struct assume_try { }; + +#define LZHAM_JOINER_FINAL(a, b) a##b +#define LZHAM_JOINER(a, b) LZHAM_JOINER_FINAL(a, b) +#define LZHAM_JOIN(a, b) LZHAM_JOINER(a, b) +#if defined(__GNUC__) + #define LZHAM_ASSUME(p) typedef assume_try < sizeof(assume_failure< (bool)(p) > ) > LZHAM_JOIN(assume_typedef, __COUNTER__) __attribute__((unused)) +#else + #define LZHAM_ASSUME(p) typedef assume_try < sizeof(assume_failure< (bool)(p) > ) > LZHAM_JOIN(assume_typedef, __COUNTER__) +#endif diff --git a/r5dev/thirdparty/lzham/include/lzham_checksum.h b/r5dev/thirdparty/lzham/include/lzham_checksum.h new file mode 100644 index 00000000..515f3389 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_checksum.h @@ -0,0 +1,13 @@ +// File: lzham_checksum.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + const uint cInitAdler32 = 1U; + uint adler32(const void* pBuf, size_t buflen, uint adler32 = cInitAdler32); + + const uint cInitCRC32 = 0U; + uint crc32(uint crc, const lzham_uint8 *ptr, size_t buf_len); + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_config.h b/r5dev/thirdparty/lzham/include/lzham_config.h new file mode 100644 index 00000000..e250c7ce --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_config.h @@ -0,0 +1,23 @@ +// File: lzham_config.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +#ifdef _DEBUG + #define LZHAM_BUILD_DEBUG + + #ifndef DEBUG + #define DEBUG + #endif +#else + #define LZHAM_BUILD_RELEASE + + #ifndef NDEBUG + #define NDEBUG + #endif + + #ifdef DEBUG + #error DEBUG cannot be defined in LZHAM_BUILD_RELEASE + #endif +#endif +#define LZHAM_BUFFERED_PRINTF 0 +#define LZHAM_PERF_SECTIONS 0 \ No newline at end of file diff --git a/r5dev/thirdparty/lzham/include/lzham_core.h b/r5dev/thirdparty/lzham/include/lzham_core.h new file mode 100644 index 00000000..3d4f3d3e --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_core.h @@ -0,0 +1,170 @@ +// File: lzham_core.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once +#include "core/stdafx.h" + +#if defined(_MSC_VER) + #pragma warning (disable: 4127) // conditional expression is constant +#endif + +#if defined(_XBOX) && !defined(LZHAM_ANSI_CPLUSPLUS) + // X360 + #include + #define _HAS_EXCEPTIONS 0 + #define NOMINMAX + + #define LZHAM_PLATFORM_X360 1 + #define LZHAM_USE_WIN32_API 1 + #define LZHAM_USE_WIN32_ATOMIC_FUNCTIONS 1 + #define LZHAM_64BIT_POINTERS 0 + #define LZHAM_CPU_HAS_64BIT_REGISTERS 1 + #define LZHAM_BIG_ENDIAN_CPU 1 + #define LZHAM_USE_UNALIGNED_INT_LOADS 1 + #define LZHAM_RESTRICT __restrict + #define LZHAM_FORCE_INLINE __forceinline + #define LZHAM_NOTE_UNUSED(x) (void)x + +#elif defined(WIN32) && !defined(LZHAM_ANSI_CPLUSPLUS) + // MSVC or MinGW, x86 or x64, Win32 API's for threading and Win32 Interlocked API's or GCC built-ins for atomic ops. + #ifdef NDEBUG + // Ensure checked iterators are disabled. + #define _SECURE_SCL 0 + #define _HAS_ITERATOR_DEBUGGING 0 + #endif + #ifndef _DLL + // If we're using the DLL form of the run-time libs, we're also going to be enabling exceptions because we'll be building CLR apps. + // Otherwise, we disable exceptions for a small speed boost. + //#define _HAS_EXCEPTIONS 0 + #endif + #define NOMINMAX + + #ifndef _WIN32_WINNT + #define _WIN32_WINNT 0x500 + #endif + + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN + #endif + + #include + + #define LZHAM_USE_WIN32_API 1 + + #if defined(__MINGW32__) || defined(__MINGW64__) + #define LZHAM_USE_GCC_ATOMIC_BUILTINS 1 + #else + #define LZHAM_USE_WIN32_ATOMIC_FUNCTIONS 1 + #endif + + #define LZHAM_PLATFORM_PC 1 + + #ifdef _WIN64 + #define LZHAM_PLATFORM_PC_X64 1 + #define LZHAM_64BIT_POINTERS 1 + #define LZHAM_CPU_HAS_64BIT_REGISTERS 1 + #define LZHAM_LITTLE_ENDIAN_CPU 1 + #else + #define LZHAM_PLATFORM_PC_X86 1 + #define LZHAM_64BIT_POINTERS 0 + #define LZHAM_CPU_HAS_64BIT_REGISTERS 0 + #define LZHAM_LITTLE_ENDIAN_CPU 1 + #endif + + #define LZHAM_USE_UNALIGNED_INT_LOADS 1 + #define LZHAM_RESTRICT __restrict + #define LZHAM_FORCE_INLINE __forceinline + + #if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__) + #define LZHAM_USE_MSVC_INTRINSICS 1 + #endif + + #define LZHAM_NOTE_UNUSED(x) (void)x + +#elif defined(__GNUC__) && !defined(LZHAM_ANSI_CPLUSPLUS) + // GCC x86 or x64, pthreads for threading and GCC built-ins for atomic ops. + #define LZHAM_PLATFORM_PC 1 + + #if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__) + #define LZHAM_PLATFORM_PC_X64 1 + #define LZHAM_64BIT_POINTERS 1 + #define LZHAM_CPU_HAS_64BIT_REGISTERS 1 + #else + #define LZHAM_PLATFORM_PC_X86 1 + #define LZHAM_64BIT_POINTERS 0 + #define LZHAM_CPU_HAS_64BIT_REGISTERS 0 + #endif + + #define LZHAM_USE_UNALIGNED_INT_LOADS 1 + + #define LZHAM_LITTLE_ENDIAN_CPU 1 + + #define LZHAM_USE_PTHREADS_API 1 + #define LZHAM_USE_GCC_ATOMIC_BUILTINS 1 + + #define LZHAM_RESTRICT + + #if defined(__clang__) + #define LZHAM_FORCE_INLINE inline + #else + #define LZHAM_FORCE_INLINE inline __attribute__((__always_inline__,__gnu_inline__)) + #endif + + #define LZHAM_NOTE_UNUSED(x) (void)x +#else + // Vanilla ANSI-C/C++ + // No threading support, unaligned loads are NOT okay. + #if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__) + #define LZHAM_64BIT_POINTERS 1 + #define LZHAM_CPU_HAS_64BIT_REGISTERS 1 + #else + #define LZHAM_64BIT_POINTERS 0 + #define LZHAM_CPU_HAS_64BIT_REGISTERS 0 + #endif + + #define LZHAM_USE_UNALIGNED_INT_LOADS 0 + + #if __BIG_ENDIAN__ + #define LZHAM_BIG_ENDIAN_CPU 1 + #else + #define LZHAM_LITTLE_ENDIAN_CPU 1 + #endif + + #define LZHAM_USE_GCC_ATOMIC_BUILTINS 0 + #define LZHAM_USE_WIN32_ATOMIC_FUNCTIONS 0 + + #define LZHAM_RESTRICT + #define LZHAM_FORCE_INLINE inline + + #define LZHAM_NOTE_UNUSED(x) (void)x +#endif + +#if LZHAM_LITTLE_ENDIAN_CPU + const bool c_lzham_little_endian_platform = true; +#else + const bool c_lzham_little_endian_platform = false; +#endif + +const bool c_lzham_big_endian_platform = !c_lzham_little_endian_platform; + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "lzham.h" +#include "lzham_config.h" +#include "lzham_types.h" +#include "lzham_assert.h" +#include "lzham_platform.h" + +#include "lzham_helpers.h" +#include "lzham_traits.h" +#include "lzham_mem.h" +#include "lzham_math.h" +#include "lzham_utils.h" +#include "lzham_vector.h" diff --git a/r5dev/thirdparty/lzham/include/lzham_helpers.h b/r5dev/thirdparty/lzham/include/lzham_helpers.h new file mode 100644 index 00000000..11e0a119 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_helpers.h @@ -0,0 +1,54 @@ +// File: lzham_helpers.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +#define LZHAM_NO_COPY_OR_ASSIGNMENT_OP(c) c(const c&); c& operator= (const c&); + +namespace lzham +{ + namespace helpers + { + template struct rel_ops + { + friend inline bool operator!=(const T& x, const T& y) { return (!(x == y)); } + friend inline bool operator> (const T& x, const T& y) { return (y < x); } + friend inline bool operator<=(const T& x, const T& y) { return (!(y < x)); } + friend inline bool operator>=(const T& x, const T& y) { return (!(x < y)); } + }; + + template + inline T* construct(T* p) + { + return new (static_cast(p)) T; + } + + template + inline T* construct(T* p, const U& init) + { + return new (static_cast(p)) T(init); + } + + template + inline void construct_array(T* p, uint n); + + template + inline void construct_array(T* p, uint n, const U& init) + { + T* q = p + n; + for ( ; p != q; ++p) + new (static_cast(p)) T(init); + } + + template + inline void destruct(T* p) + { + LZHAM_NOTE_UNUSED(p); + p->~T(); + } + + template + inline void destruct_array(T* p, uint n); + + } // namespace helpers + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_huffman_codes.h b/r5dev/thirdparty/lzham/include/lzham_huffman_codes.h new file mode 100644 index 00000000..caab1a68 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_huffman_codes.h @@ -0,0 +1,14 @@ +// File: lzham_huffman_codes.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + //const uint cHuffmanMaxSupportedSyms = 600; + const uint cHuffmanMaxSupportedSyms = 1024; + + uint get_generate_huffman_codes_table_size(); + + bool generate_huffman_codes(void* pContext, uint num_syms, const uint16* pFreq, uint8* pCodesizes, uint& max_code_size, uint& total_freq_ret); + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_lzbase.h b/r5dev/thirdparty/lzham/include/lzham_lzbase.h new file mode 100644 index 00000000..8904ddd4 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_lzbase.h @@ -0,0 +1,45 @@ +// File: lzham_lzbase.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +#include "../lzhamdecomp/lzham_lzdecompbase.h" + +//#define LZHAM_LZVERIFY +//#define LZHAM_DISABLE_RAW_BLOCKS + +namespace lzham +{ + struct CLZBase : CLZDecompBase + { + uint8 m_slot_tab0[4096]; + uint8 m_slot_tab1[512]; + uint8 m_slot_tab2[256]; + + void init_slot_tabs(); + + inline void compute_lzx_position_slot(uint dist, uint& slot, uint& ofs) + { + uint s; + if (dist < 0x1000) + s = m_slot_tab0[dist]; + else if (dist < 0x100000) + s = m_slot_tab1[dist >> 11]; + else if (dist < 0x1000000) + s = m_slot_tab2[dist >> 16]; + else if (dist < 0x2000000) + s = 48 + ((dist - 0x1000000) >> 23); + else if (dist < 0x4000000) + s = 50 + ((dist - 0x2000000) >> 24); + else + s = 52 + ((dist - 0x4000000) >> 25); + + ofs = (dist - m_lzx_position_base[s]) & m_lzx_position_extra_mask[s]; + slot = s; + + LZHAM_ASSERT(s < m_num_lzx_slots); + LZHAM_ASSERT((m_lzx_position_base[slot] + ofs) == dist); + LZHAM_ASSERT(ofs < (1U << m_lzx_position_extra_bits[slot])); + } + }; + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_match_accel.h b/r5dev/thirdparty/lzham/include/lzham_match_accel.h new file mode 100644 index 00000000..384ea7dd --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_match_accel.h @@ -0,0 +1,146 @@ +// File: lzham_match_accel.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once +#include "lzham_lzbase.h" +#include "lzham_threading.h" + +namespace lzham +{ + const uint cMatchAccelMaxSupportedProbes = 128; + + struct node + { + uint m_left; + uint m_right; + }; + + LZHAM_DEFINE_BITWISE_MOVABLE(node); + +#pragma pack(push, 1) + struct dict_match + { + uint m_dist; + uint16 m_len; + + inline uint get_dist() const { return m_dist & 0x7FFFFFFF; } + inline uint get_len() const { return m_len + 2; } + inline bool is_last() const { return (int)m_dist < 0; } + }; +#pragma pack(pop) + + LZHAM_DEFINE_BITWISE_MOVABLE(dict_match); + + class search_accelerator + { + public: + search_accelerator(); + + // If all_matches is true, the match finder returns all found matches with no filtering. + // Otherwise, the finder will tend to return lists of matches with mostly unique lengths. + // For each length, it will discard matches with worse distances (in the coding sense). + bool init(CLZBase* pLZBase, task_pool* pPool, uint max_helper_threads, uint max_dict_size, uint max_matches, bool all_matches, uint max_probes); + + void reset(); + void flush(); + + inline uint get_max_dict_size() const { return m_max_dict_size; } + inline uint get_max_dict_size_mask() const { return m_max_dict_size_mask; } + inline uint get_cur_dict_size() const { return m_cur_dict_size; } + + inline uint get_lookahead_pos() const { return m_lookahead_pos; } + inline uint get_lookahead_size() const { return m_lookahead_size; } + + inline uint get_char(int delta_pos) const { return m_dict[(m_lookahead_pos + delta_pos) & m_max_dict_size_mask]; } + inline uint get_char(uint cur_dict_pos, int delta_pos) const { return m_dict[(cur_dict_pos + delta_pos) & m_max_dict_size_mask]; } + inline const uint8* get_ptr(uint pos) const { return &m_dict[pos]; } + + uint get_max_helper_threads() const { return m_max_helper_threads; } + + inline uint operator[](uint pos) const { return m_dict[pos]; } + + uint get_max_add_bytes() const; + bool add_bytes_begin(uint num_bytes, const uint8* pBytes); + inline atomic32_t get_num_completed_helper_threads() const { return m_num_completed_helper_threads; } + void add_bytes_end(); + + // Returns the lookahead's raw position/size/dict_size at the time add_bytes_begin() is called. + inline uint get_fill_lookahead_pos() const { return m_fill_lookahead_pos; } + inline uint get_fill_lookahead_size() const { return m_fill_lookahead_size; } + inline uint get_fill_dict_size() const { return m_fill_dict_size; } + + uint get_len2_match(uint lookahead_ofs); + dict_match* find_matches(uint lookahead_ofs, bool spin = true); + + void advance_bytes(uint num_bytes); + + LZHAM_FORCE_INLINE uint get_match_len(uint lookahead_ofs, int dist, uint max_match_len, uint start_match_len = 0) const + { + LZHAM_ASSERT(lookahead_ofs < m_lookahead_size); + LZHAM_ASSERT(start_match_len <= max_match_len); + LZHAM_ASSERT(max_match_len <= (get_lookahead_size() - lookahead_ofs)); + + const int find_dict_size = m_cur_dict_size + lookahead_ofs; + if (dist > find_dict_size) + return 0; + + const uint comp_pos = static_cast((m_lookahead_pos + lookahead_ofs - dist) & m_max_dict_size_mask); + const uint lookahead_pos = (m_lookahead_pos + lookahead_ofs) & m_max_dict_size_mask; + + const uint8* pComp = &m_dict[comp_pos]; + const uint8* pLookahead = &m_dict[lookahead_pos]; + + uint match_len; + for (match_len = start_match_len; match_len < max_match_len; match_len++) + if (pComp[match_len] != pLookahead[match_len]) + break; + + return match_len; + } + + public: + CLZBase* m_pLZBase; + task_pool* m_pTask_pool; + uint m_max_helper_threads; + + uint m_max_dict_size; + uint m_max_dict_size_mask; + + uint m_lookahead_pos; + uint m_lookahead_size; + + uint m_cur_dict_size; + + lzham::vector m_dict; + + enum { cHashSize = 65536 }; + lzham::vector m_hash; + lzham::vector m_nodes; + + lzham::vector m_matches; + lzham::vector m_match_refs; + + lzham::vector m_hash_thread_index; + + enum { cDigramHashSize = 4096 }; + lzham::vector m_digram_hash; + lzham::vector m_digram_next; + + uint m_fill_lookahead_pos; + uint m_fill_lookahead_size; + uint m_fill_dict_size; + + uint m_max_probes; + uint m_max_matches; + + bool m_all_matches; + + volatile atomic32_t m_next_match_ref; + + volatile atomic32_t m_num_completed_helper_threads; + + void find_all_matches_callback(uint64 data, void* pData_ptr); + bool find_all_matches(uint num_bytes); + bool find_len2_matches(); + }; + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_math.h b/r5dev/thirdparty/lzham/include/lzham_math.h new file mode 100644 index 00000000..299f299b --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_math.h @@ -0,0 +1,113 @@ +// File: lzham_math.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +#if defined(LZHAM_USE_MSVC_INTRINSICS) && !defined(__MINGW32__) + #include + #if defined(_MSC_VER) + #pragma intrinsic(_BitScanReverse) + #endif +#endif + +namespace lzham +{ + namespace math + { + // Yes I know these should probably be pass by ref, not val: + // http://www.stepanovpapers.com/notes.pdf + // Just don't use them on non-simple (non built-in) types! + template inline T minimum(T a, T b) { return (a < b) ? a : b; } + + template inline T minimum(T a, T b, T c) { return minimum(minimum(a, b), c); } + + template inline T maximum(T a, T b) { return (a > b) ? a : b; } + + template inline T maximum(T a, T b, T c) { return maximum(maximum(a, b), c); } + + template inline T clamp(T value, T low, T high) { return (value < low) ? low : ((value > high) ? high : value); } + + inline bool is_power_of_2(uint32 x) { return x && ((x & (x - 1U)) == 0U); } + inline bool is_power_of_2(uint64 x) { return x && ((x & (x - 1U)) == 0U); } + + template inline T align_up_pointer(T p, uint alignment) + { + LZHAM_ASSERT(is_power_of_2(alignment)); + ptr_bits_t q = reinterpret_cast(p); + q = (q + alignment - 1) & (~((uint_ptr)alignment - 1)); + return reinterpret_cast(q); + } + + // From "Hackers Delight" + // val remains unchanged if it is already a power of 2. + inline uint32 next_pow2(uint32 val) + { + val--; + val |= val >> 16; + val |= val >> 8; + val |= val >> 4; + val |= val >> 2; + val |= val >> 1; + return val + 1; + } + + // val remains unchanged if it is already a power of 2. + inline uint64 next_pow2(uint64 val) + { + val--; + val |= val >> 32; + val |= val >> 16; + val |= val >> 8; + val |= val >> 4; + val |= val >> 2; + val |= val >> 1; + return val + 1; + } + + inline uint floor_log2i(uint v) + { + uint l = 0; + while (v > 1U) + { + v >>= 1; + l++; + } + return l; + } + + inline uint ceil_log2i(uint v) + { + uint l = floor_log2i(v); + if ((l != cIntBits) && (v > (1U << l))) + l++; + return l; + } + + // Returns the total number of bits needed to encode v. + // This needs to be fast - it's used heavily when determining Polar codelengths. + inline uint total_bits(uint v) + { + unsigned long l = 0; +#if defined(__MINGW32__) + if (v) + { + l = 32 -__builtin_clz(v); + } +#elif defined(LZHAM_USE_MSVC_INTRINSICS) + if (_BitScanReverse(&l, v)) + { + l++; + } +#else + while (v > 0U) + { + v >>= 1; + l++; + } +#endif + return l; + } + + } + +} // namespace lzham + diff --git a/r5dev/thirdparty/lzham/include/lzham_mem.h b/r5dev/thirdparty/lzham/include/lzham_mem.h new file mode 100644 index 00000000..d258efff --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_mem.h @@ -0,0 +1,112 @@ +// File: lzham_mem.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + void lzham_mem_init(); + + void* lzham_malloc(size_t size, size_t* pActual_size = NULL); + void* lzham_realloc(void* p, size_t size, size_t* pActual_size = NULL, bool movable = true); + void lzham_free(void* p); + size_t lzham_msize(void* p); + + template + inline T* lzham_new() + { + T* p = static_cast(lzham_malloc(sizeof(T))); + if (!p) return NULL; + if (LZHAM_IS_SCALAR_TYPE(T)) + return p; + return helpers::construct(p); + } + + template + inline T* lzham_new(const A& init0) + { + T* p = static_cast(lzham_malloc(sizeof(T))); + if (!p) return NULL; + return new (static_cast(p)) T(init0); + } + + template + inline T* lzham_new(const A& init0, const B& init1) + { + T* p = static_cast(lzham_malloc(sizeof(T))); + if (!p) return NULL; + return new (static_cast(p)) T(init0, init1); + } + + template + inline T* lzham_new(const A& init0, const B& init1, const C& init2) + { + T* p = static_cast(lzham_malloc(sizeof(T))); + if (!p) return NULL; + return new (static_cast(p)) T(init0, init1, init2); + } + + template + inline T* lzham_new(const A& init0, const B& init1, const C& init2, const D& init3) + { + T* p = static_cast(lzham_malloc(sizeof(T))); + if (!p) return NULL; + return new (static_cast(p)) T(init0, init1, init2, init3); + } + + template + inline T* lzham_new_array(uint32 num) + { + if (!num) num = 1; + + uint8* q = static_cast(lzham_malloc(LZHAM_MIN_ALLOC_ALIGNMENT + sizeof(T) * num)); + if (!q) + return NULL; + + T* p = reinterpret_cast(q + LZHAM_MIN_ALLOC_ALIGNMENT); + + reinterpret_cast(p)[-1] = num; + reinterpret_cast(p)[-2] = ~num; + + if (!LZHAM_IS_SCALAR_TYPE(T)) + { + helpers::construct_array(p, num); + } + return p; + } + + template + inline void lzham_delete(T* p) + { + if (p) + { + if (!LZHAM_IS_SCALAR_TYPE(T)) + { + helpers::destruct(p); + } + lzham_free(p); + } + } + + template + inline void lzham_delete_array(T* p) + { + if (p) + { + const uint32 num = reinterpret_cast(p)[-1]; + const uint32 num_check = reinterpret_cast(p)[-2]; + LZHAM_ASSERT(num && (num == ~num_check)); + if (num == ~num_check) + { + if (!LZHAM_IS_SCALAR_TYPE(T)) + { + helpers::destruct_array(p, num); + } + + lzham_free(reinterpret_cast(p) - LZHAM_MIN_ALLOC_ALIGNMENT); + } + } + } + + void lzham_print_mem_stats(); + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_null_threading.h b/r5dev/thirdparty/lzham/include/lzham_null_threading.h new file mode 100644 index 00000000..00fb0337 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_null_threading.h @@ -0,0 +1,97 @@ +// File: lzham_task_pool_null.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + class semaphore + { + LZHAM_NO_COPY_OR_ASSIGNMENT_OP(semaphore); + + public: + inline semaphore(long initialCount = 0, long maximumCount = 1, const char* pName = NULL) + { + initialCount, maximumCount, pName; + } + + inline ~semaphore() + { + } + + inline void release(long releaseCount = 1, long *pPreviousCount = NULL) + { + releaseCount, pPreviousCount; + } + + inline bool wait(uint32 milliseconds = UINT32_MAX) + { + milliseconds; + return true; + } + }; + + class task_pool + { + public: + inline task_pool() { } + inline task_pool(uint num_threads) { num_threads; } + inline ~task_pool() { } + + inline bool init(uint num_threads) { num_threads; return true; } + inline void deinit(); + + inline uint get_num_threads() const { return 0; } + inline uint get_num_outstanding_tasks() const { return 0; } + + // C-style task callback + typedef void (*task_callback_func)(uint64 data, void* pData_ptr); + inline bool queue_task(task_callback_func pFunc, uint64 data = 0, void* pData_ptr = NULL) + { + pFunc(data, pData_ptr); + return true; + } + + class executable_task + { + public: + virtual void execute_task(uint64 data, void* pData_ptr) = 0; + }; + + // It's the caller's responsibility to delete pObj within the execute_task() method, if needed! + inline bool queue_task(executable_task* pObj, uint64 data = 0, void* pData_ptr = NULL) + { + pObj->execute_task(data, pData_ptr); + return true; + } + + template + inline bool queue_object_task(S* pObject, T pObject_method, uint64 data = 0, void* pData_ptr = NULL) + { + (pObject->*pObject_method)(data, pData_ptr); + return true; + } + + template + inline bool queue_multiple_object_tasks(S* pObject, T pObject_method, uint64 first_data, uint num_tasks, void* pData_ptr = NULL) + { + for (uint i = 0; i < num_tasks; i++) + { + (pObject->*pObject_method)(first_data + i, pData_ptr); + } + return true; + } + + void join() { } + }; + + inline void lzham_sleep(unsigned int milliseconds) + { + milliseconds; + } + + inline uint lzham_get_max_helper_threads() + { + return 0; + } + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_platform.h b/r5dev/thirdparty/lzham/include/lzham_platform.h new file mode 100644 index 00000000..0cc58beb --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_platform.h @@ -0,0 +1,284 @@ +// File: lzham_platform.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +bool lzham_is_debugger_present(void); +void lzham_debug_break(void); +void lzham_output_debug_string(const char* p); + +// actually in lzham_assert.cpp +void lzham_assert(const char* pExp, const char* pFile, unsigned line); +void lzham_fail(const char* pExp, const char* pFile, unsigned line); + +#ifdef WIN32 + #define LZHAM_BREAKPOINT DebuggerBreak(); + #define LZHAM_BUILTIN_EXPECT(c, v) c +#elif defined(__GNUC__) + #define LZHAM_BREAKPOINT asm("int $3"); + #define LZHAM_BUILTIN_EXPECT(c, v) __builtin_expect(c, v) +#else + #define LZHAM_BREAKPOINT + #define LZHAM_BUILTIN_EXPECT(c, v) c +#endif + +#if defined(__GNUC__) && LZHAM_PLATFORM_PC +extern __inline__ __attribute__((__always_inline__,__gnu_inline__)) void lzham_yield_processor() +{ + __asm__ __volatile__("pause"); +} +#elif LZHAM_PLATFORM_X360 +#define lzham_yield_processor() \ + YieldProcessor(); \ + __asm { or r0, r0, r0 } \ + YieldProcessor(); \ + __asm { or r1, r1, r1 } \ + YieldProcessor(); \ + __asm { or r0, r0, r0 } \ + YieldProcessor(); \ + __asm { or r1, r1, r1 } \ + YieldProcessor(); \ + __asm { or r0, r0, r0 } \ + YieldProcessor(); \ + __asm { or r1, r1, r1 } \ + YieldProcessor(); \ + __asm { or r0, r0, r0 } \ + YieldProcessor(); \ + __asm { or r1, r1, r1 } +#else +LZHAM_FORCE_INLINE void lzham_yield_processor() +{ +#if LZHAM_USE_MSVC_INTRINSICS + #if LZHAM_PLATFORM_PC_X64 + _mm_pause(); + #else + YieldProcessor(); + #endif +#else + // No implementation +#endif +} +#endif + +#ifndef _MSC_VER + int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...); + int vsprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, va_list args); +#endif + +#if LZHAM_PLATFORM_X360 + #define LZHAM_MEMORY_EXPORT_BARRIER MemoryBarrier(); +#else + // Barriers shouldn't be necessary on x86/x64. + // TODO: Should use __sync_synchronize() on other platforms that support GCC. + #define LZHAM_MEMORY_EXPORT_BARRIER +#endif + +#if LZHAM_PLATFORM_X360 + #define LZHAM_MEMORY_IMPORT_BARRIER MemoryBarrier(); +#else + // Barriers shouldn't be necessary on x86/x64. + // TODO: Should use __sync_synchronize() on other platforms that support GCC. + #define LZHAM_MEMORY_IMPORT_BARRIER +#endif + +// Note: It's very important that LZHAM_READ_BIG_ENDIAN_UINT32() is fast on the target platform. +// This is used to read every DWORD from the input stream. + +#if LZHAM_USE_UNALIGNED_INT_LOADS + #if LZHAM_BIG_ENDIAN_CPU + #define LZHAM_READ_BIG_ENDIAN_UINT32(p) *reinterpret_cast(p) + #else + #if defined(LZHAM_USE_MSVC_INTRINSICS) + #define LZHAM_READ_BIG_ENDIAN_UINT32(p) _byteswap_ulong(*reinterpret_cast(p)) + #elif defined(__GNUC__) + #define LZHAM_READ_BIG_ENDIAN_UINT32(p) __builtin_bswap32(*reinterpret_cast(p)) + #else + #define LZHAM_READ_BIG_ENDIAN_UINT32(p) utils::swap32(*reinterpret_cast(p)) + #endif + #endif +#else + #define LZHAM_READ_BIG_ENDIAN_UINT32(p) ((reinterpret_cast(p)[0] << 24) | (reinterpret_cast(p)[1] << 16) | (reinterpret_cast(p)[2] << 8) | (reinterpret_cast(p)[3])) +#endif + +#if LZHAM_USE_WIN32_ATOMIC_FUNCTIONS + extern "C" __int64 _InterlockedCompareExchange64(__int64 volatile * Destination, __int64 Exchange, __int64 Comperand); + #if defined(_MSC_VER) + #pragma intrinsic(_InterlockedCompareExchange64) + #endif +#endif // LZHAM_USE_WIN32_ATOMIC_FUNCTIONS + +namespace lzham +{ +#if LZHAM_USE_WIN32_ATOMIC_FUNCTIONS + typedef LONG atomic32_t; + typedef LONGLONG atomic64_t; + + // Returns the original value. + inline atomic32_t atomic_compare_exchange32(atomic32_t volatile *pDest, atomic32_t exchange, atomic32_t comparand) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return InterlockedCompareExchange(pDest, exchange, comparand); + } + + // Returns the original value. + inline atomic64_t atomic_compare_exchange64(atomic64_t volatile *pDest, atomic64_t exchange, atomic64_t comparand) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 7) == 0); + return _InterlockedCompareExchange64(pDest, exchange, comparand); + } + + // Returns the resulting incremented value. + inline atomic32_t atomic_increment32(atomic32_t volatile *pDest) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return InterlockedIncrement(pDest); + } + + // Returns the resulting decremented value. + inline atomic32_t atomic_decrement32(atomic32_t volatile *pDest) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return InterlockedDecrement(pDest); + } + + // Returns the original value. + inline atomic32_t atomic_exchange32(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return InterlockedExchange(pDest, val); + } + + // Returns the resulting value. + inline atomic32_t atomic_add32(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return InterlockedExchangeAdd(pDest, val) + val; + } + + // Returns the original value. + inline atomic32_t atomic_exchange_add(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return InterlockedExchangeAdd(pDest, val); + } +#elif LZHAM_USE_GCC_ATOMIC_BUILTINS + typedef long atomic32_t; + typedef long long atomic64_t; + + // Returns the original value. + inline atomic32_t atomic_compare_exchange32(atomic32_t volatile *pDest, atomic32_t exchange, atomic32_t comparand) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return __sync_val_compare_and_swap(pDest, comparand, exchange); + } + + // Returns the original value. + inline atomic64_t atomic_compare_exchange64(atomic64_t volatile *pDest, atomic64_t exchange, atomic64_t comparand) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 7) == 0); + return __sync_val_compare_and_swap(pDest, comparand, exchange); + } + + // Returns the resulting incremented value. + inline atomic32_t atomic_increment32(atomic32_t volatile *pDest) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return __sync_add_and_fetch(pDest, 1); + } + + // Returns the resulting decremented value. + inline atomic32_t atomic_decrement32(atomic32_t volatile *pDest) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return __sync_sub_and_fetch(pDest, 1); + } + + // Returns the original value. + inline atomic32_t atomic_exchange32(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return __sync_lock_test_and_set(pDest, val); + } + + // Returns the resulting value. + inline atomic32_t atomic_add32(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return __sync_add_and_fetch(pDest, val); + } + + // Returns the original value. + inline atomic32_t atomic_exchange_add(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return __sync_fetch_and_add(pDest, val); + } +#else + #define LZHAM_NO_ATOMICS 1 + + // Atomic ops not supported - but try to do something reasonable. Assumes no threading at all. + typedef long atomic32_t; + typedef long long atomic64_t; + + inline atomic32_t atomic_compare_exchange32(atomic32_t volatile *pDest, atomic32_t exchange, atomic32_t comparand) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + atomic32_t cur = *pDest; + if (cur == comparand) + *pDest = exchange; + return cur; + } + + inline atomic64_t atomic_compare_exchange64(atomic64_t volatile *pDest, atomic64_t exchange, atomic64_t comparand) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 7) == 0); + atomic64_t cur = *pDest; + if (cur == comparand) + *pDest = exchange; + return cur; + } + + inline atomic32_t atomic_increment32(atomic32_t volatile *pDest) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return (*pDest += 1); + } + + inline atomic32_t atomic_decrement32(atomic32_t volatile *pDest) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return (*pDest -= 1); + } + + inline atomic32_t atomic_exchange32(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + atomic32_t cur = *pDest; + *pDest = val; + return cur; + } + + inline atomic32_t atomic_add32(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + return (*pDest += val); + } + + inline atomic32_t atomic_exchange_add(atomic32_t volatile *pDest, atomic32_t val) + { + LZHAM_ASSERT((reinterpret_cast(pDest) & 3) == 0); + atomic32_t cur = *pDest; + *pDest += val; + return cur; + } + +#endif + +#if LZHAM_BUFFERED_PRINTF + void lzham_buffered_printf(const char *format, ...); + void lzham_flush_buffered_printf(); +#else + inline void lzham_buffered_printf(const char *format, ...) { (void)format; } + inline void lzham_flush_buffered_printf() { } +#endif + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_polar_codes.h b/r5dev/thirdparty/lzham/include/lzham_polar_codes.h new file mode 100644 index 00000000..c478d9d6 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_polar_codes.h @@ -0,0 +1,14 @@ +// File: lzham_polar_codes.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + //const uint cPolarMaxSupportedSyms = 600; + const uint cPolarMaxSupportedSyms = 1024; + + uint get_generate_polar_codes_table_size(); + + bool generate_polar_codes(void* pContext, uint num_syms, const uint16* pFreq, uint8* pCodesizes, uint& max_code_size, uint& total_freq_ret); + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_prefix_coding.h b/r5dev/thirdparty/lzham/include/lzham_prefix_coding.h new file mode 100644 index 00000000..a22903d6 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_prefix_coding.h @@ -0,0 +1,144 @@ +// File: lzham_prefix_coding.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + namespace prefix_coding + { + const uint cMaxExpectedCodeSize = 16; + const uint cMaxSupportedSyms = 1024; + const uint cMaxTableBits = 11; + + bool limit_max_code_size(uint num_syms, uint8* pCodesizes, uint max_code_size); + + bool generate_codes(uint num_syms, const uint8* pCodesizes, uint16* pCodes); + + class decoder_tables + { + public: + inline decoder_tables() : + m_table_shift(0), m_table_max_code(0), m_decode_start_code_size(0), m_cur_lookup_size(0), m_lookup(NULL), m_cur_sorted_symbol_order_size(0), m_sorted_symbol_order(NULL) + { + } + + inline decoder_tables(const decoder_tables& other) : + m_table_shift(0), m_table_max_code(0), m_decode_start_code_size(0), m_cur_lookup_size(0), m_lookup(NULL), m_cur_sorted_symbol_order_size(0), m_sorted_symbol_order(NULL) + { + *this = other; + } + + inline decoder_tables& operator= (const decoder_tables& rhs) + { + assign(rhs); + return *this; + } + + inline bool assign(const decoder_tables& rhs) + { + if (this == &rhs) + return true; + + uint32* pCur_lookup = m_lookup; + uint16* pCur_sorted_symbol_order = m_sorted_symbol_order; + + memcpy(this, &rhs, sizeof(*this)); + + if ((pCur_lookup) && (pCur_sorted_symbol_order) && (rhs.m_cur_lookup_size == m_cur_lookup_size) && (rhs.m_cur_sorted_symbol_order_size == m_cur_sorted_symbol_order_size)) + { + m_lookup = pCur_lookup; + m_sorted_symbol_order = pCur_sorted_symbol_order; + + memcpy(m_lookup, rhs.m_lookup, sizeof(m_lookup[0]) * m_cur_lookup_size); + memcpy(m_sorted_symbol_order, rhs.m_sorted_symbol_order, sizeof(m_sorted_symbol_order[0]) * m_cur_sorted_symbol_order_size); + } + else + { + lzham_delete_array(pCur_lookup); + m_lookup = NULL; + + if (rhs.m_lookup) + { + m_lookup = lzham_new_array(m_cur_lookup_size); + if (!m_lookup) + return false; + memcpy(m_lookup, rhs.m_lookup, sizeof(m_lookup[0]) * m_cur_lookup_size); + } + + lzham_delete_array(pCur_sorted_symbol_order); + m_sorted_symbol_order = NULL; + + if (rhs.m_sorted_symbol_order) + { + m_sorted_symbol_order = lzham_new_array(m_cur_sorted_symbol_order_size); + if (!m_sorted_symbol_order) + return false; + memcpy(m_sorted_symbol_order, rhs.m_sorted_symbol_order, sizeof(m_sorted_symbol_order[0]) * m_cur_sorted_symbol_order_size); + } + } + + return true; + } + + inline void clear() + { + if (m_lookup) + { + lzham_delete_array(m_lookup); + m_lookup = 0; + m_cur_lookup_size = 0; + } + + if (m_sorted_symbol_order) + { + lzham_delete_array(m_sorted_symbol_order); + m_sorted_symbol_order = NULL; + m_cur_sorted_symbol_order_size = 0; + } + } + + inline ~decoder_tables() + { + if (m_lookup) + lzham_delete_array(m_lookup); + + if (m_sorted_symbol_order) + lzham_delete_array(m_sorted_symbol_order); + } + + // DO NOT use any complex classes here - it is bitwise copied. + + uint m_num_syms; + uint m_total_used_syms; + uint m_table_bits; + uint m_table_shift; + uint m_table_max_code; + uint m_decode_start_code_size; + + uint8 m_min_code_size; + uint8 m_max_code_size; + + uint m_max_codes[cMaxExpectedCodeSize + 1]; + int m_val_ptrs[cMaxExpectedCodeSize + 1]; + + uint m_cur_lookup_size; + uint32* m_lookup; + + uint m_cur_sorted_symbol_order_size; + uint16* m_sorted_symbol_order; + + inline uint get_unshifted_max_code(uint len) const + { + LZHAM_ASSERT( (len >= 1) && (len <= cMaxExpectedCodeSize) ); + uint k = m_max_codes[len - 1]; + if (!k) + return UINT_MAX; + return (k - 1) >> (16 - len); + } + }; + + bool generate_decoder_tables(uint num_syms, const uint8* pCodesizes, decoder_tables* pTables, uint table_bits); + + } // namespace prefix_coding + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_pthreads_threading.h b/r5dev/thirdparty/lzham/include/lzham_pthreads_threading.h new file mode 100644 index 00000000..fe1de038 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_pthreads_threading.h @@ -0,0 +1,383 @@ +// File: lzham_task_pool_pthreads.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +#if LZHAM_USE_PTHREADS_API + +#if LZHAM_NO_ATOMICS +#error No atomic operations defined in lzham_platform.h! +#endif + +#include +#include +#include + +namespace lzham +{ + class semaphore + { + LZHAM_NO_COPY_OR_ASSIGNMENT_OP(semaphore); + + public: + inline semaphore(long initialCount = 0, long maximumCount = 1, const char* pName = NULL) + { + LZHAM_NOTE_UNUSED(maximumCount), LZHAM_NOTE_UNUSED(pName); + LZHAM_ASSERT(maximumCount >= initialCount); + if (sem_init(&m_sem, 0, initialCount)) + { + LZHAM_FAIL("semaphore: sem_init() failed"); + } + } + + inline ~semaphore() + { + sem_destroy(&m_sem); + } + + inline void release(long releaseCount = 1) + { + LZHAM_ASSERT(releaseCount >= 1); + + int status = 0; +#ifdef WIN32 + if (1 == releaseCount) + status = sem_post(&m_sem); + else + status = sem_post_multiple(&m_sem, releaseCount); +#else + while (releaseCount > 0) + { + status = sem_post(&m_sem); + if (status) + break; + releaseCount--; + } +#endif + + if (status) + { + LZHAM_FAIL("semaphore: sem_post() or sem_post_multiple() failed"); + } + } + + inline bool wait(uint32 milliseconds = UINT32_MAX) + { + int status; + if (milliseconds == UINT32_MAX) + { + status = sem_wait(&m_sem); + } + else + { + struct timespec interval; + interval.tv_sec = milliseconds / 1000; + interval.tv_nsec = (milliseconds % 1000) * 1000000L; + status = sem_timedwait(&m_sem, &interval); + } + + if (status) + { + if (errno != ETIMEDOUT) + { + LZHAM_FAIL("semaphore: sem_wait() or sem_timedwait() failed"); + } + return false; + } + + return true; + } + + private: + sem_t m_sem; + }; + + class spinlock + { + public: + inline spinlock() + { + if (pthread_spin_init(&m_spinlock, 0)) + { + LZHAM_FAIL("spinlock: pthread_spin_init() failed"); + } + } + + inline ~spinlock() + { + pthread_spin_destroy(&m_spinlock); + } + + inline void lock() + { + if (pthread_spin_lock(&m_spinlock)) + { + LZHAM_FAIL("spinlock: pthread_spin_lock() failed"); + } + } + + inline void unlock() + { + if (pthread_spin_unlock(&m_spinlock)) + { + LZHAM_FAIL("spinlock: pthread_spin_unlock() failed"); + } + } + + private: + pthread_spinlock_t m_spinlock; + }; + + template + class tsstack + { + public: + inline tsstack() : m_top(0) + { + } + + inline ~tsstack() + { + } + + inline void clear() + { + m_spinlock.lock(); + m_top = 0; + m_spinlock.unlock(); + } + + inline bool try_push(const T& obj) + { + bool result = false; + m_spinlock.lock(); + if (m_top < (int)cMaxSize) + { + m_stack[m_top++] = obj; + result = true; + } + m_spinlock.unlock(); + return result; + } + + inline bool pop(T& obj) + { + bool result = false; + m_spinlock.lock(); + if (m_top > 0) + { + obj = m_stack[--m_top]; + result = true; + } + m_spinlock.unlock(); + return result; + } + + private: + spinlock m_spinlock; + T m_stack[cMaxSize]; + int m_top; + }; + + class task_pool + { + public: + task_pool(); + task_pool(uint num_threads); + ~task_pool(); + + enum { cMaxThreads = LZHAM_MAX_HELPER_THREADS }; + bool init(uint num_threads); + void deinit(); + + inline uint get_num_threads() const { return m_num_threads; } + inline uint get_num_outstanding_tasks() const { return m_num_outstanding_tasks; } + + // C-style task callback + typedef void (*task_callback_func)(uint64 data, void* pData_ptr); + bool queue_task(task_callback_func pFunc, uint64 data = 0, void* pData_ptr = NULL); + + class executable_task + { + public: + virtual void execute_task(uint64 data, void* pData_ptr) = 0; + }; + + // It's the caller's responsibility to delete pObj within the execute_task() method, if needed! + bool queue_task(executable_task* pObj, uint64 data = 0, void* pData_ptr = NULL); + + template + inline bool queue_object_task(S* pObject, T pObject_method, uint64 data = 0, void* pData_ptr = NULL); + + template + inline bool queue_multiple_object_tasks(S* pObject, T pObject_method, uint64 first_data, uint num_tasks, void* pData_ptr = NULL); + + void join(); + + private: + struct task + { + inline task() : m_data(0), m_pData_ptr(NULL), m_pObj(NULL), m_flags(0) { } + + uint64 m_data; + void* m_pData_ptr; + + union + { + task_callback_func m_callback; + executable_task* m_pObj; + }; + + uint m_flags; + }; + + tsstack m_task_stack; + + uint m_num_threads; + pthread_t m_threads[cMaxThreads]; + + semaphore m_tasks_available; + + enum task_flags + { + cTaskFlagObject = 1 + }; + + volatile atomic32_t m_num_outstanding_tasks; + volatile atomic32_t m_exit_flag; + + void process_task(task& tsk); + + static void* thread_func(void *pContext); + }; + + enum object_task_flags + { + cObjectTaskFlagDefault = 0, + cObjectTaskFlagDeleteAfterExecution = 1 + }; + + template + class object_task : public task_pool::executable_task + { + public: + object_task(uint flags = cObjectTaskFlagDefault) : + m_pObject(NULL), + m_pMethod(NULL), + m_flags(flags) + { + } + + typedef void (T::*object_method_ptr)(uint64 data, void* pData_ptr); + + object_task(T* pObject, object_method_ptr pMethod, uint flags = cObjectTaskFlagDefault) : + m_pObject(pObject), + m_pMethod(pMethod), + m_flags(flags) + { + LZHAM_ASSERT(pObject && pMethod); + } + + void init(T* pObject, object_method_ptr pMethod, uint flags = cObjectTaskFlagDefault) + { + LZHAM_ASSERT(pObject && pMethod); + + m_pObject = pObject; + m_pMethod = pMethod; + m_flags = flags; + } + + T* get_object() const { return m_pObject; } + object_method_ptr get_method() const { return m_pMethod; } + + virtual void execute_task(uint64 data, void* pData_ptr) + { + (m_pObject->*m_pMethod)(data, pData_ptr); + + if (m_flags & cObjectTaskFlagDeleteAfterExecution) + lzham_delete(this); + } + + protected: + T* m_pObject; + + object_method_ptr m_pMethod; + + uint m_flags; + }; + + template + inline bool task_pool::queue_object_task(S* pObject, T pObject_method, uint64 data, void* pData_ptr) + { + object_task *pTask = lzham_new< object_task >(pObject, pObject_method, cObjectTaskFlagDeleteAfterExecution); + if (!pTask) + return false; + return queue_task(pTask, data, pData_ptr); + } + + template + inline bool task_pool::queue_multiple_object_tasks(S* pObject, T pObject_method, uint64 first_data, uint num_tasks, void* pData_ptr) + { + LZHAM_ASSERT(m_num_threads); + LZHAM_ASSERT(pObject); + LZHAM_ASSERT(num_tasks); + if (!num_tasks) + return true; + + bool status = true; + + uint i; + for (i = 0; i < num_tasks; i++) + { + task tsk; + + tsk.m_pObj = lzham_new< object_task >(pObject, pObject_method, cObjectTaskFlagDeleteAfterExecution); + if (!tsk.m_pObj) + { + status = false; + break; + } + + tsk.m_data = first_data + i; + tsk.m_pData_ptr = pData_ptr; + tsk.m_flags = cTaskFlagObject; + + if (!m_task_stack.try_push(tsk)) + { + status = false; + break; + } + } + + if (i) + { + atomic_add32(&m_num_outstanding_tasks, i); + + m_tasks_available.release(i); + } + + return status; + } + + inline void lzham_sleep(unsigned int milliseconds) + { +#ifdef WIN32 + struct timespec interval; + interval.tv_sec = milliseconds / 1000; + interval.tv_nsec = (milliseconds % 1000) * 1000000L; + pthread_delay_np(&interval); +#else + while (milliseconds) + { + int msecs_to_sleep = LZHAM_MIN(milliseconds, 1000); + usleep(msecs_to_sleep * 1000); + milliseconds -= msecs_to_sleep; + } +#endif + } + + // TODO: Implement + uint lzham_get_max_helper_threads(); + +} // namespace lzham + +#endif // LZHAM_USE_PTHREADS_API diff --git a/r5dev/thirdparty/lzham/include/lzham_symbol_codec.h b/r5dev/thirdparty/lzham/include/lzham_symbol_codec.h new file mode 100644 index 00000000..824a4c74 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_symbol_codec.h @@ -0,0 +1,556 @@ +// File: lzham_symbol_codec.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once +#include "lzham_prefix_coding.h" + +namespace lzham +{ + class symbol_codec; + class adaptive_arith_data_model; + + const uint cSymbolCodecArithMinLen = 0x01000000U; + const uint cSymbolCodecArithMaxLen = 0xFFFFFFFFU; + + const uint cSymbolCodecArithProbBits = 11; + const uint cSymbolCodecArithProbScale = 1 << cSymbolCodecArithProbBits; + const uint cSymbolCodecArithProbHalfScale = 1 << (cSymbolCodecArithProbBits - 1); + const uint cSymbolCodecArithProbMoveBits = 5; + + typedef uint64 bit_cost_t; + const uint32 cBitCostScaleShift = 24; + const uint32 cBitCostScale = (1U << cBitCostScaleShift); + const bit_cost_t cBitCostMax = UINT64_MAX; + + inline bit_cost_t convert_to_scaled_bitcost(uint bits) { LZHAM_ASSERT(bits <= 255); uint32 scaled_bits = bits << cBitCostScaleShift; return static_cast(scaled_bits); } + + extern uint32 g_prob_cost[cSymbolCodecArithProbScale]; + + class raw_quasi_adaptive_huffman_data_model + { + public: + raw_quasi_adaptive_huffman_data_model(bool encoding = true, uint total_syms = 0, bool fast_encoding = false, bool use_polar_codes = false); + raw_quasi_adaptive_huffman_data_model(const raw_quasi_adaptive_huffman_data_model& other); + ~raw_quasi_adaptive_huffman_data_model(); + + bool assign(const raw_quasi_adaptive_huffman_data_model& rhs); + raw_quasi_adaptive_huffman_data_model& operator= (const raw_quasi_adaptive_huffman_data_model& rhs); + + void clear(); + + bool init(bool encoding, uint total_syms, bool fast_encoding, bool use_polar_codes, const uint16 *pInitial_sym_freq = NULL); + bool reset(); + + inline uint get_total_syms() const { return m_total_syms; } + + void rescale(); + void reset_update_rate(); + + bool update(uint sym); + + inline bit_cost_t get_cost(uint sym) const { return convert_to_scaled_bitcost(m_code_sizes[sym]); } + + public: + lzham::vector m_initial_sym_freq; + + lzham::vector m_sym_freq; + + lzham::vector m_codes; + lzham::vector m_code_sizes; + + prefix_coding::decoder_tables* m_pDecode_tables; + + uint m_total_syms; + + uint m_max_cycle; + uint m_update_cycle; + uint m_symbols_until_update; + + uint m_total_count; + + uint8 m_decoder_table_bits; + bool m_encoding; + bool m_fast_updating; + bool m_use_polar_codes; + + bool update(); + + friend class symbol_codec; + }; + + struct quasi_adaptive_huffman_data_model : public raw_quasi_adaptive_huffman_data_model + { +#if LZHAM_64BIT_POINTERS + // Ensures sizeof(quasi_adaptive_huffman_data_model) is 128 bytes on x64 (it's 64 on x86). + char m_unused_alignment[128 - sizeof(raw_quasi_adaptive_huffman_data_model)]; +#endif + }; + + class adaptive_bit_model + { + public: + adaptive_bit_model(); + adaptive_bit_model(float prob0); + adaptive_bit_model(const adaptive_bit_model& other); + + inline adaptive_bit_model& operator= (const adaptive_bit_model& rhs) { m_bit_0_prob = rhs.m_bit_0_prob; return *this; } + + inline void clear() { m_bit_0_prob = 1U << (cSymbolCodecArithProbBits - 1); } + + void set_probability_0(float prob0); + + inline void update(uint bit) + { + if (!bit) + m_bit_0_prob += ((cSymbolCodecArithProbScale - m_bit_0_prob) >> cSymbolCodecArithProbMoveBits); + else + m_bit_0_prob -= (m_bit_0_prob >> cSymbolCodecArithProbMoveBits); + LZHAM_ASSERT(m_bit_0_prob >= 1); + LZHAM_ASSERT(m_bit_0_prob < cSymbolCodecArithProbScale); + } + + inline bit_cost_t get_cost(uint bit) const { return g_prob_cost[bit ? (cSymbolCodecArithProbScale - m_bit_0_prob) : m_bit_0_prob]; } + + public: + uint16 m_bit_0_prob; + + friend class symbol_codec; + friend class adaptive_arith_data_model; + }; + + // This class is not actually used by LZHAM - it's only here for comparison/experimental purposes. + class adaptive_arith_data_model + { + public: + adaptive_arith_data_model(bool encoding = true, uint total_syms = 0); + adaptive_arith_data_model(const adaptive_arith_data_model& other); + ~adaptive_arith_data_model(); + + adaptive_arith_data_model& operator= (const adaptive_arith_data_model& rhs); + + void clear(); + + bool init(bool encoding, uint total_syms); + bool init(bool encoding, uint total_syms, bool fast_encoding, bool use_polar_codes = false) { LZHAM_NOTE_UNUSED(fast_encoding), LZHAM_NOTE_UNUSED(use_polar_codes); return init(encoding, total_syms); } + void reset(); + + void reset_update_rate(); + + bool update(uint sym); + + uint get_total_syms() const { return m_total_syms; } + bit_cost_t get_cost(uint sym) const; + + public: + uint m_total_syms; + typedef lzham::vector adaptive_bit_model_vector; + adaptive_bit_model_vector m_probs; + + friend class symbol_codec; + }; + +#if LZHAM_CPU_HAS_64BIT_REGISTERS + #define LZHAM_SYMBOL_CODEC_USE_64_BIT_BUFFER 1 +#else + #define LZHAM_SYMBOL_CODEC_USE_64_BIT_BUFFER 0 +#endif + + class symbol_codec + { + public: + symbol_codec(); + + void reset(); + + // clear() is like reset(), except it also frees all memory. + void clear(); + + // Encoding + bool start_encoding(uint expected_file_size); + bool encode_bits(uint bits, uint num_bits); + bool encode_arith_init(); + bool encode_align_to_byte(); + bool encode(uint sym, quasi_adaptive_huffman_data_model& model); + bool encode(uint bit, adaptive_bit_model& model, bool update_model = true); + bool encode(uint sym, adaptive_arith_data_model& model); + + inline uint encode_get_total_bits_written() const { return m_total_bits_written; } + + bool stop_encoding(bool support_arith); + + const lzham::vector& get_encoding_buf() const { return m_output_buf; } + lzham::vector& get_encoding_buf() { return m_output_buf; } + + // Decoding + + typedef void (*need_bytes_func_ptr)(size_t num_bytes_consumed, void *pPrivate_data, const uint8* &pBuf, size_t &buf_size, bool &eof_flag); + + bool start_decoding(const uint8* pBuf, size_t buf_size, bool eof_flag = true, need_bytes_func_ptr pNeed_bytes_func = NULL, void *pPrivate_data = NULL); + + inline void decode_set_input_buffer(const uint8* pBuf, size_t buf_size, const uint8* pBuf_next, bool eof_flag) + { + m_pDecode_buf = pBuf; + m_pDecode_buf_next = pBuf_next; + m_decode_buf_size = buf_size; + m_pDecode_buf_end = pBuf + buf_size; + m_decode_buf_eof = eof_flag; + } + inline uint64 decode_get_bytes_consumed() const { return m_pDecode_buf_next - m_pDecode_buf; } + inline uint64 decode_get_bits_remaining() const { return ((m_pDecode_buf_end - m_pDecode_buf_next) << 3) + m_bit_count; } + + void start_arith_decoding(); + uint decode_bits(uint num_bits); + uint decode_peek_bits(uint num_bits); + void decode_remove_bits(uint num_bits); + void decode_align_to_byte(); + int decode_remove_byte_from_bit_buf(); + uint decode(quasi_adaptive_huffman_data_model& model); + uint decode(adaptive_bit_model& model, bool update_model = true); + uint decode(adaptive_arith_data_model& model); + uint64 stop_decoding(); + + uint get_total_model_updates() const { return m_total_model_updates; } + + public: + const uint8* m_pDecode_buf; + const uint8* m_pDecode_buf_next; + const uint8* m_pDecode_buf_end; + size_t m_decode_buf_size; + bool m_decode_buf_eof; + + need_bytes_func_ptr m_pDecode_need_bytes_func; + void* m_pDecode_private_data; + +#if LZHAM_SYMBOL_CODEC_USE_64_BIT_BUFFER + typedef uint64 bit_buf_t; + enum { cBitBufSize = 64 }; +#else + typedef uint32 bit_buf_t; + enum { cBitBufSize = 32 }; +#endif + + bit_buf_t m_bit_buf; + int m_bit_count; + + uint m_total_model_updates; + + lzham::vector m_output_buf; + lzham::vector m_arith_output_buf; + + struct output_symbol + { + uint m_bits; + + enum + { + cArithSym = -1, + cAlignToByteSym = -2, + cArithInit = -3 + }; + int16 m_num_bits; + + uint16 m_arith_prob0; + }; + lzham::vector m_output_syms; + + uint m_total_bits_written; + + uint m_arith_base; + uint m_arith_value; + uint m_arith_length; + uint m_arith_total_bits; + + quasi_adaptive_huffman_data_model* m_pSaved_huff_model; + void* m_pSaved_model; + uint m_saved_node_index; + + bool put_bits_init(uint expected_size); + bool record_put_bits(uint bits, uint num_bits); + + void arith_propagate_carry(); + bool arith_renorm_enc_interval(); + void arith_start_encoding(); + bool arith_stop_encoding(); + + bool put_bits(uint bits, uint num_bits); + bool put_bits_align_to_byte(); + bool flush_bits(); + bool assemble_output_buf(); + + uint get_bits(uint num_bits); + void remove_bits(uint num_bits); + + void decode_need_bytes(); + + enum + { + cNull, + cEncoding, + cDecoding + } m_mode; + }; + +// Optional macros for faster decompression. These macros implement the symbol_codec class's decode functionality. +// This is hard to debug (and just plain ugly), but using these macros eliminate function calls, and they place the most important +// member variables on the stack so they're hopefully put in registers (avoiding horrible load hit stores on some CPU's). +// The user must define the LZHAM_DECODE_NEEDS_BYTES macro, which is invoked when the decode buffer is exhausted. + +#define LZHAM_SYMBOL_CODEC_DECODE_DECLARE(codec) \ + uint arith_value = 0; \ + uint arith_length = 0; \ + symbol_codec::bit_buf_t bit_buf = 0; \ + int bit_count = 0; \ + const uint8* pDecode_buf_next = NULL; + +#define LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec) \ + arith_value = codec.m_arith_value; \ + arith_length = codec.m_arith_length; \ + bit_buf = codec.m_bit_buf; \ + bit_count = codec.m_bit_count; \ + pDecode_buf_next = codec.m_pDecode_buf_next; + +#define LZHAM_SYMBOL_CODEC_DECODE_END(codec) \ + codec.m_arith_value = arith_value; \ + codec.m_arith_length = arith_length; \ + codec.m_bit_buf = bit_buf; \ + codec.m_bit_count = bit_count; \ + codec.m_pDecode_buf_next = pDecode_buf_next; + +// The user must declare the LZHAM_DECODE_NEEDS_BYTES macro. + +#define LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, result, num_bits) \ +{ \ + while (LZHAM_BUILTIN_EXPECT(bit_count < (int)(num_bits), 0)) \ + { \ + uint r; \ + if (LZHAM_BUILTIN_EXPECT(pDecode_buf_next == codec.m_pDecode_buf_end, 0)) \ + { \ + if (LZHAM_BUILTIN_EXPECT(!codec.m_decode_buf_eof, 1)) \ + { \ + LZHAM_SYMBOL_CODEC_DECODE_END(codec) \ + LZHAM_DECODE_NEEDS_BYTES \ + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec) \ + } \ + r = 0; \ + if (LZHAM_BUILTIN_EXPECT(pDecode_buf_next < codec.m_pDecode_buf_end, 1)) r = *pDecode_buf_next++; \ + } \ + else \ + r = *pDecode_buf_next++; \ + bit_count += 8; \ + bit_buf |= (static_cast(r) << (symbol_codec::cBitBufSize - bit_count)); \ + } \ + result = (num_bits) ? static_cast(bit_buf >> (symbol_codec::cBitBufSize - (num_bits))) : 0; \ + bit_buf <<= (num_bits); \ + bit_count -= (num_bits); \ +} + +#define LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, result, model) \ +{ \ + adaptive_bit_model *pModel; \ + pModel = &model; \ + while (LZHAM_BUILTIN_EXPECT(arith_length < cSymbolCodecArithMinLen, 0)) \ + { \ + uint c; codec.m_pSaved_model = pModel; \ + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, c, 8); \ + pModel = static_cast(codec.m_pSaved_model); \ + arith_value = (arith_value << 8) | c; \ + arith_length <<= 8; \ + } \ + uint x = pModel->m_bit_0_prob * (arith_length >> cSymbolCodecArithProbBits); \ + result = (arith_value >= x); \ + if (!result) \ + { \ + pModel->m_bit_0_prob += ((cSymbolCodecArithProbScale - pModel->m_bit_0_prob) >> cSymbolCodecArithProbMoveBits); \ + arith_length = x; \ + } \ + else \ + { \ + pModel->m_bit_0_prob -= (pModel->m_bit_0_prob >> cSymbolCodecArithProbMoveBits); \ + arith_value -= x; \ + arith_length -= x; \ + } \ +} + +#define LZHAM_SYMBOL_CODEC_DECODE_ADAPTIVE_ARITHMETIC(codec, result, model) \ +{ \ + adaptive_arith_data_model *pArith_data_model; \ + pArith_data_model = &model; \ + uint node_index; \ + node_index = 1; \ + do \ + { \ + while (LZHAM_BUILTIN_EXPECT(arith_length < cSymbolCodecArithMinLen, 0)) \ + { \ + uint c; codec.m_saved_node_index = node_index; codec.m_pSaved_model = pArith_data_model; \ + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, c, 8); \ + node_index = codec.m_saved_node_index; pArith_data_model = static_cast(codec.m_pSaved_model); \ + arith_value = (arith_value << 8) | c; \ + arith_length <<= 8; \ + } \ + adaptive_bit_model *pBit_model; pBit_model = &pArith_data_model->m_probs[node_index]; \ + uint x = pBit_model->m_bit_0_prob * (arith_length >> cSymbolCodecArithProbBits); \ + uint bit; bit = (arith_value >= x); \ + if (!bit) \ + { \ + pBit_model->m_bit_0_prob += ((cSymbolCodecArithProbScale - pBit_model->m_bit_0_prob) >> cSymbolCodecArithProbMoveBits); \ + arith_length = x; \ + } \ + else \ + { \ + pBit_model->m_bit_0_prob -= (pBit_model->m_bit_0_prob >> cSymbolCodecArithProbMoveBits); \ + arith_value -= x; \ + arith_length -= x; \ + } \ + node_index = (node_index << 1) + bit; \ + } while (node_index < pArith_data_model->m_total_syms); \ + result = node_index - pArith_data_model->m_total_syms; \ +} + +#if LZHAM_SYMBOL_CODEC_USE_64_BIT_BUFFER +#define LZHAM_SYMBOL_CODEC_DECODE_ADAPTIVE_HUFFMAN(codec, result, model) \ +{ \ + quasi_adaptive_huffman_data_model* pModel; const prefix_coding::decoder_tables* pTables; \ + pModel = &model; pTables = model.m_pDecode_tables; \ + if (LZHAM_BUILTIN_EXPECT(bit_count < 24, 0)) \ + { \ + uint c; \ + pDecode_buf_next += sizeof(uint32); \ + if (LZHAM_BUILTIN_EXPECT(pDecode_buf_next >= codec.m_pDecode_buf_end, 0)) \ + { \ + pDecode_buf_next -= sizeof(uint32); \ + while (bit_count < 24) \ + { \ + if (!codec.m_decode_buf_eof) \ + { \ + codec.m_pSaved_huff_model = pModel; \ + LZHAM_SYMBOL_CODEC_DECODE_END(codec) \ + LZHAM_DECODE_NEEDS_BYTES \ + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec) \ + pModel = codec.m_pSaved_huff_model; pTables = pModel->m_pDecode_tables; \ + } \ + c = 0; if (pDecode_buf_next < codec.m_pDecode_buf_end) c = *pDecode_buf_next++; \ + bit_count += 8; \ + bit_buf |= (static_cast(c) << (symbol_codec::cBitBufSize - bit_count)); \ + } \ + } \ + else \ + { \ + c = LZHAM_READ_BIG_ENDIAN_UINT32(pDecode_buf_next - sizeof(uint32)); \ + bit_count += 32; \ + bit_buf |= (static_cast(c) << (symbol_codec::cBitBufSize - bit_count)); \ + } \ + } \ + uint k = static_cast((bit_buf >> (symbol_codec::cBitBufSize - 16)) + 1); \ + uint len; \ + if (LZHAM_BUILTIN_EXPECT(k <= pTables->m_table_max_code, 1)) \ + { \ + uint32 t = pTables->m_lookup[bit_buf >> (symbol_codec::cBitBufSize - pTables->m_table_bits)]; \ + result = t & UINT16_MAX; \ + len = t >> 16; \ + } \ + else \ + { \ + len = pTables->m_decode_start_code_size; \ + for ( ; ; ) \ + { \ + if (LZHAM_BUILTIN_EXPECT(k <= pTables->m_max_codes[len - 1], 0)) \ + break; \ + len++; \ + } \ + int val_ptr = pTables->m_val_ptrs[len - 1] + static_cast(bit_buf >> (symbol_codec::cBitBufSize - len)); \ + if (((uint)val_ptr >= pModel->m_total_syms)) val_ptr = 0; \ + result = pTables->m_sorted_symbol_order[val_ptr]; \ + } \ + bit_buf <<= len; \ + bit_count -= len; \ + uint freq = pModel->m_sym_freq[result]; \ + freq++; \ + pModel->m_sym_freq[result] = static_cast(freq); \ + LZHAM_ASSERT(freq <= UINT16_MAX); \ + if (LZHAM_BUILTIN_EXPECT(--pModel->m_symbols_until_update == 0, 0)) \ + { \ + pModel->update(); \ + } \ +} +#else +#define LZHAM_SYMBOL_CODEC_DECODE_ADAPTIVE_HUFFMAN(codec, result, model) \ +{ \ + quasi_adaptive_huffman_data_model* pModel; const prefix_coding::decoder_tables* pTables; \ + pModel = &model; pTables = model.m_pDecode_tables; \ + while (LZHAM_BUILTIN_EXPECT(bit_count < (symbol_codec::cBitBufSize - 8), 1)) \ + { \ + uint c; \ + if (LZHAM_BUILTIN_EXPECT(pDecode_buf_next == codec.m_pDecode_buf_end, 0)) \ + { \ + if (LZHAM_BUILTIN_EXPECT(!codec.m_decode_buf_eof, 1)) \ + { \ + codec.m_pSaved_huff_model = pModel; \ + LZHAM_SYMBOL_CODEC_DECODE_END(codec) \ + LZHAM_DECODE_NEEDS_BYTES \ + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec) \ + pModel = codec.m_pSaved_huff_model; pTables = pModel->m_pDecode_tables; \ + } \ + c = 0; if (LZHAM_BUILTIN_EXPECT(pDecode_buf_next < codec.m_pDecode_buf_end, 1)) c = *pDecode_buf_next++; \ + } \ + else \ + c = *pDecode_buf_next++; \ + bit_count += 8; \ + bit_buf |= (static_cast(c) << (symbol_codec::cBitBufSize - bit_count)); \ + } \ + uint k = static_cast((bit_buf >> (symbol_codec::cBitBufSize - 16)) + 1); \ + uint len; \ + if (LZHAM_BUILTIN_EXPECT(k <= pTables->m_table_max_code, 1)) \ + { \ + uint32 t = pTables->m_lookup[bit_buf >> (symbol_codec::cBitBufSize - pTables->m_table_bits)]; \ + result = t & UINT16_MAX; \ + len = t >> 16; \ + } \ + else \ + { \ + len = pTables->m_decode_start_code_size; \ + for ( ; ; ) \ + { \ + if (LZHAM_BUILTIN_EXPECT(k <= pTables->m_max_codes[len - 1], 0)) \ + break; \ + len++; \ + } \ + int val_ptr = pTables->m_val_ptrs[len - 1] + static_cast(bit_buf >> (symbol_codec::cBitBufSize - len)); \ + if (LZHAM_BUILTIN_EXPECT(((uint)val_ptr >= pModel->m_total_syms), 0)) val_ptr = 0; \ + result = pTables->m_sorted_symbol_order[val_ptr]; \ + } \ + bit_buf <<= len; \ + bit_count -= len; \ + uint freq = pModel->m_sym_freq[result]; \ + freq++; \ + pModel->m_sym_freq[result] = static_cast(freq); \ + LZHAM_ASSERT(freq <= UINT16_MAX); \ + if (LZHAM_BUILTIN_EXPECT(--pModel->m_symbols_until_update == 0, 0)) \ + { \ + pModel->update(); \ + } \ +} +#endif + +#define LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec) if (bit_count & 7) { int dummy_result; LZHAM_NOTE_UNUSED(dummy_result); LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, dummy_result, bit_count & 7); } + +#define LZHAM_SYMBOL_CODEC_DECODE_REMOVE_BYTE_FROM_BIT_BUF(codec, result) \ +{ \ + result = -1; \ + if (bit_count >= 8) \ + { \ + result = static_cast(bit_buf >> (symbol_codec::cBitBufSize - 8)); \ + bit_buf <<= 8; \ + bit_count -= 8; \ + } \ +} + +#define LZHAM_SYMBOL_CODEC_DECODE_ARITH_START(codec) \ +{ \ + for ( arith_value = 0, arith_length = 0; arith_length < 4; ++arith_length ) \ + { \ + uint val; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, val, 8); \ + arith_value = (arith_value << 8) | val; \ + } \ + arith_length = cSymbolCodecArithMaxLen; \ +} + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_threading.h b/r5dev/thirdparty/lzham/include/lzham_threading.h new file mode 100644 index 00000000..b8a1dbef --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_threading.h @@ -0,0 +1,12 @@ +// File: lzham_threading.h +// See Copyright Notice and license at the end of include/lzham.h + +#if LZHAM_USE_WIN32_API + #include "lzham_win32_threading.h" +#elif LZHAM_USE_PTHREADS_API + #include "lzham_pthreads_threading.h" +#else + #include "lzham_null_threading.h" +#endif + + diff --git a/r5dev/thirdparty/lzham/include/lzham_timer.h b/r5dev/thirdparty/lzham/include/lzham_timer.h new file mode 100644 index 00000000..a522430a --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_timer.h @@ -0,0 +1,99 @@ +// File: lzham_timer.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + typedef unsigned long long timer_ticks; + + class lzham_timer + { + public: + lzham_timer(); + lzham_timer(timer_ticks start_ticks); + + void start(); + void start(timer_ticks start_ticks); + + void stop(); + + double get_elapsed_secs() const; + inline double get_elapsed_ms() const { return get_elapsed_secs() * 1000.0f; } + timer_ticks get_elapsed_us() const; + + static void init(); + static inline timer_ticks get_ticks_per_sec() { return g_freq; } + static timer_ticks get_init_ticks(); + static timer_ticks get_ticks(); + static double ticks_to_secs(timer_ticks ticks); + static inline double ticks_to_ms(timer_ticks ticks) { return ticks_to_secs(ticks) * 1000.0f; } + static inline double get_secs() { return ticks_to_secs(get_ticks()); } + static inline double get_ms() { return ticks_to_ms(get_ticks()); } + + private: + static timer_ticks g_init_ticks; + static timer_ticks g_freq; + static double g_inv_freq; + + timer_ticks m_start_time; + timer_ticks m_stop_time; + + bool m_started : 1; + bool m_stopped : 1; + }; + + enum var_args_t { cVarArgs }; + +#if LZHAM_PERF_SECTIONS + class scoped_perf_section + { + public: + inline scoped_perf_section() : + m_start_ticks(lzham_timer::get_ticks()) + { + m_name[0] = '?'; + m_name[1] = '\0'; + } + + inline scoped_perf_section(const char *pName) : + m_start_ticks(lzham_timer::get_ticks()) + { + strcpy_s(m_name, pName); + + lzham_buffered_printf("Thread: 0x%08X, BEGIN Time: %3.3fms, Section: %s\n", GetCurrentThreadId(), lzham_timer::ticks_to_ms(m_start_ticks), m_name); + } + + inline scoped_perf_section(var_args_t, const char *pName, ...) : + m_start_ticks(lzham_timer::get_ticks()) + { + va_list args; + va_start(args, pName); + vsprintf_s(m_name, sizeof(m_name), pName, args); + va_end(args); + + lzham_buffered_printf("Thread: 0x%08X, BEGIN Time: %3.3fms, Section: %s\n", GetCurrentThreadId(), lzham_timer::ticks_to_ms(m_start_ticks), m_name); + } + + inline ~scoped_perf_section() + { + double end_ms = lzham_timer::get_ms(); + double start_ms = lzham_timer::ticks_to_ms(m_start_ticks); + + lzham_buffered_printf("Thread: 0x%08X, END Time: %3.3fms, Total: %3.3fms, Section: %s\n", GetCurrentThreadId(), end_ms, end_ms - start_ms, m_name); + } + + private: + char m_name[64]; + timer_ticks m_start_ticks; + }; +#else + class scoped_perf_section + { + public: + inline scoped_perf_section() { } + inline scoped_perf_section(const char *pName) { (void)pName; } + inline scoped_perf_section(var_args_t, const char *pName, ...) { (void)pName; } + }; +#endif // LZHAM_PERF_SECTIONS + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_traits.h b/r5dev/thirdparty/lzham/include/lzham_traits.h new file mode 100644 index 00000000..fbb68ce6 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_traits.h @@ -0,0 +1,137 @@ +// File: lzham_traits.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + template + struct scalar_type + { + enum { cFlag = false }; + static inline void construct(T* p) { helpers::construct(p); } + static inline void construct(T* p, const T& init) { helpers::construct(p, init); } + static inline void construct_array(T* p, uint n) { helpers::construct_array(p, n); } + static inline void destruct(T* p) { helpers::destruct(p); } + static inline void destruct_array(T* p, uint n) { helpers::destruct_array(p, n); } + }; + + template struct scalar_type + { + enum { cFlag = true }; + static inline void construct(T** p) { memset(p, 0, sizeof(T*)); } + static inline void construct(T** p, T* init) { *p = init; } + static inline void construct_array(T** p, uint n) { memset(p, 0, sizeof(T*) * n); } + static inline void destruct(T** p) { LZHAM_NOTE_UNUSED(p); } + static inline void destruct_array(T** p, uint n) { LZHAM_NOTE_UNUSED(p); LZHAM_NOTE_UNUSED(n); } + }; + +#define LZHAM_DEFINE_BUILT_IN_TYPE(X) \ + template<> struct scalar_type { \ + enum { cFlag = true }; \ + static inline void construct(X* p) { memset(p, 0, sizeof(X)); } \ + static inline void construct(X* p, const X& init) { memcpy(p, &init, sizeof(X)); } \ + static inline void construct_array(X* p, uint n) { memset(p, 0, sizeof(X) * n); } \ + static inline void destruct(X* p) { LZHAM_NOTE_UNUSED(p); } \ + static inline void destruct_array(X* p, uint n) { LZHAM_NOTE_UNUSED(p); LZHAM_NOTE_UNUSED(n); } }; + + LZHAM_DEFINE_BUILT_IN_TYPE(bool) + LZHAM_DEFINE_BUILT_IN_TYPE(char) + LZHAM_DEFINE_BUILT_IN_TYPE(unsigned char) + LZHAM_DEFINE_BUILT_IN_TYPE(short) + LZHAM_DEFINE_BUILT_IN_TYPE(unsigned short) + LZHAM_DEFINE_BUILT_IN_TYPE(int) + LZHAM_DEFINE_BUILT_IN_TYPE(unsigned int) + LZHAM_DEFINE_BUILT_IN_TYPE(long) + LZHAM_DEFINE_BUILT_IN_TYPE(unsigned long) + LZHAM_DEFINE_BUILT_IN_TYPE(float) + LZHAM_DEFINE_BUILT_IN_TYPE(double) + LZHAM_DEFINE_BUILT_IN_TYPE(long double) + #if defined(WIN32) + LZHAM_DEFINE_BUILT_IN_TYPE(__int64) + LZHAM_DEFINE_BUILT_IN_TYPE(unsigned __int64) + #endif + +#undef LZHAM_DEFINE_BUILT_IN_TYPE + +// See: http://erdani.org/publications/cuj-2004-06.pdf + + template + struct bitwise_movable { enum { cFlag = false }; }; + +// Defines type Q as bitwise movable. +#define LZHAM_DEFINE_BITWISE_MOVABLE(Q) template<> struct bitwise_movable { enum { cFlag = true }; }; + + template + struct bitwise_copyable { enum { cFlag = false }; }; + + // Defines type Q as bitwise copyable. +#define LZHAM_DEFINE_BITWISE_COPYABLE(Q) template<> struct bitwise_copyable { enum { cFlag = true }; }; + +#define LZHAM_IS_POD(T) __is_pod(T) + +#define LZHAM_IS_SCALAR_TYPE(T) (scalar_type::cFlag) + +#define LZHAM_IS_BITWISE_COPYABLE(T) ((scalar_type::cFlag) || (bitwise_copyable::cFlag) || LZHAM_IS_POD(T)) + +#define LZHAM_IS_BITWISE_MOVABLE(T) (LZHAM_IS_BITWISE_COPYABLE(T) || (bitwise_movable::cFlag)) + +#define LZHAM_HAS_DESTRUCTOR(T) ((!scalar_type::cFlag) && (!__is_pod(T))) + + // From yasli_traits.h: + // Credit goes to Boost; + // also found in the C++ Templates book by Vandevoorde and Josuttis + + typedef char (&yes_t)[1]; + typedef char (&no_t)[2]; + + template yes_t class_test(int U::*); + template no_t class_test(...); + + template struct is_class + { + enum { value = (sizeof(class_test(0)) == sizeof(yes_t)) }; + }; + + template struct is_pointer + { + enum { value = false }; + }; + + template struct is_pointer + { + enum { value = true }; + }; + + LZHAM_DEFINE_BITWISE_COPYABLE(empty_type); + LZHAM_DEFINE_BITWISE_MOVABLE(empty_type); + + namespace helpers + { + template + inline void construct_array(T* p, uint n) + { + if (LZHAM_IS_SCALAR_TYPE(T)) + { + memset(p, 0, sizeof(T) * n); + } + else + { + T* q = p + n; + for ( ; p != q; ++p) + new (static_cast(p)) T; + } + } + + template + inline void destruct_array(T* p, uint n) + { + if ( LZHAM_HAS_DESTRUCTOR(T) ) + { + T* q = p + n; + for ( ; p != q; ++p) + p->~T(); + } + } + } + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_types.h b/r5dev/thirdparty/lzham/include/lzham_types.h new file mode 100644 index 00000000..a0227e8a --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_types.h @@ -0,0 +1,74 @@ +// File: types.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + typedef unsigned char uint8; + typedef signed char int8; + typedef unsigned char uint8; + typedef unsigned short uint16; + typedef signed short int16; + typedef unsigned int uint32; + typedef uint32 uint; + typedef signed int int32; + + #ifdef __GNUC__ + typedef unsigned long long uint64; + typedef long long int64; + #else + typedef unsigned __int64 uint64; + typedef signed __int64 int64; + #endif + + const uint8 UINT8_MIN = 0; + //const uint8 UINT8_MAX = 0xFFU; + const uint16 UINT16_MIN = 0; + //const uint16 UINT16_MAX = 0xFFFFU; + const uint32 UINT32_MIN = 0; + //const uint32 UINT32_MAX = 0xFFFFFFFFU; + const uint64 UINT64_MIN = 0; + //const uint64 UINT64_MAX = 0xFFFFFFFFFFFFFFFFULL; //0xFFFFFFFFFFFFFFFFui64; + + //const int8 INT8_MIN = -128; + //const int8 INT8_MAX = 127; + //const int16 INT16_MIN = -32768; + //const int16 INT16_MAX = 32767; + //const int32 INT32_MIN = (-2147483647 - 1); + //const int32 INT32_MAX = 2147483647; + //const int64 INT64_MIN = (int64)0x8000000000000000ULL; //(-9223372036854775807i64 - 1); + //const int64 INT64_MAX = (int64)0x7FFFFFFFFFFFFFFFULL; //9223372036854775807i64; + +#if LZHAM_64BIT_POINTERS + typedef uint64 uint_ptr; + typedef uint64 uint32_ptr; + typedef int64 signed_size_t; + typedef uint64 ptr_bits_t; + const ptr_bits_t PTR_BITS_XOR = 0xDB0DD4415C87DCF7ULL; +#else + typedef unsigned int uint_ptr; + typedef unsigned int uint32_ptr; + typedef signed int signed_size_t; + typedef uint32 ptr_bits_t; + const ptr_bits_t PTR_BITS_XOR = 0x5C87DCF7UL; +#endif + + enum + { + cInvalidIndex = -1 + }; + + const uint cIntBits = sizeof(uint) * CHAR_BIT; + + template struct int_traits { enum { cMin = INT_MIN, cMax = INT_MAX, cSigned = true }; }; + template<> struct int_traits { enum { cMin = INT8_MIN, cMax = INT8_MAX, cSigned = true }; }; + template<> struct int_traits { enum { cMin = INT16_MIN, cMax = INT16_MAX, cSigned = true }; }; + template<> struct int_traits { enum { cMin = INT32_MIN, cMax = INT32_MAX, cSigned = true }; }; + + template<> struct int_traits { enum { cMin = 0, cMax = UINT_MAX, cSigned = false }; }; + template<> struct int_traits { enum { cMin = 0, cMax = UINT8_MAX, cSigned = false }; }; + template<> struct int_traits { enum { cMin = 0, cMax = UINT16_MAX, cSigned = false }; }; + + struct empty_type { }; + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/include/lzham_utils.h b/r5dev/thirdparty/lzham/include/lzham_utils.h new file mode 100644 index 00000000..0e8f5e8b --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_utils.h @@ -0,0 +1,58 @@ +// File: lzham_utils.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +#define LZHAM_GET_ALIGNMENT(v) ((!sizeof(v)) ? 1 : (__alignof(v) ? __alignof(v) : sizeof(uint32))) + +#define LZHAM_MIN(a, b) (((a) < (b)) ? (a) : (b)) +#define LZHAM_MAX(a, b) (((a) < (b)) ? (b) : (a)) + +template T decay_array_to_subtype(T (&a)[N]); +#define LZHAM_ARRAY_SIZE(X) (sizeof(X) / sizeof(decay_array_to_subtype(X))) + +namespace lzham +{ + namespace utils + { + template inline void swap(T& l, T& r) + { + T temp(l); + l = r; + r = temp; + } + + template inline void zero_object(T& obj) + { + memset(&obj, 0, sizeof(obj)); + } + + static inline uint32 swap32(uint32 x) { return ((x << 24U) | ((x << 8U) & 0x00FF0000U) | ((x >> 8U) & 0x0000FF00U) | (x >> 24U)); } + + inline uint count_leading_zeros16(uint v) + { + LZHAM_ASSERT(v < 0x10000); + + uint temp; + uint n = 16; + + temp = v >> 8; + if (temp) { n -= 8; v = temp; } + + temp = v >> 4; + if (temp) { n -= 4; v = temp; } + + temp = v >> 2; + if (temp) { n -= 2; v = temp; } + + temp = v >> 1; + if (temp) { n -= 1; v = temp; } + + if (v & 1) n--; + + return n; + } + + } // namespace utils + +} // namespace lzham + diff --git a/r5dev/thirdparty/lzham/include/lzham_vector.h b/r5dev/thirdparty/lzham/include/lzham_vector.h new file mode 100644 index 00000000..90f3236d --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_vector.h @@ -0,0 +1,588 @@ +// File: lzham_vector.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +namespace lzham +{ + struct elemental_vector + { + void* m_p; + uint m_size; + uint m_capacity; + + typedef void (*object_mover)(void* pDst, void* pSrc, uint num); + + bool increase_capacity(uint min_new_capacity, bool grow_hint, uint element_size, object_mover pRelocate, bool nofail); + }; + + template + class vector : public helpers::rel_ops< vector > + { + public: + typedef T* iterator; + typedef const T* const_iterator; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T* pointer; + typedef const T* const_pointer; + + inline vector() : + m_p(NULL), + m_size(0), + m_capacity(0) + { + } + + inline vector(uint n, const T& init) : + m_p(NULL), + m_size(0), + m_capacity(0) + { + increase_capacity(n, false); + helpers::construct_array(m_p, n, init); + m_size = n; + } + + inline vector(const vector& other) : + m_p(NULL), + m_size(0), + m_capacity(0) + { + increase_capacity(other.m_size, false); + + m_size = other.m_size; + + if (LZHAM_IS_BITWISE_COPYABLE(T)) + memcpy(m_p, other.m_p, m_size * sizeof(T)); + else + { + T* pDst = m_p; + const T* pSrc = other.m_p; + for (uint i = m_size; i > 0; i--) + helpers::construct(pDst++, *pSrc++); + } + } + + inline explicit vector(uint size) : + m_p(NULL), + m_size(0), + m_capacity(0) + { + try_resize(size); + } + + inline ~vector() + { + if (m_p) + { + scalar_type::destruct_array(m_p, m_size); + lzham_free(m_p); + } + } + + inline vector& operator= (const vector& other) + { + if (this == &other) + return *this; + + if (m_capacity >= other.m_size) + try_resize(0); + else + { + clear(); + if (!increase_capacity(other.m_size, false)) + { + LZHAM_FAIL("lzham::vector operator=: Out of memory!"); + return *this; + } + } + + if (LZHAM_IS_BITWISE_COPYABLE(T)) + memcpy(m_p, other.m_p, other.m_size * sizeof(T)); + else + { + T* pDst = m_p; + const T* pSrc = other.m_p; + for (uint i = other.m_size; i > 0; i--) + helpers::construct(pDst++, *pSrc++); + } + + m_size = other.m_size; + + return *this; + } + + inline const T* begin() const { return m_p; } + T* begin() { return m_p; } + + inline const T* end() const { return m_p + m_size; } + T* end() { return m_p + m_size; } + + inline bool empty() const { return !m_size; } + inline uint size() const { return m_size; } + inline uint size_in_bytes() const { return m_size * sizeof(T); } + inline uint capacity() const { return m_capacity; } + + // operator[] will assert on out of range indices, but in final builds there is (and will never be) any range checking on this method. + inline const T& operator[] (uint i) const { LZHAM_ASSERT(i < m_size); return m_p[i]; } + inline T& operator[] (uint i) { LZHAM_ASSERT(i < m_size); return m_p[i]; } + + // at() always includes range checking, even in final builds, unlike operator []. + // The first element is returned if the index is out of range. + inline const T& at(uint i) const { LZHAM_ASSERT(i < m_size); return (i >= m_size) ? m_p[0] : m_p[i]; } + inline T& at(uint i) { LZHAM_ASSERT(i < m_size); return (i >= m_size) ? m_p[0] : m_p[i]; } + + inline const T& front() const { LZHAM_ASSERT(m_size); return m_p[0]; } + inline T& front() { LZHAM_ASSERT(m_size); return m_p[0]; } + + inline const T& back() const { LZHAM_ASSERT(m_size); return m_p[m_size - 1]; } + inline T& back() { LZHAM_ASSERT(m_size); return m_p[m_size - 1]; } + + inline const T* get_ptr() const { return m_p; } + inline T* get_ptr() { return m_p; } + + inline void clear() + { + if (m_p) + { + scalar_type::destruct_array(m_p, m_size); + lzham_free(m_p); + m_p = NULL; + m_size = 0; + m_capacity = 0; + } + } + + inline void clear_no_destruction() + { + if (m_p) + { + lzham_free(m_p); + m_p = NULL; + m_size = 0; + m_capacity = 0; + } + } + + inline bool try_reserve(uint new_capacity) + { + return increase_capacity(new_capacity, true, true); + } + + inline bool try_resize(uint new_size, bool grow_hint = false) + { + if (m_size != new_size) + { + if (new_size < m_size) + scalar_type::destruct_array(m_p + new_size, m_size - new_size); + else + { + if (new_size > m_capacity) + { + if (!increase_capacity(new_size, (new_size == (m_size + 1)) || grow_hint, true)) + return false; + } + + scalar_type::construct_array(m_p + m_size, new_size - m_size); + } + + m_size = new_size; + } + + return true; + } + + inline bool try_resize_no_construct(uint new_size, bool grow_hint = false) + { + if (new_size > m_capacity) + { + if (!increase_capacity(new_size, (new_size == (m_size + 1)) || grow_hint, true)) + return false; + } + + m_size = new_size; + + return true; + } + + inline T* try_enlarge(uint i) + { + uint cur_size = m_size; + if (!try_resize(cur_size + i, true)) + return NULL; + return get_ptr() + cur_size; + } + + inline bool try_push_back(const T& obj) + { + LZHAM_ASSERT(!m_p || (&obj < m_p) || (&obj >= (m_p + m_size))); + + if (m_size >= m_capacity) + { + if (!increase_capacity(m_size + 1, true, true)) + return false; + } + + scalar_type::construct(m_p + m_size, obj); + m_size++; + + return true; + } + + inline void pop_back() + { + LZHAM_ASSERT(m_size); + + if (m_size) + { + m_size--; + scalar_type::destruct(&m_p[m_size]); + } + } + + inline bool insert(uint index, const T* p, uint n) + { + LZHAM_ASSERT(index <= m_size); + if (!n) + return true; + + const uint orig_size = m_size; + if (!try_resize(m_size + n, true)) + return false; + + const uint num_to_move = orig_size - index; + if (num_to_move) + { + if (LZHAM_IS_BITWISE_COPYABLE(T)) + memmove(m_p + index + n, m_p + index, sizeof(T) * num_to_move); + else + { + const T* pSrc = m_p + orig_size - 1; + T* pDst = const_cast(pSrc) + n; + + for (uint i = 0; i < num_to_move; i++) + { + LZHAM_ASSERT((pDst - m_p) < (int)m_size); + *pDst-- = *pSrc--; + } + } + } + + T* pDst = m_p + index; + + if (LZHAM_IS_BITWISE_COPYABLE(T)) + memcpy(pDst, p, sizeof(T) * n); + else + { + for (uint i = 0; i < n; i++) + { + LZHAM_ASSERT((pDst - m_p) < (int)m_size); + *pDst++ = *p++; + } + } + + return true; + } + + // push_front() isn't going to be very fast - it's only here for usability. + inline bool try_push_front(const T& obj) + { + return insert(0, &obj, 1); + } + + bool append(const vector& other) + { + if (other.m_size) + return insert(m_size, &other[0], other.m_size); + return true; + } + + bool append(const T* p, uint n) + { + if (n) + return insert(m_size, p, n); + return true; + } + + inline void erase(uint start, uint n) + { + LZHAM_ASSERT((start + n) <= m_size); + if ((start + n) > m_size) + return; + + if (!n) + return; + + const uint num_to_move = m_size - (start + n); + + T* pDst = m_p + start; + + const T* pSrc = m_p + start + n; + + if (LZHAM_IS_BITWISE_COPYABLE(T)) + memmove(pDst, pSrc, num_to_move * sizeof(T)); + else + { + T* pDst_end = pDst + num_to_move; + + while (pDst != pDst_end) + *pDst++ = *pSrc++; + + scalar_type::destruct_array(pDst_end, n); + } + + m_size -= n; + } + + inline void erase(uint index) + { + erase(index, 1); + } + + inline void erase(T* p) + { + LZHAM_ASSERT((p >= m_p) && (p < (m_p + m_size))); + erase(static_cast(p - m_p)); + } + + void erase_unordered(uint index) + { + LZHAM_ASSERT(index < m_size); + + if ((index + 1) < m_size) + (*this)[index] = back(); + + pop_back(); + } + + inline bool operator== (const vector& rhs) const + { + if (m_size != rhs.m_size) + return false; + else if (m_size) + { + if (scalar_type::cFlag) + return memcmp(m_p, rhs.m_p, sizeof(T) * m_size) == 0; + else + { + const T* pSrc = m_p; + const T* pDst = rhs.m_p; + for (uint i = m_size; i; i--) + if (!(*pSrc++ == *pDst++)) + return false; + } + } + + return true; + } + + inline bool operator< (const vector& rhs) const + { + const uint min_size = math::minimum(m_size, rhs.m_size); + + const T* pSrc = m_p; + const T* pSrc_end = m_p + min_size; + const T* pDst = rhs.m_p; + + while ((pSrc < pSrc_end) && (*pSrc == *pDst)) + { + pSrc++; + pDst++; + } + + if (pSrc < pSrc_end) + return *pSrc < *pDst; + + return m_size < rhs.m_size; + } + + inline void swap(vector& other) + { + utils::swap(m_p, other.m_p); + utils::swap(m_size, other.m_size); + utils::swap(m_capacity, other.m_capacity); + } + + inline void sort() + { + std::sort(begin(), end()); + } + + inline void unique() + { + if (!empty()) + { + sort(); + + resize(std::unique(begin(), end()) - begin()); + } + } + + inline void reverse() + { + uint j = m_size >> 1; + for (uint i = 0; i < j; i++) + utils::swap(m_p[i], m_p[m_size - 1 - i]); + } + + inline int find(const T& key) const + { + const T* p = m_p; + const T* p_end = m_p + m_size; + + uint index = 0; + + while (p != p_end) + { + if (key == *p) + return index; + + p++; + index++; + } + + return cInvalidIndex; + } + + inline int find_sorted(const T& key) const + { + if (m_size) + { + // Uniform binary search - Knuth Algorithm 6.2.1 U, unrolled twice. + int i = ((m_size + 1) >> 1) - 1; + int m = m_size; + + for ( ; ; ) + { + LZHAM_ASSERT_OPEN_RANGE(i, 0, (int)m_size); + const T* pKey_i = m_p + i; + int cmp = key < *pKey_i; + if ((!cmp) && (key == *pKey_i)) return i; + m >>= 1; + if (!m) break; + cmp = -cmp; + i += (((m + 1) >> 1) ^ cmp) - cmp; + + LZHAM_ASSERT_OPEN_RANGE(i, 0, (int)m_size); + pKey_i = m_p + i; + cmp = key < *pKey_i; + if ((!cmp) && (key == *pKey_i)) return i; + m >>= 1; + if (!m) break; + cmp = -cmp; + i += (((m + 1) >> 1) ^ cmp) - cmp; + } + } + + return cInvalidIndex; + } + + template + inline int find_sorted(const T& key, Q less_than) const + { + if (m_size) + { + // Uniform binary search - Knuth Algorithm 6.2.1 U, unrolled twice. + int i = ((m_size + 1) >> 1) - 1; + int m = m_size; + + for ( ; ; ) + { + LZHAM_ASSERT_OPEN_RANGE(i, 0, (int)m_size); + const T* pKey_i = m_p + i; + int cmp = less_than(key, *pKey_i); + if ((!cmp) && (!less_than(*pKey_i, key))) return i; + m >>= 1; + if (!m) break; + cmp = -cmp; + i += (((m + 1) >> 1) ^ cmp) - cmp; + + LZHAM_ASSERT_OPEN_RANGE(i, 0, (int)m_size); + pKey_i = m_p + i; + cmp = less_than(key, *pKey_i); + if ((!cmp) && (!less_than(*pKey_i, key))) return i; + m >>= 1; + if (!m) break; + cmp = -cmp; + i += (((m + 1) >> 1) ^ cmp) - cmp; + } + } + + return cInvalidIndex; + } + + inline uint count_occurences(const T& key) const + { + uint c = 0; + + const T* p = m_p; + const T* p_end = m_p + m_size; + + while (p != p_end) + { + if (key == *p) + c++; + + p++; + } + + return c; + } + + inline void set_all(const T& o) + { + if ((sizeof(T) == 1) && (scalar_type::cFlag)) + memset(m_p, *reinterpret_cast(&o), m_size); + else + { + T* pDst = m_p; + T* pDst_end = pDst + m_size; + while (pDst != pDst_end) + *pDst++ = o; + } + } + + private: + T* m_p; + uint m_size; + uint m_capacity; + + template struct is_vector { enum { cFlag = false }; }; + template struct is_vector< vector > { enum { cFlag = true }; }; + + static void object_mover(void* pDst_void, void* pSrc_void, uint num) + { + T* pSrc = static_cast(pSrc_void); + T* const pSrc_end = pSrc + num; + T* pDst = static_cast(pDst_void); + + while (pSrc != pSrc_end) + { + new (static_cast(pDst)) T(*pSrc); + pSrc->~T(); + pSrc++; + pDst++; + } + } + + inline bool increase_capacity(uint min_new_capacity, bool grow_hint, bool nofail = false) + { + return reinterpret_cast(this)->increase_capacity( + min_new_capacity, grow_hint, sizeof(T), + (LZHAM_IS_BITWISE_MOVABLE(T) || (is_vector::cFlag)) ? NULL : object_mover, nofail); + } + }; + + template struct bitwise_movable< vector > { enum { cFlag = true }; }; + + extern void vector_test(); + + template + inline void swap(vector& a, vector& b) + { + a.swap(b); + } + +} // namespace lzham + diff --git a/r5dev/thirdparty/lzham/include/lzham_win32_threading.h b/r5dev/thirdparty/lzham/include/lzham_win32_threading.h new file mode 100644 index 00000000..64125ac1 --- /dev/null +++ b/r5dev/thirdparty/lzham/include/lzham_win32_threading.h @@ -0,0 +1,368 @@ +// File: lzham_task_pool_win32.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +#if LZHAM_USE_WIN32_API + +#if LZHAM_NO_ATOMICS +#error No atomic operations defined in lzham_platform.h! +#endif + +namespace lzham +{ + class semaphore + { + LZHAM_NO_COPY_OR_ASSIGNMENT_OP(semaphore); + + public: + semaphore(long initialCount = 0, long maximumCount = 1, const char* pName = NULL) + { + m_handle = CreateSemaphoreA(NULL, initialCount, maximumCount, pName); + if (NULL == m_handle) + { + LZHAM_FAIL("semaphore: CreateSemaphore() failed"); + } + } + + ~semaphore() + { + if (m_handle) + { + CloseHandle(m_handle); + m_handle = NULL; + } + } + + inline HANDLE get_handle(void) const { return m_handle; } + + void release(long releaseCount = 1) + { + if (0 == ReleaseSemaphore(m_handle, releaseCount, NULL)) + { + LZHAM_FAIL("semaphore: ReleaseSemaphore() failed"); + } + } + + bool wait(uint32 milliseconds = UINT32_MAX) + { + LZHAM_ASSUME(INFINITE == UINT32_MAX); + + DWORD result = WaitForSingleObject(m_handle, milliseconds); + + if (WAIT_FAILED == result) + { + LZHAM_FAIL("semaphore: WaitForSingleObject() failed"); + } + + return WAIT_OBJECT_0 == result; + } + + private: + HANDLE m_handle; + }; + + template + class tsstack + { + public: + inline tsstack(bool use_freelist = true) : + m_use_freelist(use_freelist) + { + LZHAM_VERIFY(((ptr_bits_t)this & (LZHAM_GET_ALIGNMENT(tsstack) - 1)) == 0); + InitializeSListHead(&m_stack_head); + InitializeSListHead(&m_freelist_head); + } + + inline ~tsstack() + { + clear(); + } + + inline void clear() + { + for ( ; ; ) + { + node* pNode = (node*)InterlockedPopEntrySList(&m_stack_head); + if (!pNode) + break; + + LZHAM_MEMORY_IMPORT_BARRIER + + helpers::destruct(&pNode->m_obj); + + lzham_free(pNode); + } + + flush_freelist(); + } + + inline void flush_freelist() + { + if (!m_use_freelist) + return; + + for ( ; ; ) + { + node* pNode = (node*)InterlockedPopEntrySList(&m_freelist_head); + if (!pNode) + break; + + LZHAM_MEMORY_IMPORT_BARRIER + + lzham_free(pNode); + } + } + + inline bool try_push(const T& obj) + { + node* pNode = alloc_node(); + if (!pNode) + return false; + + helpers::construct(&pNode->m_obj, obj); + + LZHAM_MEMORY_EXPORT_BARRIER + + InterlockedPushEntrySList(&m_stack_head, &pNode->m_slist_entry); + + return true; + } + + inline bool pop(T& obj) + { + node* pNode = (node*)InterlockedPopEntrySList(&m_stack_head); + if (!pNode) + return false; + + LZHAM_MEMORY_IMPORT_BARRIER + + obj = pNode->m_obj; + + helpers::destruct(&pNode->m_obj); + + free_node(pNode); + + return true; + } + + private: + SLIST_HEADER m_stack_head; + SLIST_HEADER m_freelist_head; + + struct node + { + SLIST_ENTRY m_slist_entry; + T m_obj; + }; + + bool m_use_freelist; + + inline node* alloc_node() + { + node* pNode = m_use_freelist ? (node*)InterlockedPopEntrySList(&m_freelist_head) : NULL; + + if (!pNode) + pNode = (node*)lzham_malloc(sizeof(node)); + + return pNode; + } + + inline void free_node(node* pNode) + { + if (m_use_freelist) + InterlockedPushEntrySList(&m_freelist_head, &pNode->m_slist_entry); + else + lzham_free(pNode); + } + }; + + class task_pool + { + public: + task_pool(); + task_pool(uint num_threads); + ~task_pool(); + + enum { cMaxThreads = LZHAM_MAX_HELPER_THREADS }; + bool init(uint num_threads); + void deinit(); + + inline uint get_num_threads() const { return m_num_threads; } + inline uint get_num_outstanding_tasks() const { return m_num_outstanding_tasks; } + + // C-style task callback + typedef void (*task_callback_func)(uint64 data, void* pData_ptr); + bool queue_task(task_callback_func pFunc, uint64 data = 0, void* pData_ptr = NULL); + + class executable_task + { + public: + virtual void execute_task(uint64 data, void* pData_ptr) = 0; + }; + + // It's the caller's responsibility to delete pObj within the execute_task() method, if needed! + bool queue_task(executable_task* pObj, uint64 data = 0, void* pData_ptr = NULL); + + template + inline bool queue_object_task(S* pObject, T pObject_method, uint64 data = 0, void* pData_ptr = NULL); + + template + inline bool queue_multiple_object_tasks(S* pObject, T pObject_method, uint64 first_data, uint num_tasks, void* pData_ptr = NULL); + + void join(); + + private: + struct task + { + //inline task() : m_data(0), m_pData_ptr(NULL), m_pObj(NULL), m_flags(0) { } + + uint64 m_data; + void* m_pData_ptr; + + union + { + task_callback_func m_callback; + executable_task* m_pObj; + }; + + uint m_flags; + }; + + tsstack m_task_stack; + + uint m_num_threads; + HANDLE m_threads[cMaxThreads]; + + semaphore m_tasks_available; + + enum task_flags + { + cTaskFlagObject = 1 + }; + + volatile atomic32_t m_num_outstanding_tasks; + volatile atomic32_t m_exit_flag; + + void process_task(task& tsk); + + static unsigned __stdcall thread_func(void* pContext); + }; + + enum object_task_flags + { + cObjectTaskFlagDefault = 0, + cObjectTaskFlagDeleteAfterExecution = 1 + }; + + template + class object_task : public task_pool::executable_task + { + public: + object_task(uint flags = cObjectTaskFlagDefault) : + m_pObject(NULL), + m_pMethod(NULL), + m_flags(flags) + { + } + + typedef void (T::*object_method_ptr)(uint64 data, void* pData_ptr); + + object_task(T* pObject, object_method_ptr pMethod, uint flags = cObjectTaskFlagDefault) : + m_pObject(pObject), + m_pMethod(pMethod), + m_flags(flags) + { + LZHAM_ASSERT(pObject && pMethod); + } + + void init(T* pObject, object_method_ptr pMethod, uint flags = cObjectTaskFlagDefault) + { + LZHAM_ASSERT(pObject && pMethod); + + m_pObject = pObject; + m_pMethod = pMethod; + m_flags = flags; + } + + T* get_object() const { return m_pObject; } + object_method_ptr get_method() const { return m_pMethod; } + + virtual void execute_task(uint64 data, void* pData_ptr) + { + (m_pObject->*m_pMethod)(data, pData_ptr); + + if (m_flags & cObjectTaskFlagDeleteAfterExecution) + lzham_delete(this); + } + + protected: + T* m_pObject; + + object_method_ptr m_pMethod; + + uint m_flags; + }; + + template + inline bool task_pool::queue_object_task(S* pObject, T pObject_method, uint64 data, void* pData_ptr) + { + object_task *pTask = lzham_new< object_task >(pObject, pObject_method, cObjectTaskFlagDeleteAfterExecution); + if (!pTask) + return false; + return queue_task(pTask, data, pData_ptr); + } + + template + inline bool task_pool::queue_multiple_object_tasks(S* pObject, T pObject_method, uint64 first_data, uint num_tasks, void* pData_ptr) + { + LZHAM_ASSERT(m_num_threads); + LZHAM_ASSERT(pObject); + LZHAM_ASSERT(num_tasks); + if (!num_tasks) + return true; + + bool status = true; + + uint i; + for (i = 0; i < num_tasks; i++) + { + task tsk; + + tsk.m_pObj = lzham_new< object_task >(pObject, pObject_method, cObjectTaskFlagDeleteAfterExecution); + if (!tsk.m_pObj) + { + status = false; + break; + } + + tsk.m_data = first_data + i; + tsk.m_pData_ptr = pData_ptr; + tsk.m_flags = cTaskFlagObject; + + if (!m_task_stack.try_push(tsk)) + { + status = false; + break; + } + } + + if (i) + { + atomic_add32(&m_num_outstanding_tasks, i); + + m_tasks_available.release(i); + } + + return status; + } + + inline void lzham_sleep(unsigned int milliseconds) + { + Sleep(milliseconds); + } + + uint lzham_get_max_helper_threads(); + +} // namespace lzham + +#endif // LZHAM_USE_WIN32_API diff --git a/r5dev/thirdparty/lzham/libs/lzhamcomp_x64.lib b/r5dev/thirdparty/lzham/libs/lzhamcomp_x64.lib deleted file mode 100644 index 7f5d6e43e27fe022626fa4eceaa19b0d22bb128a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 556410 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

I9^wSmSrU2OoqvUiGEd!etOX#zCJH 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 %cpqXiOLt!L$|e21 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

acI|{(>`c_Zp<6 zgK+Yb4)QUi81bfG=D>SLHNY$Uf4v4)V_JD=S1l#_i{mNL z>Cw_DQ=%7L6peY&nH7~w6053LR#%lRXlq@+p}l(sc4_dowvBX{)g>pEB&w>bmef?O zs7b6WPc9hWRNjD(*H>0l)iqVEsB2nNRZ-crqQ0`cYDraP!-|VydNY@k{Y&e?QU&vscv2039nce)u1G3rPd9) zVv%>o<#ovQh0*RO5vdAhcndj+dPmfqG7{dg8Qk)FY`6-HUfF^N)!Vj4OK0H|Jutk1 zGX-Qo=qTcsoSp}h!25ts4@LS)q(Q3AU4=9QErAaroy4BYLDwKn-g6MI)#+-auhZ#^ zk-lE1Hz0ij((ACl4RNo=Df3388K`)AG!3o)k7ycR%s!pogY?Zh{bi*0YkH1`TQ$BJ z*LIsucLTp&rw<_gain)(Ps`>mq}O5pAw64XFhuwb+L`Gx)9rwb=Z zzYf#lNcdW$7sRyRA>iB$;QXttmY{pC`5$D)Cw*9-84CLIz_+Tpu68LS(nfarH=Ba9 zj9T_~{F@q|J&BAAoL^ZKvpuy)T(=x+UU4ePAFJy8SO!P#yg4`~Pu#f{dm~_)kh!S2D03nQ~6ls#&WZ6 zSuXc8Q{t?z@z__ascYbvV7u_S#fnQ-tgNhQs;XU5r)b9EoF++cyQcb;4VsU2spM#k zc~VxBD-1L&r&I4KWr%aHBi@F{;acQBd)|gkYwv&lJ2PIsy8N-4+W){>xxzm`?9l2x zpZRD>(+>_t9$54;W`R#D{IlnL^S93*yJFtp%BEku`uXc)p7$%E|I;`9@10zG#i-VE z2LEZWhen=+42t~!{r(SLT6yE`T`%17!5^Kt@|PHpTNQq5X!7Sj^Yi!pa6x?3S3Y;o znoICJ0&>({Rr!Lol{@fy&DQ3&wGAyD+t#k!(%QMP1ODfBu7y_XS_@^YI#lyowd>=T zzWgTTT@<(FEejK0hEmQZ`~$g-e;-AIQyCp?&E1=}b+*4#Ir{5Mh(VzK z%0tYBZ=i?JC)c5!Xc#r}HUJeqPpNx8n1k#eYC zeV?z|z~y53Hq7YMF9yf|{#x6&w`-jImn!~_T9_m%zmd*$aNb3JyFL~ktm>nSwEX4_ zd6@dZuteY|54FWPUS08PIEoX}!L-c)98-TYu%a-{sQtBie>?UpJJf}m&!=I}J`qtf zKU4W?J&tx~L@hfpm9M^R7wl6w7VM}_MZ6a+b~oBe)9F;c_aIV|$3r@m>SwRy1pC>1 zP?_*4)P)Xb>}N4Ui9Kx;9pbEqzWZ5$?PmpwX(~SdU8HOR-*f+gCG9~wNP_S&FX8(h z`T+mmCE*_I?$qg_kf+M$Yl|Fs4rEpSeFvUT?WSC;z+q^WA;)=et$CNPnK; zj0M`Axw)ZTUx+Nv%?}k~SQO)MYHlPnAU7H+2(uq$YfFxEE>&|H<*?N_iY)n5N zh(p>P475=bdcRBW*@tLvv)o+Q8;)z`O8a!|c`wK@%=<_g!%WE-W;taHONm+Mf^iHB zcF1B+SnPiu zPsX0*pMuEpOhufC7}IeU_Lm{fMO=qSybUpqcqL*bBKsxh8tIoz<$E_^i(&)2NvHCa zjuebNl&O6D$=J{xve+{gJ7O_D<`|GnyM}t&gilk1gkb-0 zexvyA+BGZE^bGH@Bejw0$fR&2)Ar!}@9HGpgF{J94R02`n9crS+hOq#_qi$CiTCTd zd7-J1DY-*J1-ZqcyvW4d;h_QH_?hLfOhu}mI%?^SdMIqRB$q1MHIw;}O~4 zc@H)OaRTB;^`10*5GVbXDbc4R6m~PVOo>e-81<=OZ|W4r4r)ZO3Z060tR=x{aSQJj zi_uOJjCPXH9kJL^i@lDNl<$;IrSu;^Ldw*Cd}q&udsVxsqhSBmzW~kb+fl=e;r-Ta zsim-`QZ`W=WZ_m)1*5m{?**m%YEaHjb%x_1#d9vOF9{3!+9GwY4$77;dbdHKjm&a= zOVJELf5=tQ9Vc9ef+2BU7{)34?`|CXen$ly#j9g#3EzkBI_xv=2e@v9{yPnEczCq% zXT2XV|C6(Jf1;SWnEi>mDRb=VGVOX6h3Ze4vW(wdN7VoxmNtMXE1MqRY>vBol~=Yg z^>cN8B5aMU<9ByXmI2&bUiiTwLcG_!_$wp+gCTwV%G~rYPw8O#?rmmr z&P~e^IgV=(IbYQwvX5PixC?PDB4?ZTA>NKi{7${+jKky4Ag(}s5OED6`%)t!pD6SA zhltIH&mwL>WL<7TEW>p`^?ID|w_wkc!B_&pczuGg6oNf% zv1crH%woT>7#;*@-aMVk_jnI4@(x&R0`!AmB|4Sw@f91vk`|){CfJ=8d(dJJS?mZ> za=oO6v3K}f z0p(c|sSAfgo4KkZe3^QDJL<#t+u_fnwW|fc9^2R@eQUg`r_`K7n}_{wmBM?lZnjzJ z_wi1ie13sBV?$&T6z2fsUKk!4Dh}uMrZYDvS<9VkH)}xI?X6ZtzZi9&hw+iJ?f9$& z`CbeAu>gDIDA$^8PLMuUs`BKVfbo-N)5-a%=x_KRs#<$W*;pMaf7zIE4ZFwNsPPA} zk0DZrEg6mk}RB{4L_+h}5s+5JkT-m9N&y zc^@26TAitUB~P&Xa4gs%or=KciNTIoj2d0&Ua{D#7AwFw6?wel5W1+vCRmL39zw@^ z522&gCm6MlU~4V5&SD)F>$cbp7Q4w}cUz1aUgRCL7_CUb4q5C8i_wadvb<=qS1k6b z#pXbp3mxAi6M3&%?1aVUhYa09oyzyNSgg%r2QBuX#h$U)5sSTw)Hu|7#5VBvl1fes$I~A6v=!~v*F{7(p%*eY(@fN0)#l?&~7c=q<=IUTR zgM|(*3J(g+3J((f;_6`5W2Q~*+T(m~3*8jwVwzna$MYGLY-P$9GFA#OklT~Hj6Qd=HaqAp~^k6JBONlcdN2jLSmtFy}iz#yKW5^htAdV z+_p32G0zz~lw8@E@#gCJ131N@_gTczdLPH0&+3=!FT(M*XQE!f>S7VKf2il`YyFj~(-cf`^iv)FGe_PWJRS&SC7 z@D}J)zIU$0I15M~F^h2)5Uj#toCO4Hv>0ar!P+dwSwOH|7Q4Y>)W$p;@fPY-zSm~4 z4vRf#G1}@Pj~2S{axGP`66jRHrs)*w87ZlIe#IhnA4Z0d`8bN%cfa1%bujvygu z(>rcKGVS@O;nMbe-+FiiMwX265sGgg?256f&(A>quwj?d%ofwkjCp`hS$Xm z?@Yy8p2q89hS$XmuiQtSlg8^}hS$Xm?|zkU`aO<|8D1ANy!R^JoV0vh%<#IH;XR;u z;WO5$XTf9+H@t!k#7Ilo@VB9ZV4fL)XLchZEl~W!V9OVW7UMbhK#mR9mQNoGJ$5V% z;#lzep6{fcx}gJ>r_FbKe@f*a#vDHYrPvTII8(kOVAYexU0dS#pyr#X>O$6PT|0p9 zW+9)M;bGL~i;C}1W#%857ZpqS<)Mt3lU!cD%LN;x*38A3bC_$d=rz36$m`rNIyU8J z-usEY(kXv((Q9~;udGWY)iub*=)7DUF4Q<}JC3*Qh_#425LYAe-kyDn_yI)TQ*nNq ziYW6NQ?kZ9MPWB%%ap7!3-&3C@jgkgLl%3+Vn;0Ys>M!N>`jY7?dd$CIu-FISd4R- z=T^75|Vs~2XK8rnIv4<`8sKuVK*b$2zv)FGe_PWJR zSu77Tom@wOPGRo0Skz)Mi}B7!u7m4h!pn6r!5S^L)?%E0g^u&D(CxC=4Hmo8Vs~5Y z0gD~97}xMc-XV(}u^4A@$>TQ`d&Od>EcT|w3NVX{yds^#FF`Ff!D4eP#=APnBWbZ} zi>VdVCb6Ztzzaz*S0YBi;J1L(Zvj}Yg-sz7c;yrW_VrO!tlD7;dL>? z>)IBE*ToF4iy2?>tcrYfEoz@V}tzvVuS2Pd(#Hlhe#Xb z7DU=0w;{4`5kG)<2O@2d7^2u9OoYLAcD~b5sWs7V6;I5qYWY$Z4kj|g9t_&L@?SQg3$&Mj5dg1v_S-; z4I&tA5W#4J2u2%3Fxnu3(FPHWHi%%fK?I`>A{cED!DxdBMjJ#h+8~0_1`&)lh+woq z1fvZi7;O;2XoCnw8$>YLAcD~b5sWs7V6;JGe9#7w@qv?S9fW;2^V#Nmftg^wZ^3cU z21#>$Dr?eF!-zfa?{(u|C*Aif8YD|OQmsZHi0ej1Uwh-uM9Oy#S$k7q0F zHf))~Gi{xUC@m(~qZT`)Q~4fsk?+ zS)0t?Ff%;DtLN2?mL)Br+SGlPOwq$M3D?5;y$GHF?Ck1pX;=T@!_g40thfYwp<|2j z9hcyJsVTGD4u`?Ve)}&<4m`49&vn{o5zj;XSHueuUqoa(EI^cYU`pnM`3k!kTc+?% zw@yVo)|_BZBPG17ec@%kSHPR1XT8V*P{9m~zP|*b^A!9cPJc^vW)J8yl&8gA&^rui zUkzpTd`Ay7T#W0@V=d2t0s&r^)gEgO@D@bGc)3i`z%Pxap+`i#b)w5bY6f%7=4+}m zdqkwiqJfZUJQn34Jq<^|mA6l>kr?kdsdC`FE(foV{4Ni5LpC1ch4UZj8MhE+6VFJ4 ziqtw1j-~!nb!)Dj=Ywqk&#Ax}-cX)_;9o!;2R-8we>kGCboB0cJeo79*YM8Fv_EWq8JAy=8jF9S+Qd{(3@utK)6;JMdPdKf22N zY*~2-rdK3>OF0rTfs42z>v&2V-+g=)NN-iW`OA!_35mzwHBX>$)|x5$t$P9;rP?sv z6XkN0;Ol&-sb|N7gaB`AC$$F+CCXgP19+_cudgtMo`-#{G=z*I#!{}ry3wqwjVmXPMd0-0CrkpGX&z+CRVB{Gu zi>xcw8NPF+@r{t%D<^oi#6~8`KwqHaN?tMyPfXx@L}rTJV9{bVs1LcvhcJ+K$S8 z4-c-8O?~(X@_`pORTkgduo9zYNn7(~tT)1g2+C9IlxJbq@~ELDj+`+v*33yAXK4(T zH@(v_?>`~$pZN5+2NN2{^kl2JmD_poIM4cv0e8QgBmG#=&nLaEIbu;_IU=L0srgF$ zZ=!iUe*DjK<8UsHbCk1fdpB~}x{<%VW`3-9LsJ2omL09#$~86cLilW*1YT9H4!+qb zp1~&rb3Wlvp216isV7X(Eu70qqhEtp$5U}k8{fSa(z$rHvat+v!RtKow(`}hNGd-mECy~uy|`TvLsh=%r7pEqYrCk@&AB7v;AKDgIs~j&wz#o@gQJ2% z+)2AP&&F`6O;WYV92alL>pAO=cAu#_)(5?AQ@;>5o|%cUFK2o^F9RKUXyeoCc{z`D zh-Ml6EIbuoUtZ5EAcOVB_iO0sH#nzhTcQt7zs9ri5>=j{w`{gQua8fJY2(wg@lr)A zh3~J8_)fiLCy^(w^=@PfCogZy6ZJAx?vy9$k@k>2q z*hy{|eaD`t>yQs^p||Ua`r`hTvo}xFS#46zEe*O{#uIfE$NHYQh-qVYtU}tomt2iw zGq;j%C8CFqKh|)MK)a;_d&7STaM#|T?ZtR0@SvQKcbS&MIUO^O*N9`z>1(m4{lYw1 z9`as}v@HWLQ-*+C@EaS6GI&kKmZA+n8O?|cDLT2|W?6&sFbivXo{NFTEr+q;Zq)aq z%!Bjh7R+au>ePJoKJZ%uRn1qv*92@^M@uJu*wT5Cp2OAwyDmkj=9KloI7beXx> z?^}V}eC>=PQ;j?5-p;(hGF}1sEaS__o$XA$D1A>n2DjlDPf60etG6qRICbTjbuRPS z3LcJWdRM2HZ7_OaM6*UfPwDIr?6axrrN?#g^s8q^_45(756enh$sK21I8NE`_*({! z>CLVvph51|)oLz}rK0!Lh_a-z?(E@%g`-As9R zj8`{SdG*DDN)p_aMqoj$jsUz^K^Vf`286hxjPYxnqN6VO`Bb%(TPIeF5`J z<>h-H#<9ukCZu&<_z6s>@{*0rPV%~$mpkt8Wum(7A;7u5W9lq(J%`@oGp++pa3B?Z z!|emqE9?WLy#-PAqbBiaZ)9h#FB!ZT^zOP+MqkwbjiL8;SwD2^{|@kS-H~Nsn)QDt z_AJXsvHut%KAq|6?%b~KN3ztFa<)y6;;bu{iEY69WUB^r+Y@KrEQjZ$S+~Ru@5BsV zgHHzT+Wc%6$|P>=d_$XQbGx+0W;e9Fw{&fLgY#a~#aTx(rerQTU$@uiK_~6i%M%2& zb#Hc{^IIxfmF};lut>uDzg*al#_o1c_eZPF=CV~P3rM_9-S36eH`A!KtLj?Xt2QDZ z+Q;MA{N7ddo!d6Fbaid(OmuG8(%OytP&iIwe>F5Y-c{BRBQ_pfVaTe78?_a!S6f=n zjhGWUYDC{8Iy%}~H{j=Z+qNd)dktCWd`Sn7>m9fer(Wunj_U=ZkWXSmck7icwwN_E z$xS(;IA6QHeSJ%3-6l)X#d}#P=LDA1T;NKWfVvF4h7!tdgP%E7#-*LjTer70ceZx# zbn0iCQ$N)$SGMqe)YQui=UhX}m96|~AM1_xdtXE!VVeD5Fucv*&tn~8n440Kr0yeHzqzxyJ-P(HbL@(i?3h1q%Gxz>|F-R_uIO_7gmGBa z5PF`PK4Hb2Me$51*ehQ{~H!Alaj>Bnno#g^np1HKFx3B7Y zi=mnp=(4|^@xwajz1!DVRvr2*W0oRkEQj~I&UqaV>g$+=ycebV*jxT39Q*cocfN1R zd=$XH!@YJAYh5D;c>k=g_Uq17zs64z?04Zz^VxX_EoM?Y9;7gAy!pI^(1Dh#P)drF zLlj1W-Q4Iv8$&21MM^%0<$VZTxvH&f&caS8B}K|n3gdaclV!rWNC>5*NXcj8BJ-3X z!=61vC?!QoY968FdVvX(kPu2qk&@rl3gtmVhW%89vX&%8N`2a6G#qHG=Sv@dPcCi@kYb4F1YTgv=o?X-O_!|w z89S2sa*Xsk*7)BRPu>u*l7FFFFcOeFPH~wQWNm2A){bPhLQ3+t#x@<`&V`(D`n}Mfq&@*&y)?elKJ`=!{C7A^MHzfcb@;<*vIbDUYQ-qO8NR!6da%V zpZRG6Zum%!aK26q2}quRvnk0R`2FNBYG2NdgSJ9N!_mrcMd6=L7NWHzw6akVNR#fn zoi!Zt*)j|-wGGEwl;Nt@T%<|o;)_lp-{eI<@x_+wQ<{r3>0D}J@u{{MuKeJRM{x5Y z2i{GhuGB4WI+vP+e5!Z`dY2z&xt3}!(xh_@2NLq-U#bd`JHE2Z%t2J2Vq< z3@_~H1?<^3)V%zypeK9QUdZPwf~@_qAKvq|peK9QRmkV-pX_aK3_J0V)_zW2C5mPm z3d2@e^zX^zK~MHm6b)O3d5!#TrDqf8}wv9L(w$qI{d@@_pc0kvZqN8O$!=o z>Y7V;UYh2~ekDLLX#91YNDw~IUOk*94%*9c^%cW$$}{@oul?$8y1g74Wk#s^f}QS~ z@}?6(@A9mrmm_C(8qL3b?ME@)UJlKiG@Ac&a?xDfUJi{iTWonw7v3^0 z=%rp6G?r$-^)D9a_HyK0kd_y(UALD*Ge1BR^kmOh@>176weJ2GgP!acq|wwRmfj}q z1=t#Jf6oZP zUXW-2*>4JNY3>iuGzE~w0fc(c1j%csImBKN+*R2i$@BGo0 zf~sgz-mK*jZ_5s^sb%ZN)WN&q!9I)s1^BIRZSQE(zU@_dX-oGC^`dDNZt(+N?n#~L z?m-JFZ`;<@l9VSHBDP9?hK$9W71eM|&3Bf(#j?g0d~|y;{cF?d`x$)H_q9eAS10K% zTzt%z+Qmb2hPf!$@{41=pOY+laXX({%gcTZ;siY7X?whMRy^fw-g%54lu@35zw(6g za4+RJgFAS>s}PjJ>x8Rt<@LOmD|MW#H+SKQXm^I2bzKWV|LYyH@}=Io2<8l@c^n`P)nrNODWsi9aYc%%zuI3R&P^Gr7kre$YWy*tj%mACYz@!HyCU0Hp_@}Rf$ zj3PPC(wmioa3x@QyuLb7ws0P^#a@+i2Y{nx z{OkDQxkxQl+bYLRij^|2Vp&zPvSvwDT>dX@9hhsU=gZ6LYb)!PC#C)}7g`q2!AeUe KOaJ|(=l>VZ1acn$ diff --git a/r5dev/thirdparty/lzham/libs/lzhamcomp_x64D.lib b/r5dev/thirdparty/lzham/libs/lzhamcomp_x64D.lib deleted file mode 100644 index f593696f9eb493b9d5b596b90a93aa54870bcd90..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 824648 zcmeEv3t(MUmG()KLMVl_SZhJVP$NbJnzU(2Yi-Vb=G^4IXj3Ryy}eCtnm}IUCZ#Yw ziYZ7bAft>j%8ZPo4&&$yIt*52#+D+*$2dMv8OL$(G1@A>1IqB@W8nY3wfA}5d+sBE z^ZGsQ&f0hHwbx#I?X}l_o_)^Vn4caT*|ca?tN-cn{8WDL-`3VO7j|{76Pz833}eAg z!+6)1>vx}dn_>LU%}WN2Cp~EV&izgXzte&L-a2sNOxXCH`~Oo0i%$Ni@jLgwLk1`R zpI;gO16|MH1(^LLt+}To+46GvQb)ZjOxh ztnF!wrh3*+_%PO6{e78uB%3jrz2KyQm+o0R>cfk~&3Go2N`|eJsYq$GaepC%kG6PH zsI|pGr>8BFbQp@p%}g|riDnXM6A_8=+|cOYOs+V3O#zted)9U$w9m_ihrUAv0!U_( zk#MpM3)r)Ea=7U57s;6EY$6lti>FP5+qts9om=%UsS8ixr~!pNGt(e4Ixz~7fU(?6 zerGXICALu+Is|blKb;>hLJ_D`(}iMja@wmsrl7Vd5ls}XGPf$Pjh!pboWfLxr&dk_V$|C3cB!t3s9fy{j-IH8V3ZUC0j=&6#}h3N(<(F`L9iv2ZBC z5)rdFJ($Z6jTNTXtVXMd9Or3bh@C5~A>9EalAf)j3pYC0e0SE}h7w#WHwm_~J6L z+2WIG^+fyYlG<@`kRbiZeHeZUS{pn$1gd~1zQgo#Z>RTV5lq5|qNq?OD#HJl>`Sb3u1to<(4bo^821kp~DCALIqJWIOB<7daR+C(QdOCkK zY+4b@ouAIlTsnIw1q)84OVrbO^sM**QoR(2F!+8+YlCQ!+Md4RTQ(gX55;|4j2q#fi z^d47oebpkj%3vCu&!E%$R7Iaa&DsbytWVw!k4l;eso<(Lu;;tDy%8PxB>F6*=-H3~sN2qPZBI7{p*0UD;rMDnB?nL;G4fti<3%4FzSE z=!_l$?QwA1^b9#XqqB+Uq21yIUxwP9@ljp;%VmC!Z{Cjfn@9KAF{M}Q^=sTByhZ1;pN=~5Zl!x|ah z%@%VriU3FYAe8IJpV(?KH06wO%BaWo^CW2JK0G#C9ATanNYzZg40@fDx}|BC>A`r6_~z4 zQddNQsVe0dn;5E*vO<30$yskws!5rc`b*Q=x>h11)(i-QWBp}p+9~`@x(O=fP|BXL zGM~ks4$MDBCw57zsI@TEQQnz2BY>Wc`OibLnJ8()> zt&A_koULsfCUJar9P?y{^zPu*BkATT6(Ua2{_M;TUJ)=NU?t|# zAt)xX2gfk;tbnzR3r!^mXb!;>25mEKm1ZuIzW#+O%3`d*Nomy_oQ1Od)KmejHMk0; zgco(yhk~^mm8W#TZZn=Kif)KbGa<^* zXmQ4@f`c{6v3x}orA%0D#z6DADN1;&qbO|#R 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

  • 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%0A>$ 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 RZQGJq4aZ+%HrH5J{12VwOh5nt diff --git a/r5dev/thirdparty/lzham/libs/lzhamdecomp_x64.lib b/r5dev/thirdparty/lzham/libs/lzhamdecomp_x64.lib deleted file mode 100644 index 5772956d7b82f44798e3f1aa3c6ff1372b4a4dc1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 599642 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�wPd$k-dxjM16|GrcS(n` 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%0D?Y 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

    rF`vHAa!)H-*-?UwnyOV*T( zR2yTsNB*!<{z$$2GXJQu?Z07v=ql(Br+&1`^&FG0sobA*m$t)v`1?}iv9_a(gDMAQ z;QNW3`;YntW&B6wpp1-l(ART5=uo*MX{nTvmXx9SaKF~BN4j7>?NT|2RS&xcdd%ZC z7EV|BvB-mZ|JXX8RE{*0CAP4-U%COZ#S*CdH7W;nzfR?Sw7L2^q#r5KQ!q#1Gv&@* zAW_W;Y~u^c>>LC0CO*xL-}dy!>5VEst}^;@;`PwmxfXnMmC6=Bl#6`&Ce!_~cqVzwB(x0d6dSL$ol`p0JH>31#sf?I- zb|&@=J23D<<=>=o5%r@qE(q)&sq!4vqaU7((m$>81uTEc(I2;elFG9+UPo0PQu#-b zi)DPgEdS<3PGa6Kh4#?!&Alqmranpc#6jJLs63DQ9Z~w5R1WgLAEp0Cl)f~yM@IQ& zDqDW|?#(FuTPg?TuhKnqP`|Y*2j%aN()UE^7iCK!p}tw7vgL>GURK#+8=UveoFGu< z0`x7q@%t(-R2lkt8czjd>-kW;h4#Iua!~(sLh%;#b5u4x`o29%-=Xq(dXFNeSg7$= zyIUxy+Ncxq%++`+@X7fqTU?6!>!(rrS5*#tHv0rg6!OV@l>_~cqx3%w>CtEBgyJ}D zlgfclpAE^V?7YMB<>5)U%l;Yb zI&4@xc6YLWW{mX#X@8h6e_R90^5ZSvmc?5yrDe&y2LGbG4`(4yiks!x_^-+jq@OLZ z>8rB$K2cVW(X!w8q5LbCd9hmd-meT9?bge@xJAyLZZn36;jqtu5dHj9*7|$oRZ*NWZ_wDEl+~47N z4ZaD-YtX;8N}!wR#cNi6s>Wv)Yaq=Sl^>JH!2ECV-1^iXM{?ZRUW|ZoeV)csfnOG= zJXF>Z%Xf*&?Iu>C6-&Xp- zquIb22HJVO%8jWj5?A)KpzgtFgx%E zZo71qS5bd{D7J$BLY3F69&NdL^vCmGtMW1_cXlT3jb4=}MlO((u4m<+Uv2>!>iGb6 z3sqi0{p(Ts->SS^^;k11aFc}cSE{^}`e7RLn2%xqFqJKaLcJe}(m$@U-GA`Q_@m`d z$o}yvUΖ>PQr}6lbCSLsSl8-rJ(|cc>iH??9CP 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­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%0AO{Q%&tPC7`XxqFQGwp3C770MT8e4ersbMeW?H#v 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≥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≫Zk$Zu_Pu7v? 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 diff --git a/r5dev/thirdparty/lzham/lzham_api.cpp b/r5dev/thirdparty/lzham/lzham_api.cpp new file mode 100644 index 00000000..c622b6c5 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_api.cpp @@ -0,0 +1,179 @@ +// File: lzham_api.cpp - Dynamic DLL entrypoints. +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "lzhamdecomp/lzham_decomp.h" +#include "lzhamcomp/lzham_comp.h" + +extern "C" LZHAM_DLL_EXPORT lzham_uint32 lzham_get_version(void) +{ + return LZHAM_DLL_VERSION; +} + +extern "C" LZHAM_DLL_EXPORT void lzham_set_memory_callbacks(lzham_realloc_func pRealloc, lzham_msize_func pMSize, void* pUser_data) +{ + lzham::lzham_lib_set_memory_callbacks(pRealloc, pMSize, pUser_data); +} + +extern "C" LZHAM_DLL_EXPORT lzham_decompress_state_ptr lzham_decompress_init(const lzham_decompress_params *pParams) +{ + return lzham::lzham_lib_decompress_init(pParams); +} + +extern "C" LZHAM_DLL_EXPORT lzham_decompress_state_ptr lzham_decompress_reinit(lzham_decompress_state_ptr p, const lzham_decompress_params *pParams) +{ + return lzham::lzham_lib_decompress_reinit(p, pParams); +} + +extern "C" LZHAM_DLL_EXPORT lzham_decompress_checksums* lzham_decompress_deinit(lzham_decompress_state_ptr p) +{ + return lzham::lzham_lib_decompress_deinit(p); +} + +extern "C" LZHAM_DLL_EXPORT lzham_decompress_status_t lzham_decompress( + lzham_decompress_state_ptr p, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_bool no_more_input_bytes_flag) +{ + return lzham::lzham_lib_decompress(p, pIn_buf, pIn_buf_size, pOut_buf, pOut_buf_size, no_more_input_bytes_flag); +} + +extern "C" LZHAM_DLL_EXPORT lzham_decompress_status_t lzham_decompress_memory(const lzham_decompress_params *pParams, lzham_uint8* pDst_buf, size_t *pDst_len, const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32, lzham_uint32 *pCrc32) +{ + return lzham::lzham_lib_decompress_memory(pParams, pDst_buf, pDst_len, pSrc_buf, src_len, pAdler32, pCrc32); +} + +extern "C" LZHAM_DLL_EXPORT lzham_compress_state_ptr lzham_compress_init(const lzham_compress_params *pParams) +{ + return lzham::lzham_lib_compress_init(pParams); +} + +extern "C" LZHAM_DLL_EXPORT lzham_compress_state_ptr lzham_compress_reinit(lzham_compress_state_ptr p) +{ + return lzham::lzham_lib_compress_reinit(p); +} + +extern "C" LZHAM_DLL_EXPORT lzham_compress_checksums* lzham_compress_deinit(lzham_compress_state_ptr p) +{ + return lzham::lzham_lib_compress_deinit(p); +} + +extern "C" LZHAM_DLL_EXPORT lzham_compress_status_t lzham_compress( + lzham_compress_state_ptr p, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_bool no_more_input_bytes_flag) +{ + return lzham::lzham_lib_compress(p, pIn_buf, pIn_buf_size, pOut_buf, pOut_buf_size, no_more_input_bytes_flag); +} + +extern "C" LZHAM_DLL_EXPORT lzham_compress_status_t lzham_compress2( + lzham_compress_state_ptr p, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_flush_t flush_type) +{ + return lzham::lzham_lib_compress2(p, pIn_buf, pIn_buf_size, pOut_buf, pOut_buf_size, flush_type); +} + +extern "C" LZHAM_DLL_EXPORT lzham_compress_status_t lzham_compress_memory(const lzham_compress_params *pParams, lzham_uint8* pDst_buf, size_t *pDst_len, const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32, lzham_uint32 * pCrc32) +{ + return lzham::lzham_lib_compress_memory(pParams, pDst_buf, pDst_len, pSrc_buf, src_len, pAdler32, pCrc32); +} + +// ----------------- zlib-style API's + +extern "C" LZHAM_DLL_EXPORT const char *lzham_z_version(void) +{ + return LZHAM_Z_VERSION; +} + +extern "C" lzham_z_ulong LZHAM_DLL_EXPORT lzham_z_adler32(lzham_z_ulong adler, const unsigned char *ptr, size_t buf_len) +{ + return lzham::lzham_lib_z_adler32(adler, ptr, buf_len); +} + +extern "C" lzham_z_ulong LZHAM_DLL_EXPORT lzham_z_crc32(lzham_z_ulong crc, const lzham_uint8 *ptr, size_t buf_len) +{ + return lzham::lzham_lib_z_crc32(crc, ptr, buf_len); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_deflateInit(lzham_z_streamp pStream, int level) +{ + return lzham::lzham_lib_z_deflateInit(pStream, level); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_deflateInit2(lzham_z_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy) +{ + return lzham::lzham_lib_z_deflateInit2(pStream, level, method, window_bits, mem_level, strategy); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_deflateReset(lzham_z_streamp pStream) +{ + return lzham::lzham_lib_z_deflateReset(pStream); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_deflate(lzham_z_streamp pStream, int flush) +{ + return lzham::lzham_lib_z_deflate(pStream, flush); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_deflateEnd(lzham_z_streamp pStream) +{ + return lzham::lzham_lib_z_deflateEnd(pStream); +} + +extern "C" LZHAM_DLL_EXPORT lzham_z_ulong lzham_z_deflateBound(lzham_z_streamp pStream, lzham_z_ulong source_len) +{ + return lzham::lzham_lib_z_deflateBound(pStream, source_len); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_compress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len) +{ + return lzham::lzham_lib_z_compress(pDest, pDest_len, pSource, source_len); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_compress2(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len, int level) +{ + return lzham::lzham_lib_z_compress2(pDest, pDest_len, pSource, source_len, level); +} + +extern "C" LZHAM_DLL_EXPORT lzham_z_ulong lzham_z_compressBound(lzham_z_ulong source_len) +{ + return lzham::lzham_lib_z_compressBound(source_len); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_inflateInit(lzham_z_streamp pStream) +{ + return lzham::lzham_lib_z_inflateInit(pStream); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_inflateInit2(lzham_z_streamp pStream, int window_bits) +{ + return lzham::lzham_lib_z_inflateInit2(pStream, window_bits); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_inflateReset(lzham_z_streamp pStream) +{ + return lzham::lzham_lib_z_inflateReset(pStream); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_inflate(lzham_z_streamp pStream, int flush) +{ + return lzham::lzham_lib_z_inflate(pStream, flush); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_inflateEnd(lzham_z_streamp pStream) +{ + return lzham::lzham_lib_z_inflateEnd(pStream); +} + +extern "C" LZHAM_DLL_EXPORT int lzham_z_uncompress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len) +{ + return lzham::lzham_lib_z_uncompress(pDest, pDest_len, pSource, source_len); +} + +extern "C" LZHAM_DLL_EXPORT const char *lzham_z_error(int err) +{ + return lzham::lzham_lib_z_error(err); +} diff --git a/r5dev/thirdparty/lzham/lzham_assert.cpp b/r5dev/thirdparty/lzham/lzham_assert.cpp new file mode 100644 index 00000000..efaf0a79 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_assert.cpp @@ -0,0 +1,66 @@ +// File: lzham_assert.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" + +static bool g_fail_exceptions; +static bool g_exit_on_failure = true; + +void lzham_enable_fail_exceptions(bool enabled) +{ + g_fail_exceptions = enabled; +} + +void lzham_assert(const char* pExp, const char* pFile, unsigned line) +{ + char buf[512]; + + sprintf_s(buf, sizeof(buf), "%s(%u): Assertion failed: \"%s\"\n", pFile, line, pExp); + + lzham_output_debug_string(buf); + + printf("%s", buf); + + if (lzham_is_debugger_present()) + lzham_debug_break(); +} + +void lzham_fail(const char* pExp, const char* pFile, unsigned line) +{ + char buf[512]; + + sprintf_s(buf, sizeof(buf), "%s(%u): Failure: \"%s\"\n", pFile, line, pExp); + + lzham_output_debug_string(buf); + + printf("%s", buf); + + if (lzham_is_debugger_present()) + lzham_debug_break(); + +#if LZHAM_USE_WIN32_API + if (g_fail_exceptions) + RaiseException(LZHAM_FAIL_EXCEPTION_CODE, 0, 0, NULL); + else +#endif + if (g_exit_on_failure) + exit(EXIT_FAILURE); +} + +void lzham_trace(const char* pFmt, va_list args) +{ + if (lzham_is_debugger_present()) + { + char buf[512]; + vsprintf_s(buf, sizeof(buf), pFmt, args); + + lzham_output_debug_string(buf); + } +}; + +void lzham_trace(const char* pFmt, ...) +{ + va_list args; + va_start(args, pFmt); + lzham_trace(pFmt, args); + va_end(args); +}; diff --git a/r5dev/thirdparty/lzham/lzham_checksum.cpp b/r5dev/thirdparty/lzham/lzham_checksum.cpp new file mode 100644 index 00000000..3dc616d4 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_checksum.cpp @@ -0,0 +1,73 @@ +// File: lzham_checksum.cpp +#include "include/lzham_core.h" +#include "include/lzham_checksum.h" + +namespace lzham +{ + // Originally from the public domain stb.h header. + uint adler32(const void* pBuf, size_t buflen, uint adler32) + { + if (!pBuf) + return cInitAdler32; + + const uint8* buffer = static_cast(pBuf); + + const unsigned long ADLER_MOD = 65521; + unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16; + size_t blocklen; + unsigned long i; + + blocklen = buflen % 5552; + while (buflen) + { + for (i=0; i + 7 < blocklen; i += 8) + { + s1 += buffer[0], s2 += s1; + s1 += buffer[1], s2 += s1; + s1 += buffer[2], s2 += s1; + s1 += buffer[3], s2 += s1; + s1 += buffer[4], s2 += s1; + s1 += buffer[5], s2 += s1; + s1 += buffer[6], s2 += s1; + s1 += buffer[7], s2 += s1; + + buffer += 8; + } + + for (; i < blocklen; ++i) + s1 += *buffer++, s2 += s1; + + s1 %= ADLER_MOD, s2 %= ADLER_MOD; + buflen -= blocklen; + blocklen = 5552; + } + return (s2 << 16) + s1; + } + + // Karl Malbrain's compact CRC-32, with pre and post conditioning. + // See "A compact CCITT crc16 and crc32 C implementation that balances processor cache usage against speed": + // http://www.geocities.com/malbrain/ + static const lzham_uint32 s_crc32[16] = + { + 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, + 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c + }; + + uint crc32(uint crc, const lzham_uint8 *ptr, size_t buf_len) + { + if (!ptr) + return cInitCRC32; + + crc = ~crc; + while (buf_len--) + { + lzham_uint8 b = *ptr++; + crc = (crc >> 4) ^ s_crc32[(crc & 0xF) ^ (b & 0xF)]; + crc = (crc >> 4) ^ s_crc32[(crc & 0xF) ^ (b >> 4)]; + } + return ~crc; + } + + +} // namespace lzham + diff --git a/r5dev/thirdparty/lzham/lzham_huffman_codes.cpp b/r5dev/thirdparty/lzham/lzham_huffman_codes.cpp new file mode 100644 index 00000000..2ca7e392 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_huffman_codes.cpp @@ -0,0 +1,390 @@ +// File: huffman_codes.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_huffman_codes.h" + +namespace lzham +{ + struct sym_freq + { + uint m_freq; + uint16 m_left; + uint16 m_right; + + inline bool operator< (const sym_freq& other) const + { + return m_freq > other.m_freq; + } + }; + + static inline sym_freq* radix_sort_syms(uint num_syms, sym_freq* syms0, sym_freq* syms1) + { + const uint cMaxPasses = 2; + uint hist[256 * cMaxPasses]; + + memset(hist, 0, sizeof(hist[0]) * 256 * cMaxPasses); + + { + sym_freq* p = syms0; + sym_freq* q = syms0 + (num_syms >> 1) * 2; + + for ( ; p != q; p += 2) + { + const uint freq0 = p[0].m_freq; + const uint freq1 = p[1].m_freq; + + hist[ freq0 & 0xFF]++; + hist[256 + ((freq0 >> 8) & 0xFF)]++; + + hist[ freq1 & 0xFF]++; + hist[256 + ((freq1 >> 8) & 0xFF)]++; + } + + if (num_syms & 1) + { + const uint freq = p->m_freq; + + hist[ freq & 0xFF]++; + hist[256 + ((freq >> 8) & 0xFF)]++; + } + } + + sym_freq* pCur_syms = syms0; + sym_freq* pNew_syms = syms1; + + const uint total_passes = (hist[256] == num_syms) ? 1 : cMaxPasses; + + for (uint pass = 0; pass < total_passes; pass++) + { + const uint* pHist = &hist[pass << 8]; + + uint offsets[256]; + + uint cur_ofs = 0; + for (uint i = 0; i < 256; i += 2) + { + offsets[i] = cur_ofs; + cur_ofs += pHist[i]; + + offsets[i+1] = cur_ofs; + cur_ofs += pHist[i+1]; + } + + const uint pass_shift = pass << 3; + + sym_freq* p = pCur_syms; + sym_freq* q = pCur_syms + (num_syms >> 1) * 2; + + for ( ; p != q; p += 2) + { + uint c0 = p[0].m_freq; + uint c1 = p[1].m_freq; + + if (pass) + { + c0 >>= 8; + c1 >>= 8; + } + + c0 &= 0xFF; + c1 &= 0xFF; + + if (c0 == c1) + { + uint dst_offset0 = offsets[c0]; + + offsets[c0] = dst_offset0 + 2; + + pNew_syms[dst_offset0] = p[0]; + pNew_syms[dst_offset0 + 1] = p[1]; + } + else + { + uint dst_offset0 = offsets[c0]++; + uint dst_offset1 = offsets[c1]++; + + pNew_syms[dst_offset0] = p[0]; + pNew_syms[dst_offset1] = p[1]; + } + } + + if (num_syms & 1) + { + uint c = ((p->m_freq) >> pass_shift) & 0xFF; + + uint dst_offset = offsets[c]; + offsets[c] = dst_offset + 1; + + pNew_syms[dst_offset] = *p; + } + + sym_freq* t = pCur_syms; + pCur_syms = pNew_syms; + pNew_syms = t; + } + +#if LZHAM_ASSERTS_ENABLED + uint prev_freq = 0; + for (uint i = 0; i < num_syms; i++) + { + LZHAM_ASSERT(!(pCur_syms[i].m_freq < prev_freq)); + prev_freq = pCur_syms[i].m_freq; + } +#endif + + return pCur_syms; + } + + struct huffman_work_tables + { + enum { cMaxInternalNodes = cHuffmanMaxSupportedSyms }; + + sym_freq syms0[cHuffmanMaxSupportedSyms + 1 + cMaxInternalNodes]; + sym_freq syms1[cHuffmanMaxSupportedSyms + 1 + cMaxInternalNodes]; + +#if !USE_CALCULATE_MINIMUM_REDUNDANCY + uint16 queue[cMaxInternalNodes]; +#endif + }; + + uint get_generate_huffman_codes_table_size() + { + return sizeof(huffman_work_tables); + } + +#define USE_CALCULATE_MINIMUM_REDUNDANCY 1 +#if USE_CALCULATE_MINIMUM_REDUNDANCY + /* calculate_minimum_redundancy() written by + Alistair Moffat, alistair@cs.mu.oz.au, + Jyrki Katajainen, jyrki@diku.dk + November 1996. + */ + static void calculate_minimum_redundancy(int A[], int n) { + int root; /* next root node to be used */ + int leaf; /* next leaf to be used */ + int next; /* next value to be assigned */ + int avbl; /* number of available nodes */ + int used; /* number of internal nodes */ + int dpth; /* current depth of leaves */ + + /* check for pathological cases */ + if (n==0) { return; } + if (n==1) { A[0] = 0; return; } + + /* first pass, left to right, setting parent pointers */ + A[0] += A[1]; root = 0; leaf = 2; + for (next=1; next < n-1; next++) { + /* select first item for a pairing */ + if (leaf>=n || A[root]=n || (root=0; next--) + A[next] = A[A[next]]+1; + + /* third pass, right to left, setting leaf depths */ + avbl = 1; used = dpth = 0; root = n-2; next = n-1; + while (avbl>0) { + while (root>=0 && A[root]==dpth) { + used++; root--; + } + while (avbl>used) { + A[next--] = dpth; avbl--; + } + avbl = 2*used; dpth++; used = 0; + } + } +#endif + + bool generate_huffman_codes(void* pContext, uint num_syms, const uint16* pFreq, uint8* pCodesizes, uint& max_code_size, uint& total_freq_ret) + { + if ((!num_syms) || (num_syms > cHuffmanMaxSupportedSyms)) + return false; + + huffman_work_tables& state = *static_cast(pContext);; + + uint max_freq = 0; + uint total_freq = 0; + + uint num_used_syms = 0; + for (uint i = 0; i < num_syms; i++) + { + uint freq = pFreq[i]; + + if (!freq) + pCodesizes[i] = 0; + else + { + total_freq += freq; + max_freq = math::maximum(max_freq, freq); + + sym_freq& sf = state.syms0[num_used_syms]; + sf.m_left = (uint16)i; + sf.m_right = UINT16_MAX; + sf.m_freq = freq; + num_used_syms++; + } + } + + total_freq_ret = total_freq; + + if (num_used_syms == 1) + { + pCodesizes[state.syms0[0].m_left] = 1; + return true; + } + + sym_freq* syms = radix_sort_syms(num_used_syms, state.syms0, state.syms1); + +#if USE_CALCULATE_MINIMUM_REDUNDANCY + int x[cHuffmanMaxSupportedSyms]; + for (uint i = 0; i < num_used_syms; i++) + x[i] = syms[i].m_freq; + + calculate_minimum_redundancy(x, num_used_syms); + + uint max_len = 0; + for (uint i = 0; i < num_used_syms; i++) + { + uint len = x[i]; + max_len = math::maximum(len, max_len); + pCodesizes[syms[i].m_left] = static_cast(len); + } + max_code_size = max_len; +#else + // Computes Huffman codelengths in linear time. More readable than calculate_minimum_redundancy(), and approximately the same speed, but not in-place. + + // Dummy node + sym_freq& sf = state.syms0[num_used_syms]; + sf.m_left = UINT16_MAX; + sf.m_right = UINT16_MAX; + sf.m_freq = UINT_MAX; + + uint next_internal_node = num_used_syms + 1; + + uint queue_front = 0; + uint queue_end = 0; + + uint next_lowest_sym = 0; + + uint num_nodes_remaining = num_used_syms; + do + { + uint left_freq = syms[next_lowest_sym].m_freq; + uint left_child = next_lowest_sym; + + if ((queue_end > queue_front) && (syms[state.queue[queue_front]].m_freq < left_freq)) + { + left_child = state.queue[queue_front]; + left_freq = syms[left_child].m_freq; + + queue_front++; + } + else + next_lowest_sym++; + + uint right_freq = syms[next_lowest_sym].m_freq; + uint right_child = next_lowest_sym; + + if ((queue_end > queue_front) && (syms[state.queue[queue_front]].m_freq < right_freq)) + { + right_child = state.queue[queue_front]; + right_freq = syms[right_child].m_freq; + + queue_front++; + } + else + next_lowest_sym++; + + LZHAM_ASSERT(next_internal_node < huffman_work_tables::cMaxInternalNodes); + + const uint internal_node_index = next_internal_node; + next_internal_node++; + + syms[internal_node_index].m_freq = left_freq + right_freq; + syms[internal_node_index].m_left = static_cast(left_child); + syms[internal_node_index].m_right = static_cast(right_child); + + LZHAM_ASSERT(queue_end < huffman_work_tables::cMaxInternalNodes); + state.queue[queue_end] = static_cast(internal_node_index); + queue_end++; + + num_nodes_remaining--; + + } while (num_nodes_remaining > 1); + + LZHAM_ASSERT(next_lowest_sym == num_used_syms); + LZHAM_ASSERT((queue_end - queue_front) == 1); + + uint cur_node_index = state.queue[queue_front]; + + uint32* pStack = (syms == state.syms0) ? (uint32*)state.syms1 : (uint32*)state.syms0; + uint32* pStack_top = pStack; + + uint max_level = 0; + + for ( ; ; ) + { + uint level = cur_node_index >> 16; + uint node_index = cur_node_index & 0xFFFF; + + uint left_child = syms[node_index].m_left; + uint right_child = syms[node_index].m_right; + + uint next_level = (cur_node_index + 0x10000) & 0xFFFF0000; + + if (left_child < num_used_syms) + { + max_level = math::maximum(max_level, level); + + pCodesizes[syms[left_child].m_left] = static_cast(level + 1); + + if (right_child < num_used_syms) + { + pCodesizes[syms[right_child].m_left] = static_cast(level + 1); + + if (pStack == pStack_top) break; + cur_node_index = *--pStack; + } + else + { + cur_node_index = next_level | right_child; + } + } + else + { + if (right_child < num_used_syms) + { + max_level = math::maximum(max_level, level); + + pCodesizes[syms[right_child].m_left] = static_cast(level + 1); + + cur_node_index = next_level | left_child; + } + else + { + *pStack++ = next_level | left_child; + + cur_node_index = next_level | right_child; + } + } + } + + max_code_size = max_level + 1; +#endif + + return true; + } + +} // namespace lzham + diff --git a/r5dev/thirdparty/lzham/lzham_lzbase.cpp b/r5dev/thirdparty/lzham/lzham_lzbase.cpp new file mode 100644 index 00000000..e5cf7c06 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_lzbase.cpp @@ -0,0 +1,71 @@ +// File: lzham_lzbase.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_lzbase.h" + +namespace lzham +{ + void CLZBase::init_slot_tabs() + { + for (uint i = 0; i < m_num_lzx_slots; i++) + { + //printf("%u: 0x%08X - 0x%08X, %u\n", i, m_lzx_position_base[i], m_lzx_position_base[i] + (1 << m_lzx_position_extra_bits[i]) - 1, m_lzx_position_extra_bits[i]); + + uint lo = m_lzx_position_base[i]; + uint hi = lo + m_lzx_position_extra_mask[i]; + + uint8* pTab; + uint shift; + uint n; LZHAM_NOTE_UNUSED(n); + + if (hi < 0x1000) + { + pTab = m_slot_tab0; + shift = 0; + n = sizeof(m_slot_tab0); + } + else if (hi < 0x100000) + { + pTab = m_slot_tab1; + shift = 11; + n = sizeof(m_slot_tab1); + } + else if (hi < 0x1000000) + { + pTab = m_slot_tab2; + shift = 16; + n = sizeof(m_slot_tab2); + } + else + break; + + lo >>= shift; + hi >>= shift; + + LZHAM_ASSERT(hi < n); + memset(pTab + lo, (uint8)i, hi - lo + 1); + } + +#ifdef LZHAM_BUILD_DEBUG + uint slot, ofs; + for (uint i = 1; i < m_num_lzx_slots; i++) + { + compute_lzx_position_slot(m_lzx_position_base[i], slot, ofs); + LZHAM_ASSERT(slot == i); + + compute_lzx_position_slot(m_lzx_position_base[i] + m_lzx_position_extra_mask[i], slot, ofs); + LZHAM_ASSERT(slot == i); + } + + for (uint i = 1; i <= (m_dict_size-1); i += 512U*1024U) + { + compute_lzx_position_slot(i, slot, ofs); + LZHAM_ASSERT(i == m_lzx_position_base[slot] + ofs); + } + + compute_lzx_position_slot(m_dict_size - 1, slot, ofs); + LZHAM_ASSERT((m_dict_size - 1) == m_lzx_position_base[slot] + ofs); +#endif + } +} //namespace lzham + diff --git a/r5dev/thirdparty/lzham/lzham_match_accel.cpp b/r5dev/thirdparty/lzham/lzham_match_accel.cpp new file mode 100644 index 00000000..629e950f --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_match_accel.cpp @@ -0,0 +1,562 @@ +// File: lzham_match_accel.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_match_accel.h" +#include "include/lzham_timer.h" + +namespace lzham +{ + static inline uint32 hash2_to_12(uint c0, uint c1) + { + return c0 ^ (c1 << 4); + } + + static inline uint32 hash3_to_16(uint c0, uint c1, uint c2) + { + return (c0 | (c1 << 8)) ^ (c2 << 4); + } + + search_accelerator::search_accelerator() : + m_pLZBase(NULL), + m_pTask_pool(NULL), + m_max_helper_threads(0), + m_max_dict_size(0), + m_max_dict_size_mask(0), + m_lookahead_pos(0), + m_lookahead_size(0), + m_cur_dict_size(0), + m_fill_lookahead_pos(0), + m_fill_lookahead_size(0), + m_fill_dict_size(0), + m_max_probes(0), + m_max_matches(0), + m_all_matches(false), + m_next_match_ref(0), + m_num_completed_helper_threads(0) + { + } + + bool search_accelerator::init(CLZBase* pLZBase, task_pool* pPool, uint max_helper_threads, uint max_dict_size, uint max_matches, bool all_matches, uint max_probes) + { + LZHAM_ASSERT(pLZBase); + LZHAM_ASSERT(max_dict_size && math::is_power_of_2(max_dict_size)); + LZHAM_ASSERT(max_probes); + + m_max_probes = LZHAM_MIN(cMatchAccelMaxSupportedProbes, max_probes); + + m_pLZBase = pLZBase; + m_pTask_pool = max_helper_threads ? pPool : NULL; + m_max_helper_threads = m_pTask_pool ? max_helper_threads : 0; + m_max_matches = LZHAM_MIN(m_max_probes, max_matches); + m_all_matches = all_matches; + + m_max_dict_size = max_dict_size; + m_max_dict_size_mask = m_max_dict_size - 1; + m_cur_dict_size = 0; + m_lookahead_size = 0; + m_lookahead_pos = 0; + m_fill_lookahead_pos = 0; + m_fill_lookahead_size = 0; + m_fill_dict_size = 0; + m_num_completed_helper_threads = 0; + + if (!m_dict.try_resize_no_construct(max_dict_size + LZHAM_MIN(m_max_dict_size, static_cast(CLZBase::cMaxHugeMatchLen)))) + return false; + + if (!m_hash.try_resize_no_construct(cHashSize)) + return false; + + if (!m_nodes.try_resize_no_construct(max_dict_size)) + return false; + + memset(m_hash.get_ptr(), 0, m_hash.size_in_bytes()); + + return true; + } + + void search_accelerator::reset() + { + m_cur_dict_size = 0; + m_lookahead_size = 0; + m_lookahead_pos = 0; + m_fill_lookahead_pos = 0; + m_fill_lookahead_size = 0; + m_fill_dict_size = 0; + m_num_completed_helper_threads = 0; + + // Clearing the hash tables is only necessary for determinism (otherwise, it's possible the matches returned after a reset will depend on the data processes before the reset). + if (m_hash.size()) + memset(m_hash.get_ptr(), 0, m_hash.size_in_bytes()); + if (m_digram_hash.size()) + memset(m_digram_hash.get_ptr(), 0, m_digram_hash.size_in_bytes()); + } + + void search_accelerator::flush() + { + m_cur_dict_size = 0; + } + + uint search_accelerator::get_max_add_bytes() const + { + uint add_pos = static_cast(m_lookahead_pos & (m_max_dict_size - 1)); + return m_max_dict_size - add_pos; + } + + static uint8 g_hamming_dist[256] = + { + 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 + }; + + void search_accelerator::find_all_matches_callback(uint64 data, void* pData_ptr) + { + scoped_perf_section find_all_matches_timer("find_all_matches_callback"); + + LZHAM_NOTE_UNUSED(pData_ptr); + const uint thread_index = (uint)data; + + dict_match temp_matches[cMatchAccelMaxSupportedProbes * 2]; + + uint fill_lookahead_pos = m_fill_lookahead_pos; + uint fill_dict_size = m_fill_dict_size; + uint fill_lookahead_size = m_fill_lookahead_size; + + uint c0 = 0, c1 = 0; + if (fill_lookahead_size >= 2) + { + c0 = m_dict[fill_lookahead_pos & m_max_dict_size_mask]; + c1 = m_dict[(fill_lookahead_pos & m_max_dict_size_mask) + 1]; + } + + const uint8* pDict = m_dict.get_ptr(); + + while (fill_lookahead_size >= 3) + { + uint insert_pos = fill_lookahead_pos & m_max_dict_size_mask; + + uint c2 = pDict[insert_pos + 2]; + uint h = hash3_to_16(c0, c1, c2); + c0 = c1; + c1 = c2; + + LZHAM_ASSERT(!m_hash_thread_index.size() || (m_hash_thread_index[h] != UINT8_MAX)); + + // Only process those strings that this worker thread was assigned to - this allows us to manipulate multiple trees in parallel with no worries about synchronization. + if (m_hash_thread_index.size() && (m_hash_thread_index[h] != thread_index)) + { + fill_lookahead_pos++; + fill_lookahead_size--; + fill_dict_size++; + continue; + } + + dict_match* pDstMatch = temp_matches; + + uint cur_pos = m_hash[h]; + m_hash[h] = static_cast(fill_lookahead_pos); + + uint *pLeft = &m_nodes[insert_pos].m_left; + uint *pRight = &m_nodes[insert_pos].m_right; + + const uint max_match_len = LZHAM_MIN(static_cast(CLZBase::cMaxMatchLen), fill_lookahead_size); + uint best_match_len = 2; + + const uint8* pIns = &pDict[insert_pos]; + + uint n = m_max_probes; + for ( ; ; ) + { + uint delta_pos = fill_lookahead_pos - cur_pos; + if ((n-- == 0) || (!delta_pos) || (delta_pos >= fill_dict_size)) + { + *pLeft = 0; + *pRight = 0; + break; + } + + uint pos = cur_pos & m_max_dict_size_mask; + node *pNode = &m_nodes[pos]; + + // Unfortunately, the initial compare match_len must be 0 because of the way we hash and truncate matches at the end of each block. + uint match_len = 0; + const uint8* pComp = &pDict[pos]; + +#if LZHAM_PLATFORM_X360 + for ( ; match_len < max_match_len; match_len++) + if (pComp[match_len] != pIns[match_len]) + break; +#else + // Compare a qword at a time for a bit more efficiency. + const uint64* pComp_end = reinterpret_cast(pComp + max_match_len - 7); + const uint64* pComp_cur = reinterpret_cast(pComp); + const uint64* pIns_cur = reinterpret_cast(pIns); + while (pComp_cur < pComp_end) + { + if (*pComp_cur != *pIns_cur) + break; + pComp_cur++; + pIns_cur++; + } + uint alt_match_len = static_cast(reinterpret_cast(pComp_cur) - reinterpret_cast(pComp)); + for ( ; alt_match_len < max_match_len; alt_match_len++) + if (pComp[alt_match_len] != pIns[alt_match_len]) + break; +#ifdef LZVERIFY + for ( ; match_len < max_match_len; match_len++) + if (pComp[match_len] != pIns[match_len]) + break; + LZHAM_VERIFY(alt_match_len == match_len); +#endif + match_len = alt_match_len; +#endif + + if (match_len > best_match_len) + { + pDstMatch->m_len = static_cast(match_len - CLZBase::cMinMatchLen); + pDstMatch->m_dist = delta_pos; + pDstMatch++; + + best_match_len = match_len; + + if (match_len == max_match_len) + { + *pLeft = pNode->m_left; + *pRight = pNode->m_right; + break; + } + } + else if (m_all_matches) + { + pDstMatch->m_len = static_cast(match_len - CLZBase::cMinMatchLen); + pDstMatch->m_dist = delta_pos; + pDstMatch++; + } + else if ((best_match_len > 2) && (best_match_len == match_len)) + { + uint bestMatchDist = pDstMatch[-1].m_dist; + uint compMatchDist = delta_pos; + + uint bestMatchSlot, bestMatchSlotOfs; + m_pLZBase->compute_lzx_position_slot(bestMatchDist, bestMatchSlot, bestMatchSlotOfs); + + uint compMatchSlot, compMatchOfs; + m_pLZBase->compute_lzx_position_slot(compMatchDist, compMatchSlot, compMatchOfs); + + // If both matches uses the same match slot, choose the one with the offset containing the lowest nibble as these bits separately entropy coded. + // This could choose a match which is further away in the absolute sense, but closer in a coding sense. + if ( (compMatchSlot < bestMatchSlot) || + ((compMatchSlot >= 8) && (compMatchSlot == bestMatchSlot) && ((compMatchOfs & 15) < (bestMatchSlotOfs & 15))) ) + { + LZHAM_ASSERT((pDstMatch[-1].m_len + (uint)CLZBase::cMinMatchLen) == best_match_len); + pDstMatch[-1].m_dist = delta_pos; + } + else if ((match_len < max_match_len) && (compMatchSlot <= bestMatchSlot)) + { + // Choose the match which has lowest hamming distance in the mismatch byte for a tiny win on binary files. + // TODO: This competes against the prev. optimization. + uint desired_mismatch_byte = pIns[match_len]; + + uint cur_mismatch_byte = pDict[(insert_pos - bestMatchDist + match_len) & m_max_dict_size_mask]; + uint cur_mismatch_dist = g_hamming_dist[cur_mismatch_byte ^ desired_mismatch_byte]; + + uint new_mismatch_byte = pComp[match_len]; + uint new_mismatch_dist = g_hamming_dist[new_mismatch_byte ^ desired_mismatch_byte]; + if (new_mismatch_dist < cur_mismatch_dist) + { + LZHAM_ASSERT((pDstMatch[-1].m_len + (uint)CLZBase::cMinMatchLen) == best_match_len); + pDstMatch[-1].m_dist = delta_pos; + } + } + } + + uint new_pos; + if (pComp[match_len] < pIns[match_len]) + { + *pLeft = cur_pos; + pLeft = &pNode->m_right; + new_pos = pNode->m_right; + } + else + { + *pRight = cur_pos; + pRight = &pNode->m_left; + new_pos = pNode->m_left; + } + if (new_pos == cur_pos) + break; + cur_pos = new_pos; + } + + const uint num_matches = (uint)(pDstMatch - temp_matches); + + if (num_matches) + { + pDstMatch[-1].m_dist |= 0x80000000; + + const uint num_matches_to_write = LZHAM_MIN(num_matches, m_max_matches); + + const uint match_ref_ofs = atomic_exchange_add(&m_next_match_ref, num_matches_to_write); + + memcpy(&m_matches[match_ref_ofs], + temp_matches + (num_matches - num_matches_to_write), + sizeof(temp_matches[0]) * num_matches_to_write); + + // FIXME: This is going to really hurt on platforms requiring export barriers. + LZHAM_MEMORY_EXPORT_BARRIER + + atomic_exchange32((atomic32_t*)&m_match_refs[static_cast(fill_lookahead_pos - m_fill_lookahead_pos)], match_ref_ofs); + } + else + { + atomic_exchange32((atomic32_t*)&m_match_refs[static_cast(fill_lookahead_pos - m_fill_lookahead_pos)], -2); + } + + fill_lookahead_pos++; + fill_lookahead_size--; + fill_dict_size++; + } + + while (fill_lookahead_size) + { + uint insert_pos = fill_lookahead_pos & m_max_dict_size_mask; + m_nodes[insert_pos].m_left = 0; + m_nodes[insert_pos].m_right = 0; + + atomic_exchange32((atomic32_t*)&m_match_refs[static_cast(fill_lookahead_pos - m_fill_lookahead_pos)], -2); + + fill_lookahead_pos++; + fill_lookahead_size--; + fill_dict_size++; + } + + atomic_increment32(&m_num_completed_helper_threads); + } + + bool search_accelerator::find_len2_matches() + { + if (!m_digram_hash.size()) + { + if (!m_digram_hash.try_resize(cDigramHashSize)) + return false; + } + + if (m_digram_next.size() < m_lookahead_size) + { + if (!m_digram_next.try_resize(m_lookahead_size)) + return false; + } + + uint lookahead_dict_pos = m_lookahead_pos & m_max_dict_size_mask; + + for (int lookahead_ofs = 0; lookahead_ofs < ((int)m_lookahead_size - 1); ++lookahead_ofs, ++lookahead_dict_pos) + { + uint c0 = m_dict[lookahead_dict_pos]; + uint c1 = m_dict[lookahead_dict_pos + 1]; + + uint h = hash2_to_12(c0, c1) & (cDigramHashSize - 1); + + m_digram_next[lookahead_ofs] = m_digram_hash[h]; + m_digram_hash[h] = m_lookahead_pos + lookahead_ofs; + } + + m_digram_next[m_lookahead_size - 1] = 0; + + return true; + } + + uint search_accelerator::get_len2_match(uint lookahead_ofs) + { + if ((m_fill_lookahead_size - lookahead_ofs) < 2) + return 0; + + uint cur_pos = m_lookahead_pos + lookahead_ofs; + + uint next_match_pos = m_digram_next[cur_pos - m_fill_lookahead_pos]; + + uint match_dist = cur_pos - next_match_pos; + + if ((!match_dist) || (match_dist > CLZBase::cMaxLen2MatchDist) || (match_dist > (m_cur_dict_size + lookahead_ofs))) + return 0; + + const uint8* pCur = &m_dict[cur_pos & m_max_dict_size_mask]; + const uint8* pMatch = &m_dict[next_match_pos & m_max_dict_size_mask]; + + if ((pCur[0] == pMatch[0]) && (pCur[1] == pMatch[1])) + return match_dist; + + return 0; + } + + bool search_accelerator::find_all_matches(uint num_bytes) + { + if (!m_matches.try_resize_no_construct(m_max_probes * num_bytes)) + return false; + + if (!m_match_refs.try_resize_no_construct(num_bytes)) + return false; + + memset(m_match_refs.get_ptr(), 0xFF, m_match_refs.size_in_bytes()); + + m_fill_lookahead_pos = m_lookahead_pos; + m_fill_lookahead_size = num_bytes; + m_fill_dict_size = m_cur_dict_size; + + m_next_match_ref = 0; + + if (!m_pTask_pool) + { + find_all_matches_callback(0, NULL); + + m_num_completed_helper_threads = 0; + } + else + { + if (!m_hash_thread_index.try_resize_no_construct(0x10000)) + return false; + + memset(m_hash_thread_index.get_ptr(), 0xFF, m_hash_thread_index.size_in_bytes()); + + uint next_thread_index = 0; + const uint8* pDict = &m_dict[m_lookahead_pos & m_max_dict_size_mask]; + uint num_unique_trigrams = 0; + + if (num_bytes >= 3) + { + uint c0 = pDict[0]; + uint c1 = pDict[1]; + + const int limit = ((int)num_bytes - 2); + for (int i = 0; i < limit; i++) + { + uint c2 = pDict[2]; + uint t = hash3_to_16(c0, c1, c2); + c0 = c1; + c1 = c2; + + pDict++; + + if (m_hash_thread_index[t] == UINT8_MAX) + { + num_unique_trigrams++; + + m_hash_thread_index[t] = static_cast(next_thread_index); + if (++next_thread_index == m_max_helper_threads) + next_thread_index = 0; + } + } + } + + m_num_completed_helper_threads = 0; + + if (!m_pTask_pool->queue_multiple_object_tasks(this, &search_accelerator::find_all_matches_callback, 0, m_max_helper_threads)) + return false; + } + + return find_len2_matches(); + } + + bool search_accelerator::add_bytes_begin(uint num_bytes, const uint8* pBytes) + { + LZHAM_ASSERT(num_bytes <= m_max_dict_size); + LZHAM_ASSERT(!m_lookahead_size); + + uint add_pos = m_lookahead_pos & m_max_dict_size_mask; + LZHAM_ASSERT((add_pos + num_bytes) <= m_max_dict_size); + + memcpy(&m_dict[add_pos], pBytes, num_bytes); + + uint dict_bytes_to_mirror = LZHAM_MIN(static_cast(CLZBase::cMaxHugeMatchLen), m_max_dict_size); + if (add_pos < dict_bytes_to_mirror) + memcpy(&m_dict[m_max_dict_size], &m_dict[0], dict_bytes_to_mirror); + + m_lookahead_size = num_bytes; + + uint max_possible_dict_size = m_max_dict_size - num_bytes; + m_cur_dict_size = LZHAM_MIN(m_cur_dict_size, max_possible_dict_size); + + m_next_match_ref = 0; + + return find_all_matches(num_bytes); + } + + void search_accelerator::add_bytes_end() + { + if (m_pTask_pool) + { + m_pTask_pool->join(); + } + + LZHAM_ASSERT((uint)m_next_match_ref <= m_matches.size()); + } + + dict_match* search_accelerator::find_matches(uint lookahead_ofs, bool spin) + { + LZHAM_ASSERT(lookahead_ofs < m_lookahead_size); + + const uint match_ref_ofs = static_cast(m_lookahead_pos - m_fill_lookahead_pos + lookahead_ofs); + + int match_ref; + uint spin_count = 0; + + // This may spin until the match finder job(s) catch up to the caller's lookahead position. + for ( ; ; ) + { + match_ref = m_match_refs[match_ref_ofs]; + if (match_ref == -2) + return NULL; + else if (match_ref != -1) + break; + + spin_count++; + const uint cMaxSpinCount = 1000; + if ((spin) && (spin_count < cMaxSpinCount)) + { + lzham_yield_processor(); + lzham_yield_processor(); + lzham_yield_processor(); + lzham_yield_processor(); + lzham_yield_processor(); + lzham_yield_processor(); + lzham_yield_processor(); + lzham_yield_processor(); + + LZHAM_MEMORY_IMPORT_BARRIER + } + else + { + spin_count = cMaxSpinCount; + + lzham_sleep(1); + } + } + + LZHAM_MEMORY_IMPORT_BARRIER + + return &m_matches[match_ref]; + } + + void search_accelerator::advance_bytes(uint num_bytes) + { + LZHAM_ASSERT(num_bytes <= m_lookahead_size); + + m_lookahead_pos += num_bytes; + m_lookahead_size -= num_bytes; + + m_cur_dict_size += num_bytes; + LZHAM_ASSERT(m_cur_dict_size <= m_max_dict_size); + } +} diff --git a/r5dev/thirdparty/lzham/lzham_mem.cpp b/r5dev/thirdparty/lzham/lzham_mem.cpp new file mode 100644 index 00000000..0c961ed6 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_mem.cpp @@ -0,0 +1,272 @@ +// File: lzham_mem.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include +#include +#include + +using namespace lzham; + +#define LZHAM_MEM_STATS 0 + +#ifndef LZHAM_USE_WIN32_API + #define _msize malloc_usable_size +#endif + +namespace lzham +{ + #if LZHAM_64BIT_POINTERS + const uint64 MAX_POSSIBLE_BLOCK_SIZE = 0x400000000ULL; + #else + const uint32 MAX_POSSIBLE_BLOCK_SIZE = 0x7FFF0000U; + #endif + + #if LZHAM_MEM_STATS + #if LZHAM_64BIT_POINTERS + typedef atomic64_t mem_stat_t; + #define LZHAM_MEM_COMPARE_EXCHANGE atomic_compare_exchange64 + #else + typedef atomic32_t mem_stat_t; + #define LZHAM_MEM_COMPARE_EXCHANGE atomic_compare_exchange32 + #endif + + static volatile atomic32_t g_total_blocks; + static volatile mem_stat_t g_total_allocated; + static volatile mem_stat_t g_max_allocated; + + static mem_stat_t update_total_allocated(int block_delta, mem_stat_t byte_delta) + { + atomic32_t cur_total_blocks; + for ( ; ; ) + { + cur_total_blocks = g_total_blocks; + atomic32_t new_total_blocks = static_cast(cur_total_blocks + block_delta); + LZHAM_ASSERT(new_total_blocks >= 0); + if (atomic_compare_exchange32(&g_total_blocks, new_total_blocks, cur_total_blocks) == cur_total_blocks) + break; + } + + mem_stat_t cur_total_allocated, new_total_allocated; + for ( ; ; ) + { + cur_total_allocated = g_total_allocated; + new_total_allocated = static_cast(cur_total_allocated + byte_delta); + LZHAM_ASSERT(new_total_allocated >= 0); + if (LZHAM_MEM_COMPARE_EXCHANGE(&g_total_allocated, new_total_allocated, cur_total_allocated) == cur_total_allocated) + break; + } + for ( ; ; ) + { + mem_stat_t cur_max_allocated = g_max_allocated; + mem_stat_t new_max_allocated = LZHAM_MAX(new_total_allocated, cur_max_allocated); + if (LZHAM_MEM_COMPARE_EXCHANGE(&g_max_allocated, new_max_allocated, cur_max_allocated) == cur_max_allocated) + break; + } + return new_total_allocated; + } + #endif // LZHAM_MEM_STATS + + static void* lzham_default_realloc(void* p, size_t size, size_t* pActual_size, lzham_bool movable, void* pUser_data) + { + LZHAM_NOTE_UNUSED(pUser_data); + + void* p_new; + + if (!p) + { + p_new = malloc(size); + LZHAM_ASSERT( (reinterpret_cast(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 ); + + if (pActual_size) + *pActual_size = p_new ? _msize(p_new) : 0; + } + else if (!size) + { + free(p); + p_new = NULL; + + if (pActual_size) + *pActual_size = 0; + } + else + { + void* p_final_block = p; +#ifdef WIN32 + p_new = _expand(p, size); +#else + + p_new = NULL; +#endif + + if (p_new) + { + LZHAM_ASSERT( (reinterpret_cast(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 ); + p_final_block = p_new; + } + else if (movable) + { + p_new = realloc(p, size); + + if (p_new) + { + LZHAM_ASSERT( (reinterpret_cast(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 ); + p_final_block = p_new; + } + } + + if (pActual_size) + *pActual_size = _msize(p_final_block); + } + + return p_new; + } + + static size_t lzham_default_msize(void* p, void* pUser_data) + { + LZHAM_NOTE_UNUSED(pUser_data); + return p ? _msize(p) : 0; + } + + static lzham_realloc_func g_pRealloc = lzham_default_realloc; + static lzham_msize_func g_pMSize = lzham_default_msize; + static void* g_pUser_data; + + static inline void lzham_mem_error(const char* p_msg) + { + lzham_assert(p_msg, __FILE__, __LINE__); + } + + void* lzham_malloc(size_t size, size_t* pActual_size) + { + size = (size + sizeof(uint32) - 1U) & ~(sizeof(uint32) - 1U); + if (!size) + size = sizeof(uint32); + + if (size > MAX_POSSIBLE_BLOCK_SIZE) + { + lzham_mem_error("lzham_malloc: size too big"); + return NULL; + } + + size_t actual_size = size; + uint8* p_new = static_cast((*g_pRealloc)(NULL, size, &actual_size, true, g_pUser_data)); + + if (pActual_size) + *pActual_size = actual_size; + + if ((!p_new) || (actual_size < size)) + { + lzham_mem_error("lzham_malloc: out of memory"); + return NULL; + } + + LZHAM_ASSERT((reinterpret_cast(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0); + +#if LZHAM_MEM_STATS + update_total_allocated(1, static_cast(actual_size)); +#endif + + return p_new; + } + + void* lzham_realloc(void* p, size_t size, size_t* pActual_size, bool movable) + { + if ((ptr_bits_t)p & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) + { + lzham_mem_error("lzham_realloc: bad ptr"); + return NULL; + } + + if (size > MAX_POSSIBLE_BLOCK_SIZE) + { + lzham_mem_error("lzham_malloc: size too big"); + return NULL; + } + +#if LZHAM_MEM_STATS + size_t cur_size = p ? (*g_pMSize)(p, g_pUser_data) : 0; +#endif + + size_t actual_size = size; + void* p_new = (*g_pRealloc)(p, size, &actual_size, movable, g_pUser_data); + + if (pActual_size) + *pActual_size = actual_size; + + LZHAM_ASSERT((reinterpret_cast(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0); + +#if LZHAM_MEM_STATS + int num_new_blocks = 0; + if (p) + { + if (!p_new) + num_new_blocks = -1; + } + else if (p_new) + { + num_new_blocks = 1; + } + update_total_allocated(num_new_blocks, static_cast(actual_size) - static_cast(cur_size)); +#endif + + return p_new; + } + + void lzham_free(void* p) + { + if (!p) + return; + + if (reinterpret_cast(p) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) + { + lzham_mem_error("lzham_free: bad ptr"); + return; + } + +#if LZHAM_MEM_STATS + size_t cur_size = (*g_pMSize)(p, g_pUser_data); + update_total_allocated(-1, -static_cast(cur_size)); +#endif + + (*g_pRealloc)(p, 0, NULL, true, g_pUser_data); + } + + size_t lzham_msize(void* p) + { + if (!p) + return 0; + + if (reinterpret_cast(p) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) + { + lzham_mem_error("lzham_msize: bad ptr"); + return 0; + } + + return (*g_pMSize)(p, g_pUser_data); + } + + void LZHAM_CDECL lzham_lib_set_memory_callbacks(lzham_realloc_func pRealloc, lzham_msize_func pMSize, void* pUser_data) + { + if ((!pRealloc) || (!pMSize)) + { + g_pRealloc = lzham_default_realloc; + g_pMSize = lzham_default_msize; + g_pUser_data = NULL; + } + else + { + g_pRealloc = pRealloc; + g_pMSize = pMSize; + g_pUser_data = pUser_data; + } + } + + void lzham_print_mem_stats() + { +#if LZHAM_MEM_STATS + printf("Current blocks: %u, allocated: %I64u, max ever allocated: %I64i\n", g_total_blocks, (int64)g_total_allocated, (int64)g_max_allocated); +#endif + } + +} // namespace lzham + diff --git a/r5dev/thirdparty/lzham/lzham_platform.cpp b/r5dev/thirdparty/lzham/lzham_platform.cpp new file mode 100644 index 00000000..17a7d092 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_platform.cpp @@ -0,0 +1,146 @@ +// File: platform.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_timer.h" + +#if LZHAM_PLATFORM_X360 +#include +#endif + +#ifndef _MSC_VER +int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...) +{ + if (!sizeOfBuffer) + return 0; + + va_list args; + va_start(args, format); + int c = vsnprintf(buffer, sizeOfBuffer, format, args); + va_end(args); + + buffer[sizeOfBuffer - 1] = '\0'; + + if (c < 0) + return sizeOfBuffer - 1; + + return LZHAM_MIN(c, (int)sizeOfBuffer - 1); +} +int vsprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, va_list args) +{ + if (!sizeOfBuffer) + return 0; + + int c = vsnprintf(buffer, sizeOfBuffer, format, args); + + buffer[sizeOfBuffer - 1] = '\0'; + + if (c < 0) + return sizeOfBuffer - 1; + + return LZHAM_MIN(c, (int)sizeOfBuffer - 1); +} +#endif // __GNUC__ + +bool lzham_is_debugger_present(void) +{ +#if LZHAM_PLATFORM_X360 + return DmIsDebuggerPresent() != 0; +#elif LZHAM_USE_WIN32_API + return IsDebuggerPresent() != 0; +#else + return false; +#endif +} + +void lzham_debug_break(void) +{ +#if LZHAM_USE_WIN32_API + DebugBreak(); +#endif +} + +void lzham_output_debug_string(const char* p) +{ + LZHAM_NOTE_UNUSED(p); +#if LZHAM_USE_WIN32_API + OutputDebugStringA(p); +#endif +} + +#if LZHAM_BUFFERED_PRINTF +// This stuff was a quick hack only intended for debugging/development. +namespace lzham +{ + struct buffered_str + { + enum { cBufSize = 256 }; + char m_buf[cBufSize]; + }; + + static lzham::vector g_buffered_strings; + static volatile long g_buffered_string_locked; + + static void lock_buffered_strings() + { + while (atomic_exchange32(&g_buffered_string_locked, 1) == 1) + { + lzham_yield_processor(); + lzham_yield_processor(); + lzham_yield_processor(); + lzham_yield_processor(); + } + + LZHAM_MEMORY_IMPORT_BARRIER + } + + static void unlock_buffered_strings() + { + LZHAM_MEMORY_EXPORT_BARRIER + + atomic_exchange32(&g_buffered_string_locked, 0); + } + +} // namespace lzham + +void lzham_buffered_printf(const char *format, ...) +{ + format; + + char buf[lzham::buffered_str::cBufSize]; + + va_list args; + va_start(args, format); + vsnprintf_s(buf, sizeof(buf), sizeof(buf), format, args); + va_end(args); + + buf[sizeof(buf) - 1] = '\0'; + + lzham::lock_buffered_strings(); + + if (!lzham::g_buffered_strings.capacity()) + { + lzham::g_buffered_strings.try_reserve(2048); + } + + if (lzham::g_buffered_strings.try_resize(lzham::g_buffered_strings.size() + 1)) + { + memcpy(lzham::g_buffered_strings.back().m_buf, buf, sizeof(buf)); + } + + lzham::unlock_buffered_strings(); +} + +void lzham_flush_buffered_printf() +{ + lzham::lock_buffered_strings(); + + for (lzham::uint i = 0; i < lzham::g_buffered_strings.size(); i++) + { + printf("%s", lzham::g_buffered_strings[i].m_buf); + } + + lzham::g_buffered_strings.try_resize(0); + + lzham::unlock_buffered_strings(); +} +#endif diff --git a/r5dev/thirdparty/lzham/lzham_polar_codes.cpp b/r5dev/thirdparty/lzham/lzham_polar_codes.cpp new file mode 100644 index 00000000..55696fff --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_polar_codes.cpp @@ -0,0 +1,414 @@ +// File: polar_codes.cpp +// See Copyright Notice and license at the end of include/lzham.h +// +// Andrew Polar's prefix code algorithm: +// http://ezcodesample.com/prefixer/prefixer_article.html +// +// Also implements Fyffe's approximate codelength generation method, which is +// very similar but operates directly on codelengths vs. symbol frequencies: +// Fyffe Codes for Fast Codelength Approximation, Graham Fyffe, 1999 +// http://code.google.com/p/lzham/wiki/FyffeCodes +#include "include/lzham_core.h" +#include "include/lzham_polar_codes.h" + +#define LZHAM_USE_SHANNON_FANO_CODES 0 +#define LZHAM_USE_FYFFE_CODES 0 + +namespace lzham +{ + struct sym_freq + { + uint16 m_freq; + uint16 m_sym; + }; + + static inline sym_freq* radix_sort_syms(uint num_syms, sym_freq* syms0, sym_freq* syms1) + { + const uint cMaxPasses = 2; + uint hist[256 * cMaxPasses]; + + memset(hist, 0, sizeof(hist[0]) * 256 * cMaxPasses); + + { + sym_freq* p = syms0; + sym_freq* q = syms0 + (num_syms >> 1) * 2; + + for ( ; p != q; p += 2) + { + const uint freq0 = p[0].m_freq; + const uint freq1 = p[1].m_freq; + + hist[ freq0 & 0xFF]++; + hist[256 + ((freq0 >> 8) & 0xFF)]++; + + hist[ freq1 & 0xFF]++; + hist[256 + ((freq1 >> 8) & 0xFF)]++; + } + + if (num_syms & 1) + { + const uint freq = p->m_freq; + + hist[ freq & 0xFF]++; + hist[256 + ((freq >> 8) & 0xFF)]++; + } + } + + sym_freq* pCur_syms = syms0; + sym_freq* pNew_syms = syms1; + + const uint total_passes = (hist[256] == num_syms) ? 1 : cMaxPasses; + + for (uint pass = 0; pass < total_passes; pass++) + { + const uint* pHist = &hist[pass << 8]; + + uint offsets[256]; + + uint cur_ofs = 0; + for (uint i = 0; i < 256; i += 2) + { + offsets[i] = cur_ofs; + cur_ofs += pHist[i]; + + offsets[i+1] = cur_ofs; + cur_ofs += pHist[i+1]; + } + + const uint pass_shift = pass << 3; + + sym_freq* p = pCur_syms; + sym_freq* q = pCur_syms + (num_syms >> 1) * 2; + + for ( ; p != q; p += 2) + { + uint c0 = p[0].m_freq; + uint c1 = p[1].m_freq; + + if (pass) + { + c0 >>= 8; + c1 >>= 8; + } + + c0 &= 0xFF; + c1 &= 0xFF; + + // Cut down on LHS's on console platforms by processing two at a time. + if (c0 == c1) + { + uint dst_offset0 = offsets[c0]; + + offsets[c0] = dst_offset0 + 2; + + pNew_syms[dst_offset0] = p[0]; + pNew_syms[dst_offset0 + 1] = p[1]; + } + else + { + uint dst_offset0 = offsets[c0]++; + uint dst_offset1 = offsets[c1]++; + + pNew_syms[dst_offset0] = p[0]; + pNew_syms[dst_offset1] = p[1]; + } + } + + if (num_syms & 1) + { + uint c = ((p->m_freq) >> pass_shift) & 0xFF; + + uint dst_offset = offsets[c]; + offsets[c] = dst_offset + 1; + + pNew_syms[dst_offset] = *p; + } + + sym_freq* t = pCur_syms; + pCur_syms = pNew_syms; + pNew_syms = t; + } + +#if LZHAM_ASSERTS_ENABLED + uint prev_freq = 0; + for (uint i = 0; i < num_syms; i++) + { + LZHAM_ASSERT(!(pCur_syms[i].m_freq < prev_freq)); + prev_freq = pCur_syms[i].m_freq; + } +#endif + + return pCur_syms; + } + + struct polar_work_tables + { + sym_freq syms0[cPolarMaxSupportedSyms]; + sym_freq syms1[cPolarMaxSupportedSyms]; + }; + + uint get_generate_polar_codes_table_size() + { + return sizeof(polar_work_tables); + } + + void generate_polar_codes(uint num_syms, sym_freq* pSF, uint8* pCodesizes, uint& max_code_size_ret) + { + int tmp_freq[cPolarMaxSupportedSyms]; + + uint orig_total_freq = 0; + uint cur_total = 0; + for (uint i = 0; i < num_syms; i++) + { + uint sym_freq = pSF[num_syms - 1 - i].m_freq; + orig_total_freq += sym_freq; + + uint sym_len = math::total_bits(sym_freq); + uint adjusted_sym_freq = 1 << (sym_len - 1); + tmp_freq[i] = adjusted_sym_freq; + cur_total += adjusted_sym_freq; + } + + uint tree_total = 1 << (math::total_bits(orig_total_freq) - 1); + if (tree_total < orig_total_freq) + tree_total <<= 1; + + uint start_index = 0; + while ((cur_total < tree_total) && (start_index < num_syms)) + { + for (uint i = start_index; i < num_syms; i++) + { + uint freq = tmp_freq[i]; + if ((cur_total + freq) <= tree_total) + { + tmp_freq[i] += freq; + if ((cur_total += freq) == tree_total) + break; + } + else + { + start_index = i + 1; + } + } + } + + LZHAM_ASSERT(cur_total == tree_total); + + uint max_code_size = 0; + const uint tree_total_bits = math::total_bits(tree_total); + for (uint i = 0; i < num_syms; i++) + { + uint codesize = (tree_total_bits - math::total_bits(tmp_freq[i])); + max_code_size = LZHAM_MAX(codesize, max_code_size); + pCodesizes[pSF[num_syms-1-i].m_sym] = static_cast(codesize); + } + max_code_size_ret = max_code_size; + } + +#if LZHAM_USE_FYFFE_CODES + void generate_fyffe_codes(uint num_syms, sym_freq* pSF, uint8* pCodesizes, uint& max_code_size_ret) + { + int tmp_codesizes[cPolarMaxSupportedSyms]; + + uint cur_total = 0; + uint orig_total = 0; + for (uint i = 0; i < num_syms; i++) + { + uint sym_freq = pSF[i].m_freq; + orig_total += sym_freq; + + // Compute the nearest power of 2 lower or equal to the symbol's frequency. + // This is equivalent to codesize=ceil(-log2(sym_prob)). + uint floor_sym_freq = sym_freq; + if (!math::is_power_of_2(floor_sym_freq)) + { + uint sym_freq_bits = math::total_bits(sym_freq); + floor_sym_freq = 1 << (sym_freq_bits - 1); + } + + // Compute preliminary codesizes. tmp_freq's will always be <= the input frequencies. + tmp_codesizes[i] = math::total_bits(floor_sym_freq); + cur_total += floor_sym_freq; + } + + // Desired_total is a power of 2, and will always be >= the adjusted frequency total. + uint desired_total = cur_total; + if (!math::is_power_of_2(desired_total)) + desired_total = math::next_pow2(desired_total); + + LZHAM_ASSERT(cur_total <= desired_total); + + // Compute residual and initial symbol codesizes. + uint desired_total_bits = math::total_bits(desired_total); + int r = desired_total; + for (uint i = 0; i < num_syms; i++) + { + uint codesize = desired_total_bits - tmp_codesizes[i]; + tmp_codesizes[i] = static_cast(codesize); + r -= (desired_total >> codesize); + } + + LZHAM_ASSERT(r >= 0); + + int sym_freq_scale = (desired_total << 7) / orig_total; + + // Promote codesizes from most probable to lowest, as needed. + bool force_unhappiness = false; + while (r > 0) + { + for (int i = num_syms - 1; i >= 0; i--) + { + uint codesize = tmp_codesizes[i]; + if (codesize == 1) + continue; + + int sym_freq = pSF[i].m_freq; + int f = desired_total >> codesize; + if (f > r) + continue; + + // A code is "unhappy" when it is assigned more bits than -log2(sym_prob). + // It's too expensive to compute -log2(sym_freq/total_freq), so instead this directly compares the symbol's original + // frequency vs. the effective/adjusted frequency. sym_freq >= f is an approximation. + //bool unhappy = force_unhappiness || (sym_freq >= f); + + // Compare the symbol's original probability vs. its effective probability at its current codelength. + //bool unhappy = force_unhappiness || ((sym_freq * ((float)desired_total / orig_total)) > f); + bool unhappy = force_unhappiness || ((sym_freq * sym_freq_scale) > (f << 7)); + + if (unhappy) + { + tmp_codesizes[i]--; + + r -= f; + if (r <= 0) + break; + } + } + // Occasionally, a second pass is required to reduce the residual to 0. + // Subsequent passes ignore unhappiness. This is not discussed in Fyffe's original article. + force_unhappiness = true; + } + + LZHAM_ASSERT(!r); + + uint max_code_size = 0; + + for (uint i = 0; i < num_syms; i++) + { + uint codesize = tmp_codesizes[i]; + max_code_size = LZHAM_MAX(codesize, max_code_size); + pCodesizes[pSF[i].m_sym] = static_cast(codesize); + } + max_code_size_ret = max_code_size; + } +#endif //LZHAM_USE_FYFFE_CODES + +#if LZHAM_USE_SHANNON_FANO_CODES + // Straightforward recursive Shannon-Fano implementation, for comparison purposes. + static void generate_shannon_fano_codes_internal(uint num_syms, sym_freq* pSF, uint8* pCodesizes, int l, int h, uint total_freq) + { + LZHAM_ASSERT((h - l) >= 2); + + uint left_total = total_freq; + uint right_total = 0; + int best_diff = INT_MAX; + int best_split_index = 0; + for (int i = h - 1; i > l; i--) + { + uint freq = pSF[i].m_freq; + uint next_left_total = left_total - freq; + uint next_right_total = right_total + freq; + LZHAM_ASSERT((next_left_total + next_right_total) == total_freq); + + int diff = labs(next_left_total - next_right_total); + if (diff >= best_diff) + break; + + left_total = next_left_total; + right_total = next_right_total; + best_split_index = i; + best_diff = diff; + if (!best_diff) + break; + } + + for (int i = l; i < h; i++) + pCodesizes[i]++; + + if ((best_split_index - l) > 1) generate_shannon_fano_codes_internal(num_syms, pSF, pCodesizes, l, best_split_index, left_total); + if ((h - best_split_index) > 1) generate_shannon_fano_codes_internal(num_syms, pSF, pCodesizes, best_split_index, h, right_total); + } + + void generate_shannon_fano_codes(uint num_syms, sym_freq* pSF, uint total_freq, uint8* pCodesizes, uint& max_code_size_ret) + { + LZHAM_ASSERT(num_syms >= 2); + uint8 tmp_codesizes[cPolarMaxSupportedSyms]; + memset(tmp_codesizes, 0, num_syms); + + generate_shannon_fano_codes_internal(num_syms, pSF, tmp_codesizes, 0, num_syms, total_freq); + + uint max_code_size = 0; + for (uint i = 0; i < num_syms; i++) + { + uint codesize = tmp_codesizes[i]; + max_code_size = LZHAM_MAX(codesize, max_code_size); + pCodesizes[pSF[i].m_sym] = static_cast(codesize); + } + max_code_size_ret = max_code_size; + } +#endif // LZHAM_USE_SHANNON_FANO_CODES + + bool generate_polar_codes(void* pContext, uint num_syms, const uint16* pFreq, uint8* pCodesizes, uint& max_code_size, uint& total_freq_ret) + { + if ((!num_syms) || (num_syms > cPolarMaxSupportedSyms)) + return false; + + polar_work_tables& state = *static_cast(pContext);; + + uint max_freq = 0; + uint total_freq = 0; + + uint num_used_syms = 0; + for (uint i = 0; i < num_syms; i++) + { + uint freq = pFreq[i]; + + if (!freq) + pCodesizes[i] = 0; + else + { + total_freq += freq; + max_freq = math::maximum(max_freq, freq); + + sym_freq& sf = state.syms0[num_used_syms]; + sf.m_sym = static_cast(i); + sf.m_freq = static_cast(freq); + num_used_syms++; + } + } + + total_freq_ret = total_freq; + + if (num_used_syms == 1) + { + pCodesizes[state.syms0[0].m_sym] = 1; + } + else + { + sym_freq* syms = radix_sort_syms(num_used_syms, state.syms0, state.syms1); + +#if LZHAM_USE_SHANNON_FANO_CODES + generate_shannon_fano_codes(num_syms, syms, total_freq, pCodesizes, max_code_size); +#elif LZHAM_USE_FYFFE_CODES + generate_fyffe_codes(num_syms, syms, pCodesizes, max_code_size); +#else + generate_polar_codes(num_syms, syms, pCodesizes, max_code_size); +#endif + } + + return true; + } + +} // namespace lzham + diff --git a/r5dev/thirdparty/lzham/lzham_prefix_coding.cpp b/r5dev/thirdparty/lzham/lzham_prefix_coding.cpp new file mode 100644 index 00000000..47ef9260 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_prefix_coding.cpp @@ -0,0 +1,350 @@ +// File: lzham_prefix_coding.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_prefix_coding.h" + +#ifdef LZHAM_BUILD_DEBUG + //#define TEST_DECODER_TABLES +#endif + +namespace lzham +{ + namespace prefix_coding + { + bool limit_max_code_size(uint num_syms, uint8* pCodesizes, uint max_code_size) + { + const uint cMaxEverCodeSize = 34; + + if ((!num_syms) || (num_syms > cMaxSupportedSyms) || (max_code_size < 1) || (max_code_size > cMaxEverCodeSize)) + return false; + + uint num_codes[cMaxEverCodeSize + 1]; + utils::zero_object(num_codes); + + bool should_limit = false; + + for (uint i = 0; i < num_syms; i++) + { + uint c = pCodesizes[i]; + + LZHAM_ASSERT(c <= cMaxEverCodeSize); + + num_codes[c]++; + if (c > max_code_size) + should_limit = true; + } + + if (!should_limit) + return true; + + uint ofs = 0; + uint next_sorted_ofs[cMaxEverCodeSize + 1]; + for (uint i = 1; i <= cMaxEverCodeSize; i++) + { + next_sorted_ofs[i] = ofs; + ofs += num_codes[i]; + } + + if ((ofs < 2) || (ofs > cMaxSupportedSyms)) + return true; + + if (ofs > (1U << max_code_size)) + return false; + + for (uint i = max_code_size + 1; i <= cMaxEverCodeSize; i++) + num_codes[max_code_size] += num_codes[i]; + + // Technique of adjusting tree to enforce maximum code size from LHArc. + + uint total = 0; + for (uint i = max_code_size; i; --i) + total += (num_codes[i] << (max_code_size - i)); + + if (total == (1U << max_code_size)) + return true; + + do + { + num_codes[max_code_size]--; + + uint i; + for (i = max_code_size - 1; i; --i) + { + if (!num_codes[i]) + continue; + num_codes[i]--; + num_codes[i + 1] += 2; + break; + } + if (!i) + return false; + + total--; + } while (total != (1U << max_code_size)); + + uint8 new_codesizes[cMaxSupportedSyms]; + uint8* p = new_codesizes; + for (uint i = 1; i <= max_code_size; i++) + { + uint n = num_codes[i]; + if (n) + { + memset(p, i, n); + p += n; + } + } + + for (uint i = 0; i < num_syms; i++) + { + const uint c = pCodesizes[i]; + if (c) + { + uint next_ofs = next_sorted_ofs[c]; + next_sorted_ofs[c] = next_ofs + 1; + + pCodesizes[i] = static_cast(new_codesizes[next_ofs]); + } + } + + return true; + } + + bool generate_codes(uint num_syms, const uint8* pCodesizes, uint16* pCodes) + { + uint num_codes[cMaxExpectedCodeSize + 1]; + utils::zero_object(num_codes); + + for (uint i = 0; i < num_syms; i++) + { + uint c = pCodesizes[i]; + LZHAM_ASSERT(c <= cMaxExpectedCodeSize); + num_codes[c]++; + } + + uint code = 0; + + uint next_code[cMaxExpectedCodeSize + 1]; + next_code[0] = 0; + + for (uint i = 1; i <= cMaxExpectedCodeSize; i++) + { + next_code[i] = code; + + code = (code + num_codes[i]) << 1; + } + + if (code != (1 << (cMaxExpectedCodeSize + 1))) + { + uint t = 0; + for (uint i = 1; i <= cMaxExpectedCodeSize; i++) + { + t += num_codes[i]; + if (t > 1) + return false; + } + } + + for (uint i = 0; i < num_syms; i++) + { + uint c = pCodesizes[i]; + + LZHAM_ASSERT(!c || (next_code[c] <= UINT16_MAX)); + + pCodes[i] = static_cast(next_code[c]++); + + LZHAM_ASSERT(!c || (math::total_bits(pCodes[i]) <= pCodesizes[i])); + } + + return true; + } + + bool generate_decoder_tables(uint num_syms, const uint8* pCodesizes, decoder_tables* pTables, uint table_bits) + { + uint min_codes[cMaxExpectedCodeSize]; + + if ((!num_syms) || (table_bits > cMaxTableBits)) + return false; + + pTables->m_num_syms = num_syms; + + uint num_codes[cMaxExpectedCodeSize + 1]; + utils::zero_object(num_codes); + + for (uint i = 0; i < num_syms; i++) + { + uint c = pCodesizes[i]; + num_codes[c]++; + } + + uint sorted_positions[cMaxExpectedCodeSize + 1]; + + uint next_code = 0; + + uint total_used_syms = 0; + uint max_code_size = 0; + uint min_code_size = UINT_MAX; + for (uint i = 1; i <= cMaxExpectedCodeSize; i++) + { + const uint n = num_codes[i]; + + if (!n) + pTables->m_max_codes[i - 1] = 0;//UINT_MAX; + else + { + min_code_size = math::minimum(min_code_size, i); + max_code_size = math::maximum(max_code_size, i); + + min_codes[i - 1] = next_code; + + pTables->m_max_codes[i - 1] = next_code + n - 1; + pTables->m_max_codes[i - 1] = 1 + ((pTables->m_max_codes[i - 1] << (16 - i)) | ((1 << (16 - i)) - 1)); + + pTables->m_val_ptrs[i - 1] = total_used_syms; + + sorted_positions[i] = total_used_syms; + + next_code += n; + total_used_syms += n; + } + + next_code <<= 1; + } + + pTables->m_total_used_syms = total_used_syms; + + if (total_used_syms > pTables->m_cur_sorted_symbol_order_size) + { + pTables->m_cur_sorted_symbol_order_size = total_used_syms; + + if (!math::is_power_of_2(total_used_syms)) + pTables->m_cur_sorted_symbol_order_size = math::minimum(num_syms, math::next_pow2(total_used_syms)); + + if (pTables->m_sorted_symbol_order) + { + lzham_delete_array(pTables->m_sorted_symbol_order); + pTables->m_sorted_symbol_order = NULL; + } + + pTables->m_sorted_symbol_order = lzham_new_array(pTables->m_cur_sorted_symbol_order_size); + if (!pTables->m_sorted_symbol_order) + return false; + } + + pTables->m_min_code_size = static_cast(min_code_size); + pTables->m_max_code_size = static_cast(max_code_size); + + for (uint i = 0; i < num_syms; i++) + { + uint c = pCodesizes[i]; + if (c) + { + LZHAM_ASSERT(num_codes[c]); + + uint sorted_pos = sorted_positions[c]++; + + LZHAM_ASSERT(sorted_pos < total_used_syms); + + pTables->m_sorted_symbol_order[sorted_pos] = static_cast(i); + } + } + + if (table_bits <= pTables->m_min_code_size) + table_bits = 0; + pTables->m_table_bits = table_bits; + + if (table_bits) + { + uint table_size = 1 << table_bits; + if (table_size > pTables->m_cur_lookup_size) + { + pTables->m_cur_lookup_size = table_size; + + if (pTables->m_lookup) + { + lzham_delete_array(pTables->m_lookup); + pTables->m_lookup = NULL; + } + + pTables->m_lookup = lzham_new_array(table_size); + if (!pTables->m_lookup) + return false; + } + + memset(pTables->m_lookup, 0xFF, static_cast(sizeof(pTables->m_lookup[0])) * (1UL << table_bits)); + + for (uint codesize = 1; codesize <= table_bits; codesize++) + { + if (!num_codes[codesize]) + continue; + + const uint fillsize = table_bits - codesize; + const uint fillnum = 1 << fillsize; + + const uint min_code = min_codes[codesize - 1]; + const uint max_code = pTables->get_unshifted_max_code(codesize); + const uint val_ptr = pTables->m_val_ptrs[codesize - 1]; + + for (uint code = min_code; code <= max_code; code++) + { + const uint sym_index = pTables->m_sorted_symbol_order[ val_ptr + code - min_code ]; + LZHAM_ASSERT( pCodesizes[sym_index] == codesize ); + + for (uint j = 0; j < fillnum; j++) + { + const uint t = j + (code << fillsize); + + LZHAM_ASSERT(t < (1U << table_bits)); + + LZHAM_ASSERT(pTables->m_lookup[t] == UINT32_MAX); + + pTables->m_lookup[t] = sym_index | (codesize << 16U); + } + } + } + } + + for (uint i = 0; i < cMaxExpectedCodeSize; i++) + pTables->m_val_ptrs[i] -= min_codes[i]; + + pTables->m_table_max_code = 0; + pTables->m_decode_start_code_size = pTables->m_min_code_size; + + if (table_bits) + { + uint i; + for (i = table_bits; i >= 1; i--) + { + if (num_codes[i]) + { + pTables->m_table_max_code = pTables->m_max_codes[i - 1]; + break; + } + } + if (i >= 1) + { + pTables->m_decode_start_code_size = table_bits + 1; + for (i = table_bits + 1; i <= max_code_size; i++) + { + if (num_codes[i]) + { + pTables->m_decode_start_code_size = i; + break; + } + } + } + } + + // sentinels + pTables->m_max_codes[cMaxExpectedCodeSize] = UINT_MAX; + pTables->m_val_ptrs[cMaxExpectedCodeSize] = 0xFFFFF; + + pTables->m_table_shift = 32 - pTables->m_table_bits; + + return true; + } + + } // namespace prefix_codig + +} // namespace lzham + + diff --git a/r5dev/thirdparty/lzham/lzham_pthreads_threading.cpp b/r5dev/thirdparty/lzham/lzham_pthreads_threading.cpp new file mode 100644 index 00000000..511d740d --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_pthreads_threading.cpp @@ -0,0 +1,227 @@ +// File: lzham_task_pool_pthreads.cpp +// +// Copyright (c) 2009-2010 Richard Geldreich, Jr. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +#include "include/lzham_core.h" +#include "include/lzham_pthreads_threading.h" +#include "include/lzham_timer.h" + +#ifdef WIN32 +#include +#endif + +#if defined(__GNUC__) +#include +#endif + +#if LZHAM_USE_PTHREADS_API + +#ifdef WIN32 +#pragma comment(lib, "../ext/libpthread/lib/pthreadVC2.lib") +#endif + +namespace lzham +{ + task_pool::task_pool() : + m_num_threads(0), + m_tasks_available(0, 32767), + m_num_outstanding_tasks(0), + m_exit_flag(false) + { + utils::zero_object(m_threads); + } + + task_pool::task_pool(uint num_threads) : + m_num_threads(0), + m_tasks_available(0, 32767), + m_num_outstanding_tasks(0), + m_exit_flag(false) + { + utils::zero_object(m_threads); + + bool status = init(num_threads); + LZHAM_VERIFY(status); + } + + task_pool::~task_pool() + { + deinit(); + } + + bool task_pool::init(uint num_threads) + { + LZHAM_ASSERT(num_threads <= cMaxThreads); + num_threads = math::minimum(num_threads, cMaxThreads); + + deinit(); + + bool succeeded = true; + + m_num_threads = 0; + while (m_num_threads < num_threads) + { + int status = pthread_create(&m_threads[m_num_threads], NULL, thread_func, this); + if (status) + { + succeeded = false; + break; + } + + m_num_threads++; + } + + if (!succeeded) + { + deinit(); + return false; + } + + return true; + } + + void task_pool::deinit() + { + if (m_num_threads) + { + join(); + + atomic_exchange32(&m_exit_flag, true); + + m_tasks_available.release(m_num_threads); + + for (uint i = 0; i < m_num_threads; i++) + pthread_join(m_threads[i], NULL); + + m_num_threads = 0; + + atomic_exchange32(&m_exit_flag, false); + } + + m_task_stack.clear(); + m_num_outstanding_tasks = 0; + } + + bool task_pool::queue_task(task_callback_func pFunc, uint64 data, void* pData_ptr) + { + LZHAM_ASSERT(m_num_threads); + LZHAM_ASSERT(pFunc); + + task tsk; + tsk.m_callback = pFunc; + tsk.m_data = data; + tsk.m_pData_ptr = pData_ptr; + tsk.m_flags = 0; + + if (!m_task_stack.try_push(tsk)) + return false; + + atomic_increment32(&m_num_outstanding_tasks); + + m_tasks_available.release(1); + + return true; + } + + // It's the object's responsibility to delete pObj within the execute_task() method, if needed! + bool task_pool::queue_task(executable_task* pObj, uint64 data, void* pData_ptr) + { + LZHAM_ASSERT(m_num_threads); + LZHAM_ASSERT(pObj); + + task tsk; + tsk.m_pObj = pObj; + tsk.m_data = data; + tsk.m_pData_ptr = pData_ptr; + tsk.m_flags = cTaskFlagObject; + + if (!m_task_stack.try_push(tsk)) + return false; + + atomic_increment32(&m_num_outstanding_tasks); + + m_tasks_available.release(1); + + return true; + } + + void task_pool::process_task(task& tsk) + { + if (tsk.m_flags & cTaskFlagObject) + tsk.m_pObj->execute_task(tsk.m_data, tsk.m_pData_ptr); + else + tsk.m_callback(tsk.m_data, tsk.m_pData_ptr); + + atomic_decrement32(&m_num_outstanding_tasks); + } + + void task_pool::join() + { + task tsk; + while (atomic_add32(&m_num_outstanding_tasks, 0) > 0) + { + if (m_task_stack.pop(tsk)) + { + process_task(tsk); + } + else + { + lzham_sleep(1); + } + } + } + + void * task_pool::thread_func(void *pContext) + { + task_pool* pPool = static_cast(pContext); + task tsk; + + for ( ; ; ) + { + if (!pPool->m_tasks_available.wait()) + break; + + if (pPool->m_exit_flag) + break; + + if (pPool->m_task_stack.pop(tsk)) + { + pPool->process_task(tsk); + } + } + + return NULL; + } + + uint lzham_get_max_helper_threads() + { +#if defined(__GNUC__) + uint num_procs = get_nprocs(); + return num_procs ? (num_procs - 1) : 0; +#else + printf("TODO: lzham_get_max_helper_threads(): Implement system specific func to determine the max # of helper threads\n"); + + // Just assume a dual-core machine. + return 1; +#endif + } + +} // namespace lzham + +#endif // LZHAM_USE_PTHREADS_API diff --git a/r5dev/thirdparty/lzham/lzham_symbol_codec.cpp b/r5dev/thirdparty/lzham/lzham_symbol_codec.cpp new file mode 100644 index 00000000..9eeb6c62 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_symbol_codec.cpp @@ -0,0 +1,1453 @@ +// File: lzham_symbol_codec.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_symbol_codec.h" +#include "include/lzham_huffman_codes.h" +#include "include/lzham_polar_codes.h" + +// Set to 1 to enable ~2x more frequent Huffman table updating (at slower decompression). +#define LZHAM_MORE_FREQUENT_TABLE_UPDATING 1 + +namespace lzham +{ + // Using a fixed table to convert from scaled probability to scaled bits for determinism across compilers/run-time libs/platforms. + uint32 g_prob_cost[cSymbolCodecArithProbScale] = + { + 0x0,0xB000000,0xA000000,0x96A3FE6,0x9000000,0x8AD961F,0x86A3FE6,0x8315130,0x8000000,0x7D47FCC,0x7AD961F, + 0x78A62B0,0x76A3FE6,0x74CAFFC,0x7315130,0x717D605,0x7000000,0x6E99C09,0x6D47FCC,0x6C087D3,0x6AD961F,0x69B9116, + 0x68A62B0,0x679F7D8,0x66A3FE6,0x65B2C3E,0x64CAFFC,0x63EBFB1,0x6315130,0x6245B5C,0x617D605,0x60BB9CA,0x6000000, + 0x5F4A296,0x5E99C09,0x5DEE74F,0x5D47FCC,0x5CA6144,0x5C087D3,0x5B6EFE1,0x5AD961F,0x5A47779,0x59B9116,0x592E050, + 0x58A62B0,0x58215EA,0x579F7D8,0x5720677,0x56A3FE6,0x562A260,0x55B2C3E,0x553DBEF,0x54CAFFC,0x545A701,0x53EBFB1, + 0x537F8CF,0x5315130,0x52AC7B8,0x5245B5C,0x51E0B1B,0x517D605,0x511BB33,0x50BB9CA,0x505D0FC,0x5000000,0x4FA461A, + 0x4F4A296,0x4EF14C7,0x4E99C09,0x4E437BE,0x4DEE74F,0x4D9AA2C,0x4D47FCC,0x4CF67A8,0x4CA6144,0x4C56C23,0x4C087D3, + 0x4BBB3E1,0x4B6EFE1,0x4B23B6D,0x4AD961F,0x4A8FF97,0x4A47779,0x49FFD6A,0x49B9116,0x4973228,0x492E050,0x48E9B41, + 0x48A62B0,0x4863655,0x48215EA,0x47E012C,0x479F7D8,0x475F9B0,0x4720677,0x46E1DF1,0x46A3FE6,0x4666C1D,0x462A260, + 0x45EE27C,0x45B2C3E,0x4577F74,0x453DBEF,0x4504180,0x44CAFFC,0x4492735,0x445A701,0x4422F38,0x43EBFB1,0x43B5846, + 0x437F8CF,0x434A129,0x4315130,0x42E08C0,0x42AC7B8,0x4278DF7,0x4245B5C,0x4212FC7,0x41E0B1B,0x41AED39,0x417D605, + 0x414C561,0x411BB33,0x40EB75F,0x40BB9CA,0x408C25C,0x405D0FC,0x402E58F,0x4000000,0x3FD2036,0x3FA461A,0x3F77197, + 0x3F4A296,0x3F1D903,0x3EF14C7,0x3EC55D0,0x3E99C09,0x3E6E75F,0x3E437BE,0x3E18D14,0x3DEE74F,0x3DC465D,0x3D9AA2C, + 0x3D712AC,0x3D47FCC,0x3D1F17A,0x3CF67A8,0x3CCE246,0x3CA6144,0x3C7E492,0x3C56C23,0x3C2F7E8,0x3C087D3,0x3BE1BD5, + 0x3BBB3E1,0x3B94FE9,0x3B6EFE1,0x3B493BC,0x3B23B6D,0x3AFE6E7,0x3AD961F,0x3AB4908,0x3A8FF97,0x3A6B9C0,0x3A47779, + 0x3A238B5,0x39FFD6A,0x39DC58E,0x39B9116,0x3995FF7,0x3973228,0x395079E,0x392E050,0x390BC34,0x38E9B41,0x38C7D6E, + 0x38A62B0,0x3884B01,0x3863655,0x38424A6,0x38215EA,0x3800A1A,0x37E012C,0x37BFB18,0x379F7D8,0x377F762,0x375F9B0, + 0x373FEBA,0x3720677,0x37010E1,0x36E1DF1,0x36C2DA0,0x36A3FE6,0x36854BC,0x3666C1D,0x3648600,0x362A260,0x360C136, + 0x35EE27C,0x35D062B,0x35B2C3E,0x35954AD,0x3577F74,0x355AC8C,0x353DBEF,0x3520D98,0x3504180,0x34E77A4,0x34CAFFC, + 0x34AEA83,0x3492735,0x347660B,0x345A701,0x343EA12,0x3422F38,0x340766F,0x33EBFB1,0x33D0AFA,0x33B5846,0x339A78E, + 0x337F8CF,0x3364C05,0x334A129,0x332F839,0x3315130,0x32FAC09,0x32E08C0,0x32C6751,0x32AC7B8,0x32929F1,0x3278DF7, + 0x325F3C6,0x3245B5C,0x322C4B2,0x3212FC7,0x31F9C96,0x31E0B1B,0x31C7B53,0x31AED39,0x31960CB,0x317D605,0x3164CE2, + 0x314C561,0x3133F7D,0x311BB33,0x310387F,0x30EB75F,0x30D37CE,0x30BB9CA,0x30A3D50,0x308C25C,0x30748EC,0x305D0FC, + 0x3045A88,0x302E58F,0x301720E,0x3000000,0x2FE8F64,0x2FD2036,0x2FBB274,0x2FA461A,0x2F8DB27,0x2F77197,0x2F60968, + 0x2F4A296,0x2F33D20,0x2F1D903,0x2F0763B,0x2EF14C7,0x2EDB4A5,0x2EC55D0,0x2EAF848,0x2E99C09,0x2E84111,0x2E6E75F, + 0x2E58EEE,0x2E437BE,0x2E2E1CB,0x2E18D14,0x2E03996,0x2DEE74F,0x2DD963D,0x2DC465D,0x2DAF7AD,0x2D9AA2C,0x2D85DD7, + 0x2D712AC,0x2D5C8A9,0x2D47FCC,0x2D33812,0x2D1F17A,0x2D0AC02,0x2CF67A8,0x2CE246A,0x2CCE246,0x2CBA13A,0x2CA6144, + 0x2C92262,0x2C7E492,0x2C6A7D4,0x2C56C23,0x2C43180,0x2C2F7E8,0x2C1BF5A,0x2C087D3,0x2BF5151,0x2BE1BD5,0x2BCE75A, + 0x2BBB3E1,0x2BA8166,0x2B94FE9,0x2B81F68,0x2B6EFE1,0x2B5C153,0x2B493BC,0x2B3671A,0x2B23B6D,0x2B110B1,0x2AFE6E7, + 0x2AEBE0C,0x2AD961F,0x2AC6F1E,0x2AB4908,0x2AA23DC,0x2A8FF97,0x2A7DC39,0x2A6B9C0,0x2A5982B,0x2A47779,0x2A357A7, + 0x2A238B5,0x2A11AA1,0x29FFD6A,0x29EE10F,0x29DC58E,0x29CAAE6,0x29B9116,0x29A781C,0x2995FF7,0x29848A6,0x2973228, + 0x2961C7B,0x295079E,0x293F390,0x292E050,0x291CDDD,0x290BC34,0x28FAB56,0x28E9B41,0x28D8BF4,0x28C7D6E,0x28B6FAD, + 0x28A62B0,0x2895677,0x2884B01,0x287404B,0x2863655,0x2852D1F,0x28424A6,0x2831CEA,0x28215EA,0x2810FA5,0x2800A1A, + 0x27F0547,0x27E012C,0x27CFDC7,0x27BFB18,0x27AF91E,0x279F7D8,0x278F744,0x277F762,0x276F831,0x275F9B0,0x274FBDE, + 0x273FEBA,0x2730242,0x2720677,0x2710B57,0x27010E1,0x26F1715,0x26E1DF1,0x26D2575,0x26C2DA0,0x26B3670,0x26A3FE6, + 0x26949FF,0x26854BC,0x267601C,0x2666C1D,0x26578BE,0x2648600,0x26393E1,0x262A260,0x261B17D,0x260C136,0x25FD18C, + 0x25EE27C,0x25DF407,0x25D062B,0x25C18E8,0x25B2C3E,0x25A402A,0x25954AD,0x25869C6,0x2577F74,0x25695B6,0x255AC8C, + 0x254C3F4,0x253DBEF,0x252F47B,0x2520D98,0x2512744,0x2504180,0x24F5C4B,0x24E77A4,0x24D9389,0x24CAFFC,0x24BCCFA, + 0x24AEA83,0x24A0897,0x2492735,0x248465C,0x247660B,0x2468643,0x245A701,0x244C847,0x243EA12,0x2430C63,0x2422F38, + 0x2415292,0x240766F,0x23F9ACF,0x23EBFB1,0x23DE515,0x23D0AFA,0x23C3160,0x23B5846,0x23A7FAB,0x239A78E,0x238CFF0, + 0x237F8CF,0x237222C,0x2364C05,0x2357659,0x234A129,0x233CC74,0x232F839,0x2322478,0x2315130,0x2307E61,0x22FAC09, + 0x22EDA29,0x22E08C0,0x22D37CE,0x22C6751,0x22B974A,0x22AC7B8,0x229F89B,0x22929F1,0x2285BBA,0x2278DF7,0x226C0A6, + 0x225F3C6,0x2252758,0x2245B5C,0x2238FCF,0x222C4B2,0x221FA05,0x2212FC7,0x22065F7,0x21F9C96,0x21ED3A2,0x21E0B1B, + 0x21D4301,0x21C7B53,0x21BB410,0x21AED39,0x21A26CD,0x21960CB,0x2189B33,0x217D605,0x217113F,0x2164CE2,0x21588EE, + 0x214C561,0x214023B,0x2133F7D,0x2127D25,0x211BB33,0x210F9A6,0x210387F,0x20F77BD,0x20EB75F,0x20DF765,0x20D37CE, + 0x20C789B,0x20BB9CA,0x20AFB5C,0x20A3D50,0x2097FA6,0x208C25C,0x2080574,0x20748EC,0x2068CC4,0x205D0FC,0x2051593, + 0x2045A88,0x2039FDD,0x202E58F,0x2022BA0,0x201720E,0x200B8D8,0x2000000,0x1FF4784,0x1FE8F64,0x1FDD79F,0x1FD2036, + 0x1FC6928,0x1FBB274,0x1FAFC1A,0x1FA461A,0x1F99074,0x1F8DB27,0x1F82633,0x1F77197,0x1F6BD53,0x1F60968,0x1F555D3, + 0x1F4A296,0x1F3EFB0,0x1F33D20,0x1F28AE6,0x1F1D903,0x1F12774,0x1F0763B,0x1EFC557,0x1EF14C7,0x1EE648C,0x1EDB4A5, + 0x1ED0511,0x1EC55D0,0x1EBA6E3,0x1EAF848,0x1EA49FF,0x1E99C09,0x1E8EE64,0x1E84111,0x1E79410,0x1E6E75F,0x1E63AFE, + 0x1E58EEE,0x1E4E32E,0x1E437BE,0x1E38C9D,0x1E2E1CB,0x1E23748,0x1E18D14,0x1E0E32E,0x1E03996,0x1DF904C,0x1DEE74F, + 0x1DE3E9F,0x1DD963D,0x1DCEE27,0x1DC465D,0x1DB9EDF,0x1DAF7AD,0x1DA50C7,0x1D9AA2C,0x1D903DC,0x1D85DD7,0x1D7B81C, + 0x1D712AC,0x1D66D86,0x1D5C8A9,0x1D52416,0x1D47FCC,0x1D3DBCA,0x1D33812,0x1D294A2,0x1D1F17A,0x1D14E9B,0x1D0AC02, + 0x1D009B2,0x1CF67A8,0x1CEC5E6,0x1CE246A,0x1CD8335,0x1CCE246,0x1CC419D,0x1CBA13A,0x1CB011C,0x1CA6144,0x1C9C1B0, + 0x1C92262,0x1C88358,0x1C7E492,0x1C74611,0x1C6A7D4,0x1C609DA,0x1C56C23,0x1C4CEB0,0x1C43180,0x1C39493,0x1C2F7E8, + 0x1C25B80,0x1C1BF5A,0x1C12375,0x1C087D3,0x1BFEC71,0x1BF5151,0x1BEB673,0x1BE1BD5,0x1BD8177,0x1BCE75A,0x1BC4D7D, + 0x1BBB3E1,0x1BB1A84,0x1BA8166,0x1B9E888,0x1B94FE9,0x1B8B789,0x1B81F68,0x1B78786,0x1B6EFE1,0x1B6587B,0x1B5C153, + 0x1B52A69,0x1B493BC,0x1B3FD4D,0x1B3671A,0x1B2D125,0x1B23B6D,0x1B1A5F1,0x1B110B1,0x1B07BAE,0x1AFE6E7,0x1AF525C, + 0x1AEBE0C,0x1AE29F8,0x1AD961F,0x1AD0281,0x1AC6F1E,0x1ABDBF6,0x1AB4908,0x1AAB655,0x1AA23DC,0x1A9919C,0x1A8FF97, + 0x1A86DCB,0x1A7DC39,0x1A74AE0,0x1A6B9C0,0x1A628DA,0x1A5982B,0x1A507B6,0x1A47779,0x1A3E774,0x1A357A7,0x1A2C812, + 0x1A238B5,0x1A1A98F,0x1A11AA1,0x1A08BEA,0x19FFD6A,0x19F6F21,0x19EE10F,0x19E5333,0x19DC58E,0x19D381F,0x19CAAE6, + 0x19C1DE3,0x19B9116,0x19B047E,0x19A781C,0x199EBEF,0x1995FF7,0x198D434,0x19848A6,0x197BD4D,0x1973228,0x196A737, + 0x1961C7B,0x19591F3,0x195079E,0x1947D7D,0x193F390,0x19369D7,0x192E050,0x19256FD,0x191CDDD,0x19144EF,0x190BC34, + 0x19033AC,0x18FAB56,0x18F2333,0x18E9B41,0x18E1382,0x18D8BF4,0x18D0498,0x18C7D6E,0x18BF675,0x18B6FAD,0x18AE916, + 0x18A62B0,0x189DC7C,0x1895677,0x188D0A4,0x1884B01,0x187C58E,0x187404B,0x186BB38,0x1863655,0x185B1A2,0x1852D1F, + 0x184A8CB,0x18424A6,0x183A0B1,0x1831CEA,0x1829953,0x18215EA,0x18192B0,0x1810FA5,0x1808CC8,0x1800A1A,0x17F8799, + 0x17F0547,0x17E8322,0x17E012C,0x17D7F63,0x17CFDC7,0x17C7C59,0x17BFB18,0x17B7A05,0x17AF91E,0x17A7865,0x179F7D8, + 0x1797778,0x178F744,0x178773D,0x177F762,0x17777B4,0x176F831,0x17678DB,0x175F9B0,0x1757AB1,0x174FBDE,0x1747D36, + 0x173FEBA,0x1738068,0x1730242,0x1728447,0x1720677,0x17188D2,0x1710B57,0x1708E07,0x17010E1,0x16F93E6,0x16F1715, + 0x16E9A6E,0x16E1DF1,0x16DA19E,0x16D2575,0x16CA976,0x16C2DA0,0x16BB1F3,0x16B3670,0x16ABB16,0x16A3FE6,0x169C4DE, + 0x16949FF,0x168CF49,0x16854BC,0x167DA58,0x167601C,0x166E608,0x1666C1D,0x165F25A,0x16578BE,0x164FF4B,0x1648600, + 0x1640CDD,0x16393E1,0x1631B0D,0x162A260,0x16229DB,0x161B17D,0x1613946,0x160C136,0x160494D,0x15FD18C,0x15F59F0, + 0x15EE27C,0x15E6B2E,0x15DF407,0x15D7D06,0x15D062B,0x15C8F77,0x15C18E8,0x15BA280,0x15B2C3E,0x15AB621,0x15A402A, + 0x159CA59,0x15954AD,0x158DF27,0x15869C6,0x157F48A,0x1577F74,0x1570A82,0x15695B6,0x156210E,0x155AC8C,0x155382E, + 0x154C3F4,0x1544FDF,0x153DBEF,0x1536823,0x152F47B,0x15280F7,0x1520D98,0x1519A5C,0x1512744,0x150B450,0x1504180, + 0x14FCED4,0x14F5C4B,0x14EE9E6,0x14E77A4,0x14E0585,0x14D9389,0x14D21B1,0x14CAFFC,0x14C3E69,0x14BCCFA,0x14B5BAD, + 0x14AEA83,0x14A797C,0x14A0897,0x14997D5,0x1492735,0x148B6B7,0x148465C,0x147D622,0x147660B,0x146F616,0x1468643, + 0x1461691,0x145A701,0x1453793,0x144C847,0x144591C,0x143EA12,0x1437B2A,0x1430C63,0x1429DBD,0x1422F38,0x141C0D5, + 0x1415292,0x140E470,0x140766F,0x140088F,0x13F9ACF,0x13F2D30,0x13EBFB1,0x13E5253,0x13DE515,0x13D77F8,0x13D0AFA, + 0x13C9E1D,0x13C3160,0x13BC4C3,0x13B5846,0x13AEBE8,0x13A7FAB,0x13A138D,0x139A78E,0x1393BAF,0x138CFF0,0x1386450, + 0x137F8CF,0x1378D6E,0x137222C,0x136B709,0x1364C05,0x135E11F,0x1357659,0x1350BB2,0x134A129,0x13436C0,0x133CC74, + 0x1336248,0x132F839,0x1328E4A,0x1322478,0x131BAC5,0x1315130,0x130E7B9,0x1307E61,0x1301526,0x12FAC09,0x12F430A, + 0x12EDA29,0x12E7166,0x12E08C0,0x12DA038,0x12D37CE,0x12CCF81,0x12C6751,0x12BFF3F,0x12B974A,0x12B2F73,0x12AC7B8, + 0x12A601B,0x129F89B,0x1299137,0x12929F1,0x128C2C7,0x1285BBA,0x127F4CA,0x1278DF7,0x1272740,0x126C0A6,0x1265A28, + 0x125F3C6,0x1258D81,0x1252758,0x124C14C,0x1245B5C,0x123F587,0x1238FCF,0x1232A33,0x122C4B2,0x1225F4E,0x121FA05, + 0x12194D8,0x1212FC7,0x120CAD1,0x12065F7,0x1200139,0x11F9C96,0x11F380E,0x11ED3A2,0x11E6F51,0x11E0B1B,0x11DA700, + 0x11D4301,0x11CDF1C,0x11C7B53,0x11C17A4,0x11BB410,0x11B5097,0x11AED39,0x11A89F6,0x11A26CD,0x119C3BF,0x11960CB, + 0x118FDF2,0x1189B33,0x118388F,0x117D605,0x1177395,0x117113F,0x116AF04,0x1164CE2,0x115EADB,0x11588EE,0x115271A, + 0x114C561,0x11463C1,0x114023B,0x113A0CF,0x1133F7D,0x112DE44,0x1127D25,0x1121C1F,0x111BB33,0x1115A60,0x110F9A6, + 0x1109906,0x110387F,0x10FD811,0x10F77BD,0x10F1781,0x10EB75F,0x10E5755,0x10DF765,0x10D978D,0x10D37CE,0x10CD828, + 0x10C789B,0x10C1926,0x10BB9CA,0x10B5A87,0x10AFB5C,0x10A9C4A,0x10A3D50,0x109DE6F,0x1097FA6,0x10920F5,0x108C25C, + 0x10863DC,0x1080574,0x107A724,0x10748EC,0x106EACC,0x1068CC4,0x1062ED4,0x105D0FC,0x105733B,0x1051593,0x104B802, + 0x1045A88,0x103FD27,0x1039FDD,0x10342AA,0x102E58F,0x102888C,0x1022BA0,0x101CECB,0x101720E,0x1011567,0x100B8D8, + 0x1005C61,0x1000000,0xFFA3B6,0xFF4784,0xFEEB68,0xFE8F64,0xFE3376,0xFDD79F,0xFD7BDF,0xFD2036,0xFCC4A3, + 0xFC6928,0xFC0DC2,0xFBB274,0xFB573C,0xFAFC1A,0xFAA10F,0xFA461A,0xF9EB3C,0xF99074,0xF935C2,0xF8DB27, + 0xF880A2,0xF82633,0xF7CBDA,0xF77197,0xF7176A,0xF6BD53,0xF66353,0xF60968,0xF5AF93,0xF555D3,0xF4FC2A, + 0xF4A296,0xF44918,0xF3EFB0,0xF3965D,0xF33D20,0xF2E3F9,0xF28AE6,0xF231EA,0xF1D903,0xF18031,0xF12774, + 0xF0CECD,0xF0763B,0xF01DBF,0xEFC557,0xEF6D05,0xEF14C7,0xEEBC9F,0xEE648C,0xEE0C8E,0xEDB4A5,0xED5CD0, + 0xED0511,0xECAD66,0xEC55D0,0xEBFE4F,0xEBA6E3,0xEB4F8B,0xEAF848,0xEAA119,0xEA49FF,0xE9F2FA,0xE99C09, + 0xE9452D,0xE8EE64,0xE897B1,0xE84111,0xE7EA86,0xE79410,0xE73DAD,0xE6E75F,0xE69124,0xE63AFE,0xE5E4EC, + 0xE58EEE,0xE53904,0xE4E32E,0xE48D6C,0xE437BE,0xE3E223,0xE38C9D,0xE3372A,0xE2E1CB,0xE28C80,0xE23748, + 0xE1E224,0xE18D14,0xE13817,0xE0E32E,0xE08E58,0xE03996,0xDFE4E7,0xDF904C,0xDF3BC4,0xDEE74F,0xDE92ED, + 0xDE3E9F,0xDDEA64,0xDD963D,0xDD4228,0xDCEE27,0xDC9A38,0xDC465D,0xDBF295,0xDB9EDF,0xDB4B3D,0xDAF7AD, + 0xDAA431,0xDA50C7,0xD9FD70,0xD9AA2C,0xD956FB,0xD903DC,0xD8B0D0,0xD85DD7,0xD80AF1,0xD7B81C,0xD7655B, + 0xD712AC,0xD6C010,0xD66D86,0xD61B0E,0xD5C8A9,0xD57656,0xD52416,0xD4D1E7,0xD47FCC,0xD42DC2,0xD3DBCA, + 0xD389E5,0xD33812,0xD2E651,0xD294A2,0xD24305,0xD1F17A,0xD1A001,0xD14E9B,0xD0FD46,0xD0AC02,0xD05AD1, + 0xD009B2,0xCFB8A4,0xCF67A8,0xCF16BE,0xCEC5E6,0xCE751F,0xCE246A,0xCDD3C7,0xCD8335,0xCD32B5,0xCCE246, + 0xCC91E9,0xCC419D,0xCBF163,0xCBA13A,0xCB5122,0xCB011C,0xCAB127,0xCA6144,0xCA1171,0xC9C1B0,0xC97200, + 0xC92262,0xC8D2D4,0xC88358,0xC833ED,0xC7E492,0xC79549,0xC74611,0xC6F6EA,0xC6A7D4,0xC658CE,0xC609DA, + 0xC5BAF6,0xC56C23,0xC51D61,0xC4CEB0,0xC48010,0xC43180,0xC3E301,0xC39493,0xC34635,0xC2F7E8,0xC2A9AC, + 0xC25B80,0xC20D64,0xC1BF5A,0xC1715F,0xC12375,0xC0D59C,0xC087D3,0xC03A1A,0xBFEC71,0xBF9ED9,0xBF5151, + 0xBF03DA,0xBEB673,0xBE691B,0xBE1BD5,0xBDCE9E,0xBD8177,0xBD3461,0xBCE75A,0xBC9A64,0xBC4D7D,0xBC00A7, + 0xBBB3E1,0xBB672A,0xBB1A84,0xBACDED,0xBA8166,0xBA34EF,0xB9E888,0xB99C31,0xB94FE9,0xB903B1,0xB8B789, + 0xB86B71,0xB81F68,0xB7D36F,0xB78786,0xB73BAC,0xB6EFE1,0xB6A427,0xB6587B,0xB60CDF,0xB5C153,0xB575D6, + 0xB52A69,0xB4DF0B,0xB493BC,0xB4487D,0xB3FD4D,0xB3B22C,0xB3671A,0xB31C18,0xB2D125,0xB28641,0xB23B6D, + 0xB1F0A7,0xB1A5F1,0xB15B4A,0xB110B1,0xB0C628,0xB07BAE,0xB03143,0xAFE6E7,0xAF9C9A,0xAF525C,0xAF082C, + 0xAEBE0C,0xAE73FA,0xAE29F8,0xADE004,0xAD961F,0xAD4C49,0xAD0281,0xACB8C8,0xAC6F1E,0xAC2583,0xABDBF6, + 0xAB9278,0xAB4908,0xAAFFA7,0xAAB655,0xAA6D11,0xAA23DC,0xA9DAB5,0xA9919C,0xA94893,0xA8FF97,0xA8B6AA, + 0xA86DCB,0xA824FB,0xA7DC39,0xA79386,0xA74AE0,0xA70249,0xA6B9C0,0xA67146,0xA628DA,0xA5E07B,0xA5982B, + 0xA54FEA,0xA507B6,0xA4BF90,0xA47779,0xA42F6F,0xA3E774,0xA39F87,0xA357A7,0xA30FD6,0xA2C812,0xA2805D, + 0xA238B5,0xA1F11B,0xA1A98F,0xA16211,0xA11AA1,0xA0D33F,0xA08BEA,0xA044A4,0x9FFD6A,0x9FB63F,0x9F6F21, + 0x9F2811,0x9EE10F,0x9E9A1B,0x9E5333,0x9E0C5A,0x9DC58E,0x9D7ED0,0x9D381F,0x9CF17C,0x9CAAE6,0x9C645E, + 0x9C1DE3,0x9BD776,0x9B9116,0x9B4AC3,0x9B047E,0x9ABE46,0x9A781C,0x9A31FF,0x99EBEF,0x99A5EC,0x995FF7, + 0x991A0F,0x98D434,0x988E67,0x9848A6,0x9802F3,0x97BD4D,0x9777B4,0x973228,0x96ECA9,0x96A737,0x9661D3, + 0x961C7B,0x95D730,0x9591F3,0x954CC2,0x95079E,0x94C287,0x947D7D,0x943880,0x93F390,0x93AEAD,0x9369D7, + 0x93250D,0x92E050,0x929BA0,0x9256FD,0x921266,0x91CDDD,0x91895F,0x9144EF,0x91008B,0x90BC34,0x9077EA, + 0x9033AC,0x8FEF7B,0x8FAB56,0x8F673E,0x8F2333,0x8EDF34,0x8E9B41,0x8E575B,0x8E1382,0x8DCFB5,0x8D8BF4, + 0x8D4840,0x8D0498,0x8CC0FD,0x8C7D6E,0x8C39EB,0x8BF675,0x8BB30B,0x8B6FAD,0x8B2C5B,0x8AE916,0x8AA5DD, + 0x8A62B0,0x8A1F90,0x89DC7C,0x899973,0x895677,0x891388,0x88D0A4,0x888DCC,0x884B01,0x880841,0x87C58E, + 0x8782E6,0x87404B,0x86FDBC,0x86BB38,0x8678C1,0x863655,0x85F3F6,0x85B1A2,0x856F5B,0x852D1F,0x84EAEF, + 0x84A8CB,0x8466B3,0x8424A6,0x83E2A6,0x83A0B1,0x835EC8,0x831CEA,0x82DB19,0x829953,0x825799,0x8215EA, + 0x81D448,0x8192B0,0x815125,0x810FA5,0x80CE31,0x808CC8,0x804B6B,0x800A1A,0x7FC8D4,0x7F8799,0x7F466A, + 0x7F0547,0x7EC42F,0x7E8322,0x7E4221,0x7E012C,0x7DC041,0x7D7F63,0x7D3E8F,0x7CFDC7,0x7CBD0B,0x7C7C59, + 0x7C3BB3,0x7BFB18,0x7BBA89,0x7B7A05,0x7B398C,0x7AF91E,0x7AB8BC,0x7A7865,0x7A3819,0x79F7D8,0x79B7A2, + 0x797778,0x793759,0x78F744,0x78B73B,0x78773D,0x78374A,0x77F762,0x77B786,0x7777B4,0x7737ED,0x76F831, + 0x76B881,0x7678DB,0x763940,0x75F9B0,0x75BA2B,0x757AB1,0x753B42,0x74FBDE,0x74BC84,0x747D36,0x743DF2, + 0x73FEBA,0x73BF8C,0x738068,0x734150,0x730242,0x72C33F,0x728447,0x72455A,0x720677,0x71C79F,0x7188D2, + 0x714A0F,0x710B57,0x70CCAA,0x708E07,0x704F6F,0x7010E1,0x6FD25E,0x6F93E6,0x6F5578,0x6F1715,0x6ED8BC, + 0x6E9A6E,0x6E5C2B,0x6E1DF1,0x6DDFC3,0x6DA19E,0x6D6385,0x6D2575,0x6CE770,0x6CA976,0x6C6B86,0x6C2DA0, + 0x6BEFC4,0x6BB1F3,0x6B742D,0x6B3670,0x6AF8BE,0x6ABB16,0x6A7D79,0x6A3FE6,0x6A025D,0x69C4DE,0x69876A, + 0x6949FF,0x690C9F,0x68CF49,0x6891FE,0x6854BC,0x681785,0x67DA58,0x679D35,0x67601C,0x67230D,0x66E608, + 0x66A90D,0x666C1D,0x662F36,0x65F25A,0x65B587,0x6578BE,0x653C00,0x64FF4B,0x64C2A1,0x648600,0x644969, + 0x640CDD,0x63D05A,0x6393E1,0x635772,0x631B0D,0x62DEB2,0x62A260,0x626619,0x6229DB,0x61EDA7,0x61B17D, + 0x61755D,0x613946,0x60FD39,0x60C136,0x60853D,0x60494D,0x600D68,0x5FD18C,0x5F95B9,0x5F59F0,0x5F1E31, + 0x5EE27C,0x5EA6D0,0x5E6B2E,0x5E2F96,0x5DF407,0x5DB882,0x5D7D06,0x5D4194,0x5D062B,0x5CCACC,0x5C8F77, + 0x5C542B,0x5C18E8,0x5BDDAF,0x5BA280,0x5B675A,0x5B2C3E,0x5AF12B,0x5AB621,0x5A7B21,0x5A402A,0x5A053D, + 0x59CA59,0x598F7E,0x5954AD,0x5919E5,0x58DF27,0x58A472,0x5869C6,0x582F23,0x57F48A,0x57B9FA,0x577F74, + 0x5744F6,0x570A82,0x56D018,0x5695B6,0x565B5E,0x56210E,0x55E6C8,0x55AC8C,0x557258,0x55382E,0x54FE0C, + 0x54C3F4,0x5489E5,0x544FDF,0x5415E2,0x53DBEF,0x53A204,0x536823,0x532E4A,0x52F47B,0x52BAB5,0x5280F7, + 0x524743,0x520D98,0x51D3F5,0x519A5C,0x5160CC,0x512744,0x50EDC6,0x50B450,0x507AE4,0x504180,0x500826, + 0x4FCED4,0x4F958B,0x4F5C4B,0x4F2314,0x4EE9E6,0x4EB0C0,0x4E77A4,0x4E3E90,0x4E0585,0x4DCC83,0x4D9389, + 0x4D5A99,0x4D21B1,0x4CE8D2,0x4CAFFC,0x4C772E,0x4C3E69,0x4C05AD,0x4BCCFA,0x4B944F,0x4B5BAD,0x4B2314, + 0x4AEA83,0x4AB1FB,0x4A797C,0x4A4105,0x4A0897,0x49D031,0x4997D5,0x495F80,0x492735,0x48EEF2,0x48B6B7, + 0x487E85,0x48465C,0x480E3B,0x47D622,0x479E13,0x47660B,0x472E0C,0x46F616,0x46BE28,0x468643,0x464E66, + 0x461691,0x45DEC5,0x45A701,0x456F46,0x453793,0x44FFE9,0x44C847,0x4490AD,0x44591C,0x442193,0x43EA12, + 0x43B29A,0x437B2A,0x4343C2,0x430C63,0x42D50C,0x429DBD,0x426676,0x422F38,0x41F802,0x41C0D5,0x4189AF, + 0x415292,0x411B7D,0x40E470,0x40AD6B,0x40766F,0x403F7B,0x40088F,0x3FD1AB,0x3F9ACF,0x3F63FB,0x3F2D30, + 0x3EF66D,0x3EBFB1,0x3E88FE,0x3E5253,0x3E1BB0,0x3DE515,0x3DAE83,0x3D77F8,0x3D4175,0x3D0AFA,0x3CD488, + 0x3C9E1D,0x3C67BB,0x3C3160,0x3BFB0E,0x3BC4C3,0x3B8E80,0x3B5846,0x3B2213,0x3AEBE8,0x3AB5C5,0x3A7FAB, + 0x3A4998,0x3A138D,0x39DD89,0x39A78E,0x39719B,0x393BAF,0x3905CC,0x38CFF0,0x389A1C,0x386450,0x382E8C, + 0x37F8CF,0x37C31B,0x378D6E,0x3757C9,0x37222C,0x36EC96,0x36B709,0x368183,0x364C05,0x36168E,0x35E11F, + 0x35ABB9,0x357659,0x354102,0x350BB2,0x34D66A,0x34A129,0x346BF1,0x3436C0,0x340196,0x33CC74,0x33975A, + 0x336248,0x332D3D,0x32F839,0x32C33E,0x328E4A,0x32595D,0x322478,0x31EF9B,0x31BAC5,0x3185F7,0x315130, + 0x311C71,0x30E7B9,0x30B309,0x307E61,0x3049C0,0x301526,0x2FE094,0x2FAC09,0x2F7786,0x2F430A,0x2F0E96, + 0x2EDA29,0x2EA5C4,0x2E7166,0x2E3D0F,0x2E08C0,0x2DD479,0x2DA038,0x2D6BFF,0x2D37CE,0x2D03A4,0x2CCF81, + 0x2C9B66,0x2C6751,0x2C3345,0x2BFF3F,0x2BCB41,0x2B974A,0x2B635B,0x2B2F73,0x2AFB92,0x2AC7B8,0x2A93E6, + 0x2A601B,0x2A2C57,0x29F89B,0x29C4E5,0x299137,0x295D90,0x2929F1,0x28F658,0x28C2C7,0x288F3D,0x285BBA, + 0x28283F,0x27F4CA,0x27C15D,0x278DF7,0x275A98,0x272740,0x26F3EF,0x26C0A6,0x268D63,0x265A28,0x2626F4, + 0x25F3C6,0x25C0A0,0x258D81,0x255A69,0x252758,0x24F44F,0x24C14C,0x248E50,0x245B5C,0x24286E,0x23F587, + 0x23C2A8,0x238FCF,0x235CFD,0x232A33,0x22F76F,0x22C4B2,0x2291FD,0x225F4E,0x222CA6,0x21FA05,0x21C76B, + 0x2194D8,0x21624C,0x212FC7,0x20FD49,0x20CAD1,0x209861,0x2065F7,0x203395,0x200139,0x1FCEE4,0x1F9C96, + 0x1F6A4F,0x1F380E,0x1F05D5,0x1ED3A2,0x1EA176,0x1E6F51,0x1E3D32,0x1E0B1B,0x1DD90A,0x1DA700,0x1D74FD, + 0x1D4301,0x1D110B,0x1CDF1C,0x1CAD34,0x1C7B53,0x1C4978,0x1C17A4,0x1BE5D7,0x1BB410,0x1B8250,0x1B5097, + 0x1B1EE5,0x1AED39,0x1ABB94,0x1A89F6,0x1A585E,0x1A26CD,0x19F542,0x19C3BF,0x199241,0x1960CB,0x192F5B, + 0x18FDF2,0x18CC8F,0x189B33,0x1869DE,0x18388F,0x180746,0x17D605,0x17A4C9,0x177395,0x174267,0x17113F, + 0x16E01E,0x16AF04,0x167DF0,0x164CE2,0x161BDC,0x15EADB,0x15B9E1,0x1588EE,0x155801,0x15271A,0x14F63A, + 0x14C561,0x14948E,0x1463C1,0x1432FB,0x14023B,0x13D182,0x13A0CF,0x137023,0x133F7D,0x130EDD,0x12DE44, + 0x12ADB1,0x127D25,0x124C9F,0x121C1F,0x11EBA6,0x11BB33,0x118AC6,0x115A60,0x112A00,0x10F9A6,0x10C953, + 0x109906,0x1068BF,0x10387F,0x100845,0xFD811,0xFA7E4,0xF77BD,0xF479C,0xF1781,0xEE76D,0xEB75F, + 0xE8757,0xE5755,0xE275A,0xDF765,0xDC776,0xD978D,0xD67AA,0xD37CE,0xD07F8,0xCD828,0xCA85E, + 0xC789B,0xC48DD,0xC1926,0xBE975,0xBB9CA,0xB8A26,0xB5A87,0xB2AEF,0xAFB5C,0xACBD0,0xA9C4A, + 0xA6CCA,0xA3D50,0xA0DDC,0x9DE6F,0x9AF07,0x97FA6,0x9504A,0x920F5,0x8F1A6,0x8C25C,0x89319, + 0x863DC,0x834A5,0x80574,0x7D649,0x7A724,0x77805,0x748EC,0x719D9,0x6EACC,0x6BBC5,0x68CC4, + 0x65DC9,0x62ED4,0x5FFE5,0x5D0FC,0x5A218,0x5733B,0x54464,0x51593,0x4E6C7,0x4B802,0x48942, + 0x45A88,0x42BD5,0x3FD27,0x3CE7F,0x39FDD,0x37141,0x342AA,0x3141A,0x2E58F,0x2B70B,0x2888C, + 0x25A13,0x22BA0,0x1FD33,0x1CECB,0x1A069,0x1720E,0x143B8,0x11567,0xE71D,0xB8D8,0x8A9A, + 0x5C61,0x2E2D + }; + +#define LZHAM_CREATE_PROB_COST_TABLE 0 + +#if LZHAM_CREATE_PROB_COST_TABLE + class arith_prob_cost_initializer + { + public: + arith_prob_cost_initializer() + { + const double cInvLn2 = 1.4426950408889634073599246810019; // 1.0/ln(2) + + for (uint i = 0; i < cSymbolCodecArithProbScale; i++) + { + double flBits = i ? (-log(i * (1.0 / cSymbolCodecArithProbScale)) * cInvLn2) : 0; + g_prob_cost[i] = static_cast(floor(.5f + flBits * cBitCostScale)); + printf("0x%X,", g_prob_cost[i]); + if ((i % 11) == 10) printf("\n"); + } + printf("\n"); + } + }; + static arith_prob_cost_initializer g_prob_cost_initializer; +#endif + + raw_quasi_adaptive_huffman_data_model::raw_quasi_adaptive_huffman_data_model(bool encoding, uint total_syms, bool fast_updating, bool use_polar_codes) : + m_pDecode_tables(NULL), + m_total_syms(0), + m_max_cycle(0), + m_update_cycle(0), + m_symbols_until_update(0), + m_total_count(0), + m_decoder_table_bits(0), + m_encoding(encoding), + m_fast_updating(false), + m_use_polar_codes(false) + { + if (total_syms) + { + init(encoding, total_syms, fast_updating, use_polar_codes); + } + } + + raw_quasi_adaptive_huffman_data_model::raw_quasi_adaptive_huffman_data_model(const raw_quasi_adaptive_huffman_data_model& other) : + m_pDecode_tables(NULL), + m_total_syms(0), + m_max_cycle(0), + m_update_cycle(0), + m_symbols_until_update(0), + m_total_count(0), + m_decoder_table_bits(0), + m_encoding(false), + m_fast_updating(false), + m_use_polar_codes(false) + { + *this = other; + } + + raw_quasi_adaptive_huffman_data_model::~raw_quasi_adaptive_huffman_data_model() + { + if (m_pDecode_tables) + lzham_delete(m_pDecode_tables); + } + + bool raw_quasi_adaptive_huffman_data_model::assign(const raw_quasi_adaptive_huffman_data_model& rhs) + { + if (this == &rhs) + return true; + + m_total_syms = rhs.m_total_syms; + + m_max_cycle = rhs.m_max_cycle; + m_update_cycle = rhs.m_update_cycle; + m_symbols_until_update = rhs.m_symbols_until_update; + + m_total_count = rhs.m_total_count; + + m_sym_freq = rhs.m_sym_freq; + m_initial_sym_freq = rhs.m_initial_sym_freq; + + m_codes = rhs.m_codes; + m_code_sizes = rhs.m_code_sizes; + + if (rhs.m_pDecode_tables) + { + if (m_pDecode_tables) + { + if (!m_pDecode_tables->assign(*rhs.m_pDecode_tables)) + { + clear(); + return false; + } + } + else + { + m_pDecode_tables = lzham_new(*rhs.m_pDecode_tables); + if (!m_pDecode_tables) + { + clear(); + return false; + } + } + } + else if (m_pDecode_tables) + { + lzham_delete(m_pDecode_tables); + m_pDecode_tables = NULL; + } + + m_decoder_table_bits = rhs.m_decoder_table_bits; + m_encoding = rhs.m_encoding; + m_fast_updating = rhs.m_fast_updating; + m_use_polar_codes = rhs.m_use_polar_codes; + + return true; + } + + raw_quasi_adaptive_huffman_data_model& raw_quasi_adaptive_huffman_data_model::operator= (const raw_quasi_adaptive_huffman_data_model& rhs) + { + assign(rhs); + return *this; + } + + void raw_quasi_adaptive_huffman_data_model::clear() + { + m_sym_freq.clear(); + m_initial_sym_freq.clear(); + m_codes.clear(); + m_code_sizes.clear(); + + m_max_cycle = 0; + m_total_syms = 0; + m_update_cycle = 0; + m_symbols_until_update = 0; + m_decoder_table_bits = 0; + m_total_count = 0; + + if (m_pDecode_tables) + { + lzham_delete(m_pDecode_tables); + m_pDecode_tables = NULL; + } + + m_fast_updating = false; + m_use_polar_codes = false; + } + + bool raw_quasi_adaptive_huffman_data_model::init(bool encoding, uint total_syms, bool fast_updating, bool use_polar_codes, const uint16 *pInitial_sym_freq) + { + m_encoding = encoding; + m_fast_updating = fast_updating; + m_use_polar_codes = use_polar_codes; + m_symbols_until_update = 0; + + if (!m_sym_freq.try_resize(total_syms)) + { + clear(); + return false; + } + + if (pInitial_sym_freq) + { + if (!m_initial_sym_freq.try_resize(total_syms)) + { + clear(); + return false; + } + memcpy(m_initial_sym_freq.begin(), pInitial_sym_freq, total_syms * m_initial_sym_freq.size_in_bytes()); + } + + if (!m_code_sizes.try_resize(total_syms)) + { + clear(); + return false; + } + + m_total_syms = total_syms; + + if (m_total_syms <= 16) + m_decoder_table_bits = 0; + else + m_decoder_table_bits = static_cast(math::minimum(1 + math::ceil_log2i(m_total_syms), prefix_coding::cMaxTableBits)); + + if (m_encoding) + { + lzham_delete(m_pDecode_tables); + m_pDecode_tables = NULL; + + if (!m_codes.try_resize(total_syms)) + { + clear(); + return false; + } + } + else if (!m_pDecode_tables) + { + m_pDecode_tables = lzham_new(); + if (!m_pDecode_tables) + { + clear(); + return false; + } + } + + // TODO: Make this setting a user controllable parameter? + if (m_fast_updating) + m_max_cycle = (LZHAM_MAX(64, m_total_syms) + 6) << 5; + else + { +#if LZHAM_MORE_FREQUENT_TABLE_UPDATING + m_max_cycle = (LZHAM_MAX(24, m_total_syms) + 6) * 12; +#else + m_max_cycle = (LZHAM_MAX(32, m_total_syms) + 6) * 16; +#endif + } + + m_max_cycle = LZHAM_MIN(m_max_cycle, 32767); + + reset(); + + return true; + } + + bool raw_quasi_adaptive_huffman_data_model::reset() + { + if (!m_total_syms) + return true; + + if (m_initial_sym_freq.size()) + { + m_update_cycle = 0; + for (uint i = 0; i < m_total_syms; i++) + { + uint sym_freq = m_initial_sym_freq[i]; + m_sym_freq[i] = static_cast(sym_freq); + m_update_cycle += sym_freq; + } + } + else + { + for (uint i = 0; i < m_total_syms; i++) + m_sym_freq[i] = 1; + m_update_cycle = m_total_syms; + } + + m_total_count = 0; + m_symbols_until_update = 0; + + if (!update()) + return false; + + m_symbols_until_update = m_update_cycle = 8; + return true; + } + + void raw_quasi_adaptive_huffman_data_model::rescale() + { + uint total_freq = 0; + + for (uint i = 0; i < m_total_syms; i++) + { + uint freq = (m_sym_freq[i] + 1) >> 1; + total_freq += freq; + m_sym_freq[i] = static_cast(freq); + } + + m_total_count = total_freq; + } + + void raw_quasi_adaptive_huffman_data_model::reset_update_rate() + { + m_total_count += (m_update_cycle - m_symbols_until_update); + +#ifdef _DEBUG + uint actual_total = 0; + for (uint i = 0; i < m_sym_freq.size(); i++) + actual_total += m_sym_freq[i]; + LZHAM_ASSERT(actual_total == m_total_count); +#endif + + if (m_total_count > m_total_syms) + rescale(); + + m_symbols_until_update = m_update_cycle = LZHAM_MIN(8, m_update_cycle); + } + + bool raw_quasi_adaptive_huffman_data_model::update() + { + LZHAM_ASSERT(!m_symbols_until_update); + m_total_count += m_update_cycle; + LZHAM_ASSERT(m_total_count <= 65535); + + while (m_total_count >= 32768) + rescale(); + + uint table_size = m_use_polar_codes ? get_generate_polar_codes_table_size() : get_generate_huffman_codes_table_size(); + void *pTables = alloca(table_size); + + uint max_code_size, total_freq; + bool status; + if (m_use_polar_codes) + status = generate_polar_codes(pTables, m_total_syms, &m_sym_freq[0], &m_code_sizes[0], max_code_size, total_freq); + else + status = generate_huffman_codes(pTables, m_total_syms, &m_sym_freq[0], &m_code_sizes[0], max_code_size, total_freq); + LZHAM_ASSERT(status); + LZHAM_ASSERT(total_freq == m_total_count); + if ((!status) || (total_freq != m_total_count)) + return false; + + if (max_code_size > prefix_coding::cMaxExpectedCodeSize) + { + status = prefix_coding::limit_max_code_size(m_total_syms, &m_code_sizes[0], prefix_coding::cMaxExpectedCodeSize); + LZHAM_ASSERT(status); + if (!status) + return false; + } + + if (m_encoding) + status = prefix_coding::generate_codes(m_total_syms, &m_code_sizes[0], &m_codes[0]); + else + status = prefix_coding::generate_decoder_tables(m_total_syms, &m_code_sizes[0], m_pDecode_tables, m_decoder_table_bits); + + LZHAM_ASSERT(status); + if (!status) + return false; + + if (m_fast_updating) + m_update_cycle = 2 * m_update_cycle; + else + m_update_cycle = (5 * m_update_cycle) >> 2; + + if (m_update_cycle > m_max_cycle) + m_update_cycle = m_max_cycle; + + m_symbols_until_update = m_update_cycle; + + return true; + } + + bool raw_quasi_adaptive_huffman_data_model::update(uint sym) + { + uint freq = m_sym_freq[sym]; + freq++; + m_sym_freq[sym] = static_cast(freq); + + LZHAM_ASSERT(freq <= UINT16_MAX); + + if (--m_symbols_until_update == 0) + { + if (!update()) + return false; + } + + return true; + } + + adaptive_bit_model::adaptive_bit_model() + { + clear(); + } + + adaptive_bit_model::adaptive_bit_model(float prob0) + { + set_probability_0(prob0); + } + + adaptive_bit_model::adaptive_bit_model(const adaptive_bit_model& other) : + m_bit_0_prob(other.m_bit_0_prob) + { + } + + void adaptive_bit_model::set_probability_0(float prob0) + { + m_bit_0_prob = static_cast(math::clamp((uint)(prob0 * cSymbolCodecArithProbScale), 1, cSymbolCodecArithProbScale - 1)); + } + + adaptive_arith_data_model::adaptive_arith_data_model(bool encoding, uint total_syms) + { + init(encoding, total_syms); + } + + adaptive_arith_data_model::adaptive_arith_data_model(const adaptive_arith_data_model& other) + { + m_total_syms = other.m_total_syms; + m_probs = other.m_probs; + } + + adaptive_arith_data_model::~adaptive_arith_data_model() + { + } + + adaptive_arith_data_model& adaptive_arith_data_model::operator= (const adaptive_arith_data_model& rhs) + { + m_total_syms = rhs.m_total_syms; + m_probs = rhs.m_probs; + return *this; + } + + void adaptive_arith_data_model::clear() + { + m_total_syms = 0; + m_probs.clear(); + } + + bool adaptive_arith_data_model::init(bool encoding, uint total_syms) + { + LZHAM_NOTE_UNUSED(encoding); + if (!total_syms) + { + clear(); + return true; + } + + if ((total_syms < 2) || (!math::is_power_of_2(total_syms))) + total_syms = math::next_pow2(total_syms); + + m_total_syms = total_syms; + + if (!m_probs.try_resize(m_total_syms)) + return false; + + return true; + } + + void adaptive_arith_data_model::reset() + { + for (uint i = 0; i < m_probs.size(); i++) + m_probs[i].clear(); + } + + void adaptive_arith_data_model::reset_update_rate() + { + } + + bool adaptive_arith_data_model::update(uint sym) + { + uint node = 1; + + uint bitmask = m_total_syms; + + do + { + bitmask >>= 1; + + uint bit = (sym & bitmask) ? 1 : 0; + m_probs[node].update(bit); + node = (node << 1) + bit; + + } while (bitmask > 1); + + return true; + } + + bit_cost_t adaptive_arith_data_model::get_cost(uint sym) const + { + uint node = 1; + + uint bitmask = m_total_syms; + + bit_cost_t cost = 0; + do + { + bitmask >>= 1; + + uint bit = (sym & bitmask) ? 1 : 0; + cost += m_probs[node].get_cost(bit); + node = (node << 1) + bit; + + } while (bitmask > 1); + + return cost; + } + + symbol_codec::symbol_codec() + { + clear(); + } + + void symbol_codec::reset() + { + m_pDecode_buf = NULL; + m_pDecode_buf_next = NULL; + m_pDecode_buf_end = NULL; + m_decode_buf_size = 0; + + m_bit_buf = 0; + m_bit_count = 0; + m_total_model_updates = 0; + m_mode = cNull; + m_total_bits_written = 0; + + m_arith_base = 0; + m_arith_value = 0; + m_arith_length = 0; + m_arith_total_bits = 0; + + m_output_buf.try_resize(0); + m_arith_output_buf.try_resize(0); + m_output_syms.try_resize(0); + + m_pDecode_need_bytes_func = NULL; + m_pDecode_private_data = NULL; + m_pSaved_huff_model = NULL; + m_pSaved_model = NULL; + m_saved_node_index = 0; + } + + void symbol_codec::clear() + { + reset(); + + m_output_buf.clear(); + m_arith_output_buf.clear(); + m_output_syms.clear(); + } + + bool symbol_codec::start_encoding(uint expected_file_size) + { + m_mode = cEncoding; + + m_total_model_updates = 0; + m_total_bits_written = 0; + + if (!put_bits_init(expected_file_size)) + return false; + + m_output_syms.try_resize(0); + + arith_start_encoding(); + + return true; + } + + bool symbol_codec::encode_bits(uint bits, uint num_bits) + { + LZHAM_ASSERT(m_mode == cEncoding); + + if (!num_bits) + return true; + + LZHAM_ASSERT((num_bits == 32) || (bits <= ((1U << num_bits) - 1))); + + if (num_bits > 16) + { + if (!record_put_bits(bits >> 16, num_bits - 16)) + return false; + if (!record_put_bits(bits & 0xFFFF, 16)) + return false; + } + else + { + if (!record_put_bits(bits, num_bits)) + return false; + } + return true; + } + + bool symbol_codec::encode_arith_init() + { + LZHAM_ASSERT(m_mode == cEncoding); + + output_symbol sym; + sym.m_bits = 0; + sym.m_num_bits = output_symbol::cArithInit; + sym.m_arith_prob0 = 0; + if (!m_output_syms.try_push_back(sym)) + return false; + + return true; + } + + bool symbol_codec::encode_align_to_byte() + { + LZHAM_ASSERT(m_mode == cEncoding); + + output_symbol sym; + sym.m_bits = 0; + sym.m_num_bits = output_symbol::cAlignToByteSym; + sym.m_arith_prob0 = 0; + if (!m_output_syms.try_push_back(sym)) + return false; + + return true; + } + + bool symbol_codec::encode(uint sym, quasi_adaptive_huffman_data_model& model) + { + LZHAM_ASSERT(m_mode == cEncoding); + LZHAM_ASSERT(model.m_encoding); + + if (!record_put_bits(model.m_codes[sym], model.m_code_sizes[sym])) + return false; + + uint freq = model.m_sym_freq[sym]; + freq++; + model.m_sym_freq[sym] = static_cast(freq); + + LZHAM_ASSERT(freq <= UINT16_MAX); + + if (--model.m_symbols_until_update == 0) + { + m_total_model_updates++; + if (!model.update()) + return false; + } + return true; + } + + void symbol_codec::arith_propagate_carry() + { + int index = m_arith_output_buf.size() - 1; + while (index >= 0) + { + uint c = m_arith_output_buf[index]; + + if (c == 0xFF) + m_arith_output_buf[index] = 0; + else + { + m_arith_output_buf[index]++; + break; + } + + index--; + } + } + + bool symbol_codec::arith_renorm_enc_interval() + { + do + { + if (!m_arith_output_buf.try_push_back((m_arith_base >> 24) & 0xFF)) + return false; + m_total_bits_written += 8; + + m_arith_base <<= 8; + } while ((m_arith_length <<= 8) < cSymbolCodecArithMinLen); + return true; + } + + void symbol_codec::arith_start_encoding() + { + m_arith_output_buf.try_resize(0); + + m_arith_base = 0; + m_arith_value = 0; + m_arith_length = cSymbolCodecArithMaxLen; + m_arith_total_bits = 0; + } + + bool symbol_codec::encode(uint bit, adaptive_bit_model& model, bool update_model) + { + LZHAM_ASSERT(m_mode == cEncoding); + + m_arith_total_bits++; + + output_symbol sym; + sym.m_bits = bit; + sym.m_num_bits = -1; + sym.m_arith_prob0 = model.m_bit_0_prob; + if (!m_output_syms.try_push_back(sym)) + return false; + + uint x = model.m_bit_0_prob * (m_arith_length >> cSymbolCodecArithProbBits); + + if (!bit) + { + if (update_model) + model.m_bit_0_prob += ((cSymbolCodecArithProbScale - model.m_bit_0_prob) >> cSymbolCodecArithProbMoveBits); + + m_arith_length = x; + } + else + { + if (update_model) + model.m_bit_0_prob -= (model.m_bit_0_prob >> cSymbolCodecArithProbMoveBits); + + uint orig_base = m_arith_base; + m_arith_base += x; + m_arith_length -= x; + if (orig_base > m_arith_base) + arith_propagate_carry(); + } + + if (m_arith_length < cSymbolCodecArithMinLen) + { + if (!arith_renorm_enc_interval()) + return false; + } + + return true; + } + + bool symbol_codec::encode(uint sym, adaptive_arith_data_model& model) + { + uint node = 1; + + uint bitmask = model.m_total_syms; + + do + { + bitmask >>= 1; + + uint bit = (sym & bitmask) ? 1 : 0; + if (!encode(bit, model.m_probs[node])) + return false; + node = (node << 1) + bit; + + } while (bitmask > 1); + return true; + } + + bool symbol_codec::arith_stop_encoding() + { + uint orig_base = m_arith_base; + + if (m_arith_length > 2 * cSymbolCodecArithMinLen) + { + m_arith_base += cSymbolCodecArithMinLen; + m_arith_length = (cSymbolCodecArithMinLen >> 1); + } + else + { + m_arith_base += (cSymbolCodecArithMinLen >> 1); + m_arith_length = (cSymbolCodecArithMinLen >> 9); + } + + if (orig_base > m_arith_base) + arith_propagate_carry(); + + if (!arith_renorm_enc_interval()) + return false; + + while (m_arith_output_buf.size() < 4) + { + if (!m_arith_output_buf.try_push_back(0)) + return false; + m_total_bits_written += 8; + } + return true; + } + + bool symbol_codec::stop_encoding(bool support_arith) + { + LZHAM_ASSERT(m_mode == cEncoding); + + if (support_arith) + { + if (!arith_stop_encoding()) + return false; + } + + if (!assemble_output_buf()) + return false; + + m_mode = cNull; + return true; + } + + bool symbol_codec::record_put_bits(uint bits, uint num_bits) + { + LZHAM_ASSERT(m_mode == cEncoding); + + LZHAM_ASSERT(num_bits <= 25); + LZHAM_ASSERT(m_bit_count >= 25); + + if (!num_bits) + return true; + + m_total_bits_written += num_bits; + + output_symbol sym; + sym.m_bits = bits; + sym.m_num_bits = (uint16)num_bits; + sym.m_arith_prob0 = 0; + if (!m_output_syms.try_push_back(sym)) + return false; + + return true; + } + + bool symbol_codec::put_bits_init(uint expected_size) + { + m_bit_buf = 0; + m_bit_count = cBitBufSize; + + m_output_buf.try_resize(0); + if (!m_output_buf.try_reserve(expected_size)) + return false; + + return true; + } + + bool symbol_codec::put_bits(uint bits, uint num_bits) + { + LZHAM_ASSERT(num_bits <= 25); + LZHAM_ASSERT(m_bit_count >= 25); + + if (!num_bits) + return true; + + m_bit_count -= num_bits; + m_bit_buf |= (static_cast(bits) << m_bit_count); + + m_total_bits_written += num_bits; + + while (m_bit_count <= (cBitBufSize - 8)) + { + if (!m_output_buf.try_push_back(static_cast(m_bit_buf >> (cBitBufSize - 8)))) + return false; + + m_bit_buf <<= 8; + m_bit_count += 8; + } + + return true; + } + + bool symbol_codec::put_bits_align_to_byte() + { + uint num_bits_in = cBitBufSize - m_bit_count; + if (num_bits_in & 7) + { + if (!put_bits(0, 8 - (num_bits_in & 7))) + return false; + } + return true; + } + + bool symbol_codec::flush_bits() + { + return put_bits(0, 7); // to ensure the last bits are flushed + } + + bool symbol_codec::assemble_output_buf() + { + m_total_bits_written = 0; + + uint arith_buf_ofs = 0; + + // Intermix the final Arithmetic, Huffman, or plain bits to a single combined bitstream. + // All bits from each source must be output in exactly the same order that the decompressor will read them. + for (uint sym_index = 0; sym_index < m_output_syms.size(); sym_index++) + { + const output_symbol& sym = m_output_syms[sym_index]; + + if (sym.m_num_bits == output_symbol::cAlignToByteSym) + { + if (!put_bits_align_to_byte()) + return false; + } + else if (sym.m_num_bits == output_symbol::cArithInit) + { + LZHAM_ASSERT(m_arith_output_buf.size()); + + if (m_arith_output_buf.size()) + { + m_arith_length = cSymbolCodecArithMaxLen; + m_arith_value = 0; + for (uint i = 0; i < 4; i++) + { + const uint c = m_arith_output_buf[arith_buf_ofs++]; + m_arith_value = (m_arith_value << 8) | c; + if (!put_bits(c, 8)) + return false; + } + } + } + else if (sym.m_num_bits == output_symbol::cArithSym) + { + // This renorm logic must match the logic used in the arithmetic decoder. + if (m_arith_length < cSymbolCodecArithMinLen) + { + do + { + const uint c = (arith_buf_ofs < m_arith_output_buf.size()) ? m_arith_output_buf[arith_buf_ofs++] : 0; + if (!put_bits(c, 8)) + return false; + m_arith_value = (m_arith_value << 8) | c; + } while ((m_arith_length <<= 8) < cSymbolCodecArithMinLen); + } + + uint x = sym.m_arith_prob0 * (m_arith_length >> cSymbolCodecArithProbBits); + uint bit = (m_arith_value >= x); + + if (bit == 0) + { + m_arith_length = x; + } + else + { + m_arith_value -= x; + m_arith_length -= x; + } + + LZHAM_VERIFY(bit == sym.m_bits); + } + else + { + // Huffman or plain bits + if (!put_bits(sym.m_bits, sym.m_num_bits)) + return false; + } + } + + return flush_bits(); + } + + //------------------------------------------------------------------------------------------------------------------ + // Decoding + //------------------------------------------------------------------------------------------------------------------ + + bool symbol_codec::start_decoding(const uint8* pBuf, size_t buf_size, bool eof_flag, need_bytes_func_ptr pNeed_bytes_func, void *pPrivate_data) + { + if (!buf_size) + return false; + + m_total_model_updates = 0; + + m_pDecode_buf = pBuf; + m_pDecode_buf_next = pBuf; + m_decode_buf_size = buf_size; + m_pDecode_buf_end = pBuf + buf_size; + + m_pDecode_need_bytes_func = pNeed_bytes_func; + m_pDecode_private_data = pPrivate_data; + m_decode_buf_eof = eof_flag; + + m_bit_buf = 0; + m_bit_count = 0; + + m_mode = cDecoding; + + return true; + } + + uint symbol_codec::decode_bits(uint num_bits) + { + LZHAM_ASSERT(m_mode == cDecoding); + + if (!num_bits) + return 0; + + if (num_bits > 16) + { + uint a = get_bits(num_bits - 16); + uint b = get_bits(16); + + return (a << 16) | b; + } + else + return get_bits(num_bits); + } + + void symbol_codec::decode_remove_bits(uint num_bits) + { + LZHAM_ASSERT(m_mode == cDecoding); + + while (num_bits > 16) + { + remove_bits(16); + num_bits -= 16; + } + + remove_bits(num_bits); + } + + uint symbol_codec::decode_peek_bits(uint num_bits) + { + LZHAM_ASSERT(m_mode == cDecoding); + LZHAM_ASSERT(num_bits <= 25); + + if (!num_bits) + return 0; + + while (m_bit_count < (int)num_bits) + { + uint c = 0; + if (m_pDecode_buf_next == m_pDecode_buf_end) + { + if (!m_decode_buf_eof) + { + m_pDecode_need_bytes_func(m_pDecode_buf_next - m_pDecode_buf, m_pDecode_private_data, m_pDecode_buf, m_decode_buf_size, m_decode_buf_eof); + m_pDecode_buf_end = m_pDecode_buf + m_decode_buf_size; + m_pDecode_buf_next = m_pDecode_buf; + if (m_pDecode_buf_next < m_pDecode_buf_end) c = *m_pDecode_buf_next++; + } + } + else + c = *m_pDecode_buf_next++; + + m_bit_count += 8; + LZHAM_ASSERT(m_bit_count <= cBitBufSize); + + m_bit_buf |= (static_cast(c) << (cBitBufSize - m_bit_count)); + } + + return static_cast(m_bit_buf >> (cBitBufSize - num_bits)); + } + + uint symbol_codec::decode(quasi_adaptive_huffman_data_model& model) + { + LZHAM_ASSERT(m_mode == cDecoding); + LZHAM_ASSERT(!model.m_encoding); + + const prefix_coding::decoder_tables* pTables = model.m_pDecode_tables; + + while (m_bit_count < (cBitBufSize - 8)) + { + uint c = 0; + if (m_pDecode_buf_next == m_pDecode_buf_end) + { + if (!m_decode_buf_eof) + { + m_pDecode_need_bytes_func(m_pDecode_buf_next - m_pDecode_buf, m_pDecode_private_data, m_pDecode_buf, m_decode_buf_size, m_decode_buf_eof); + m_pDecode_buf_end = m_pDecode_buf + m_decode_buf_size; + m_pDecode_buf_next = m_pDecode_buf; + if (m_pDecode_buf_next < m_pDecode_buf_end) c = *m_pDecode_buf_next++; + } + } + else + c = *m_pDecode_buf_next++; + + m_bit_count += 8; + m_bit_buf |= (static_cast(c) << (cBitBufSize - m_bit_count)); + } + + uint k = static_cast((m_bit_buf >> (cBitBufSize - 16)) + 1); + uint sym, len; + + if (k <= pTables->m_table_max_code) + { + uint32 t = pTables->m_lookup[m_bit_buf >> (cBitBufSize - pTables->m_table_bits)]; + + LZHAM_ASSERT(t != UINT32_MAX); + sym = t & UINT16_MAX; + len = t >> 16; + + LZHAM_ASSERT(model.m_code_sizes[sym] == len); + } + else + { + len = pTables->m_decode_start_code_size; + + for ( ; ; ) + { + if (k <= pTables->m_max_codes[len - 1]) + break; + len++; + } + + int val_ptr = pTables->m_val_ptrs[len - 1] + static_cast((m_bit_buf >> (cBitBufSize - len))); + + if (((uint)val_ptr >= model.m_total_syms)) + { + // corrupted stream, or a bug + LZHAM_ASSERT(0); + return 0; + } + + sym = pTables->m_sorted_symbol_order[val_ptr]; + } + + m_bit_buf <<= len; + m_bit_count -= len; + + uint freq = model.m_sym_freq[sym]; + freq++; + model.m_sym_freq[sym] = static_cast(freq); + + LZHAM_ASSERT(freq <= UINT16_MAX); + + if (--model.m_symbols_until_update == 0) + { + m_total_model_updates++; + model.update(); + } + + return sym; + } + + uint64 symbol_codec::stop_decoding() + { + LZHAM_ASSERT(m_mode == cDecoding); + + uint64 n = m_pDecode_buf_next - m_pDecode_buf; + + m_mode = cNull; + + return n; + } + + uint symbol_codec::get_bits(uint num_bits) + { + LZHAM_ASSERT(num_bits <= 25); + + if (!num_bits) + return 0; + + while (m_bit_count < (int)num_bits) + { + uint c = 0; + if (m_pDecode_buf_next == m_pDecode_buf_end) + { + if (!m_decode_buf_eof) + { + m_pDecode_need_bytes_func(m_pDecode_buf_next - m_pDecode_buf, m_pDecode_private_data, m_pDecode_buf, m_decode_buf_size, m_decode_buf_eof); + m_pDecode_buf_end = m_pDecode_buf + m_decode_buf_size; + m_pDecode_buf_next = m_pDecode_buf; + if (m_pDecode_buf_next < m_pDecode_buf_end) c = *m_pDecode_buf_next++; + } + } + else + c = *m_pDecode_buf_next++; + + m_bit_count += 8; + LZHAM_ASSERT(m_bit_count <= cBitBufSize); + + m_bit_buf |= (static_cast(c) << (cBitBufSize - m_bit_count)); + } + + uint result = static_cast(m_bit_buf >> (cBitBufSize - num_bits)); + + m_bit_buf <<= num_bits; + m_bit_count -= num_bits; + + return result; + } + + void symbol_codec::remove_bits(uint num_bits) + { + LZHAM_ASSERT(num_bits <= 25); + + if (!num_bits) + return; + + while (m_bit_count < (int)num_bits) + { + uint c = 0; + if (m_pDecode_buf_next == m_pDecode_buf_end) + { + if (!m_decode_buf_eof) + { + m_pDecode_need_bytes_func(m_pDecode_buf_next - m_pDecode_buf, m_pDecode_private_data, m_pDecode_buf, m_decode_buf_size, m_decode_buf_eof); + m_pDecode_buf_end = m_pDecode_buf + m_decode_buf_size; + m_pDecode_buf_next = m_pDecode_buf; + if (m_pDecode_buf_next < m_pDecode_buf_end) c = *m_pDecode_buf_next++; + } + } + else + c = *m_pDecode_buf_next++; + + m_bit_count += 8; + LZHAM_ASSERT(m_bit_count <= cBitBufSize); + + m_bit_buf |= (static_cast(c) << (cBitBufSize - m_bit_count)); + } + + m_bit_buf <<= num_bits; + m_bit_count -= num_bits; + } + + void symbol_codec::decode_align_to_byte() + { + LZHAM_ASSERT(m_mode == cDecoding); + + if (m_bit_count & 7) + { + remove_bits(m_bit_count & 7); + } + } + + int symbol_codec::decode_remove_byte_from_bit_buf() + { + if (m_bit_count < 8) + return -1; + int result = static_cast(m_bit_buf >> (cBitBufSize - 8)); + m_bit_buf <<= 8; + m_bit_count -= 8; + return result; + } + + uint symbol_codec::decode(adaptive_bit_model& model, bool update_model) + { + while (m_arith_length < cSymbolCodecArithMinLen) + { + uint c = get_bits(8); + m_arith_value = (m_arith_value << 8) | c; + m_arith_length <<= 8; + } + + uint x = model.m_bit_0_prob * (m_arith_length >> cSymbolCodecArithProbBits); + uint bit = (m_arith_value >= x); + + if (!bit) + { + if (update_model) + model.m_bit_0_prob += ((cSymbolCodecArithProbScale - model.m_bit_0_prob) >> cSymbolCodecArithProbMoveBits); + + m_arith_length = x; + } + else + { + if (update_model) + model.m_bit_0_prob -= (model.m_bit_0_prob >> cSymbolCodecArithProbMoveBits); + m_arith_value -= x; + m_arith_length -= x; + } + + return bit; + } + + uint symbol_codec::decode(adaptive_arith_data_model& model) + { + uint node = 1; + + do + { + uint bit = decode(model.m_probs[node]); + + node = (node << 1) + bit; + + } while (node < model.m_total_syms); + + return node - model.m_total_syms; + } + + void symbol_codec::start_arith_decoding() + { + LZHAM_ASSERT(m_mode == cDecoding); + + m_arith_length = cSymbolCodecArithMaxLen; + m_arith_value = 0; + + m_arith_value = (get_bits(8) << 24); + m_arith_value |= (get_bits(8) << 16); + m_arith_value |= (get_bits(8) << 8); + m_arith_value |= get_bits(8); + } + + void symbol_codec::decode_need_bytes() + { + if (!m_decode_buf_eof) + { + m_pDecode_need_bytes_func(m_pDecode_buf_next - m_pDecode_buf, m_pDecode_private_data, m_pDecode_buf, m_decode_buf_size, m_decode_buf_eof); + m_pDecode_buf_end = m_pDecode_buf + m_decode_buf_size; + m_pDecode_buf_next = m_pDecode_buf; + } + } + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/lzham_timer.cpp b/r5dev/thirdparty/lzham/lzham_timer.cpp new file mode 100644 index 00000000..8d31e53b --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_timer.cpp @@ -0,0 +1,147 @@ +// File: lzham_timer.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_timer.h" + +#ifndef LZHAM_USE_WIN32_API + #include +#endif + +namespace lzham +{ + unsigned long long lzham_timer::g_init_ticks; + unsigned long long lzham_timer::g_freq; + double lzham_timer::g_inv_freq; + + #if LZHAM_USE_WIN32_API + inline void query_counter(timer_ticks *pTicks) + { + QueryPerformanceCounter(reinterpret_cast(pTicks)); + } + inline void query_counter_frequency(timer_ticks *pTicks) + { + QueryPerformanceFrequency(reinterpret_cast(pTicks)); + } + #else + inline void query_counter(timer_ticks *pTicks) + { + *pTicks = clock(); + } + inline void query_counter_frequency(timer_ticks *pTicks) + { + *pTicks = CLOCKS_PER_SEC; + } + #endif + + lzham_timer::lzham_timer() : + m_start_time(0), + m_stop_time(0), + m_started(false), + m_stopped(false) + { + if (!g_inv_freq) + init(); + } + + lzham_timer::lzham_timer(timer_ticks start_ticks) + { + if (!g_inv_freq) + init(); + + m_start_time = start_ticks; + + m_started = true; + m_stopped = false; + } + + void lzham_timer::start(timer_ticks start_ticks) + { + m_start_time = start_ticks; + + m_started = true; + m_stopped = false; + } + + void lzham_timer::start() + { + query_counter(&m_start_time); + + m_started = true; + m_stopped = false; + } + + void lzham_timer::stop() + { + LZHAM_ASSERT(m_started); + + query_counter(&m_stop_time); + + m_stopped = true; + } + + double lzham_timer::get_elapsed_secs() const + { + LZHAM_ASSERT(m_started); + if (!m_started) + return 0; + + timer_ticks stop_time = m_stop_time; + if (!m_stopped) + query_counter(&stop_time); + + timer_ticks delta = stop_time - m_start_time; + return delta * g_inv_freq; + } + + timer_ticks lzham_timer::get_elapsed_us() const + { + LZHAM_ASSERT(m_started); + if (!m_started) + return 0; + + timer_ticks stop_time = m_stop_time; + if (!m_stopped) + query_counter(&stop_time); + + timer_ticks delta = stop_time - m_start_time; + return (delta * 1000000ULL + (g_freq >> 1U)) / g_freq; + } + + void lzham_timer::init() + { + if (!g_inv_freq) + { + query_counter_frequency(&g_freq); + g_inv_freq = 1.0f / g_freq; + + query_counter(&g_init_ticks); + } + } + + timer_ticks lzham_timer::get_init_ticks() + { + if (!g_inv_freq) + init(); + + return g_init_ticks; + } + + timer_ticks lzham_timer::get_ticks() + { + if (!g_inv_freq) + init(); + + timer_ticks ticks; + query_counter(&ticks); + return ticks - g_init_ticks; + } + + double lzham_timer::ticks_to_secs(timer_ticks ticks) + { + if (!g_inv_freq) + init(); + + return ticks * g_inv_freq; + } + +} // namespace lzham \ No newline at end of file diff --git a/r5dev/thirdparty/lzham/lzham_vector.cpp b/r5dev/thirdparty/lzham/lzham_vector.cpp new file mode 100644 index 00000000..ca3f449d --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_vector.cpp @@ -0,0 +1,74 @@ +// File: lzham_vector.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_vector.h" + +namespace lzham +{ + bool elemental_vector::increase_capacity(uint min_new_capacity, bool grow_hint, uint element_size, object_mover pMover, bool nofail) + { + LZHAM_ASSERT(m_size <= m_capacity); + +#if LZHAM_64BIT_POINTERS + LZHAM_ASSUME(sizeof(void*) == sizeof(uint64)); + LZHAM_ASSERT(min_new_capacity < (0x400000000ULL / element_size)); +#else + LZHAM_ASSUME(sizeof(void*) == sizeof(uint32)); + LZHAM_ASSERT(min_new_capacity < (0x7FFF0000U / element_size)); +#endif + + if (m_capacity >= min_new_capacity) + return true; + + size_t new_capacity = min_new_capacity; + if ((grow_hint) && (!math::is_power_of_2(static_cast(new_capacity)))) + new_capacity = math::next_pow2(static_cast(new_capacity)); + + LZHAM_ASSERT(new_capacity && (new_capacity > m_capacity)); + + const size_t desired_size = element_size * new_capacity; + size_t actual_size; + if (!pMover) + { + void* new_p = lzham_realloc(m_p, desired_size, &actual_size, true); + if (!new_p) + { + if (nofail) + return false; + + char buf[256]; + sprintf_s(buf, sizeof(buf), "vector: lzham_realloc() failed allocating %u bytes", desired_size); + LZHAM_FAIL(buf); + } + m_p = new_p; + } + else + { + void* new_p = lzham_malloc(desired_size, &actual_size); + if (!new_p) + { + if (nofail) + return false; + + char buf[256]; + sprintf_s(buf, sizeof(buf), "vector: lzham_malloc() failed allocating %u bytes", desired_size); + LZHAM_FAIL(buf); + } + + (*pMover)(new_p, m_p, m_size); + + if (m_p) + lzham_free(m_p); + + m_p = new_p; + } + + if (actual_size > desired_size) + m_capacity = static_cast(actual_size / element_size); + else + m_capacity = static_cast(new_capacity); + + return true; + } + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/lzham_win32_threading.cpp b/r5dev/thirdparty/lzham/lzham_win32_threading.cpp new file mode 100644 index 00000000..23b3a273 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzham_win32_threading.cpp @@ -0,0 +1,220 @@ +// File: lzham_task_pool_win32.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "include/lzham_core.h" +#include "include/lzham_win32_threading.h" +#include "include/lzham_timer.h" +#include + +#if LZHAM_USE_WIN32_API + +namespace lzham +{ + task_pool::task_pool() : + m_num_threads(0), + m_tasks_available(0, 32767), + m_num_outstanding_tasks(0), + m_exit_flag(false) + { + utils::zero_object(m_threads); + } + + task_pool::task_pool(uint num_threads) : + m_num_threads(0), + m_tasks_available(0, 32767), + m_num_outstanding_tasks(0), + m_exit_flag(false) + { + utils::zero_object(m_threads); + + bool status = init(num_threads); + LZHAM_VERIFY(status); + } + + task_pool::~task_pool() + { + deinit(); + } + + bool task_pool::init(uint num_threads) + { + LZHAM_ASSERT(num_threads <= cMaxThreads); + num_threads = math::minimum(num_threads, cMaxThreads); + + deinit(); + + bool succeeded = true; + + m_num_threads = 0; + while (m_num_threads < num_threads) + { + m_threads[m_num_threads] = (HANDLE)_beginthreadex(NULL, 32768, thread_func, this, 0, NULL); + LZHAM_ASSERT(m_threads[m_num_threads] != 0); + + if (!m_threads[m_num_threads]) + { + succeeded = false; + break; + } + + m_num_threads++; + } + + if (!succeeded) + { + deinit(); + return false; + } + + return true; + } + + void task_pool::deinit() + { + if (m_num_threads) + { + join(); + + atomic_exchange32(&m_exit_flag, true); + + m_tasks_available.release(m_num_threads); + + for (uint i = 0; i < m_num_threads; i++) + { + if (m_threads[i]) + { + for ( ; ; ) + { + DWORD result = WaitForSingleObject(m_threads[i], 30000); + if ((result == WAIT_OBJECT_0) || (result == WAIT_ABANDONED)) + break; + } + + CloseHandle(m_threads[i]); + m_threads[i] = NULL; + } + } + + m_num_threads = 0; + + atomic_exchange32(&m_exit_flag, false); + } + + m_task_stack.clear(); + m_num_outstanding_tasks = 0; + } + + bool task_pool::queue_task(task_callback_func pFunc, uint64 data, void* pData_ptr) + { + LZHAM_ASSERT(m_num_threads); + LZHAM_ASSERT(pFunc); + + task tsk; + tsk.m_callback = pFunc; + tsk.m_data = data; + tsk.m_pData_ptr = pData_ptr; + tsk.m_flags = 0; + + if (!m_task_stack.try_push(tsk)) + return false; + + atomic_increment32(&m_num_outstanding_tasks); + + m_tasks_available.release(1); + + return true; + } + + // It's the object's responsibility to delete pObj within the execute_task() method, if needed! + bool task_pool::queue_task(executable_task* pObj, uint64 data, void* pData_ptr) + { + LZHAM_ASSERT(m_num_threads); + LZHAM_ASSERT(pObj); + + task tsk; + tsk.m_pObj = pObj; + tsk.m_data = data; + tsk.m_pData_ptr = pData_ptr; + tsk.m_flags = cTaskFlagObject; + + if (!m_task_stack.try_push(tsk)) + return false; + + atomic_increment32(&m_num_outstanding_tasks); + + m_tasks_available.release(1); + + return true; + } + + void task_pool::process_task(task& tsk) + { + if (tsk.m_flags & cTaskFlagObject) + tsk.m_pObj->execute_task(tsk.m_data, tsk.m_pData_ptr); + else + tsk.m_callback(tsk.m_data, tsk.m_pData_ptr); + + atomic_decrement32(&m_num_outstanding_tasks); + } + + void task_pool::join() + { + while (atomic_add32(&m_num_outstanding_tasks, 0) > 0) + { + task tsk; + if (m_task_stack.pop(tsk)) + { + process_task(tsk); + } + else + { + lzham_sleep(1); + } + } + } + + unsigned __stdcall task_pool::thread_func(void* pContext) + { + task_pool* pPool = static_cast(pContext); + + for ( ; ; ) + { + if (!pPool->m_tasks_available.wait()) + break; + + if (pPool->m_exit_flag) + break; + + task tsk; + if (pPool->m_task_stack.pop(tsk)) + { + pPool->process_task(tsk); + } + } + + _endthreadex(0); + return 0; + } + + static uint g_num_processors; + + uint lzham_get_max_helper_threads() + { + if (!g_num_processors) + { + SYSTEM_INFO system_info; + GetSystemInfo(&system_info); + g_num_processors = system_info.dwNumberOfProcessors; + } + + if (g_num_processors > 1) + { + // use all CPU's + return LZHAM_MIN(task_pool::cMaxThreads, g_num_processors - 1); + } + + return 0; + } + +} // namespace lzham + +#endif // LZHAM_USE_WIN32_API diff --git a/r5dev/thirdparty/lzham/lzhamcomp/lzham_comp.h b/r5dev/thirdparty/lzham/lzhamcomp/lzham_comp.h new file mode 100644 index 00000000..05827470 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamcomp/lzham_comp.h @@ -0,0 +1,38 @@ +// File: lzham_comp.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once +#include "../include/lzham.h" + +namespace lzham +{ + lzham_compress_state_ptr LZHAM_CDECL lzham_lib_compress_init(const lzham_compress_params *pParams); + + lzham_compress_state_ptr LZHAM_CDECL lzham_lib_compress_reinit(lzham_compress_state_ptr p); + + lzham_compress_checksums* LZHAM_CDECL lzham_lib_compress_deinit(lzham_compress_state_ptr p); + + lzham_compress_status_t LZHAM_CDECL lzham_lib_compress( + lzham_compress_state_ptr p, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_bool no_more_input_bytes_flag); + + lzham_compress_status_t LZHAM_CDECL lzham_lib_compress2( + lzham_compress_state_ptr p, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_flush_t flush_type); + + lzham_compress_status_t LZHAM_CDECL lzham_lib_compress_memory(const lzham_compress_params *pParams, lzham_uint8* pDst_buf, size_t *pDst_len, const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32, lzham_uint32* pCrc32); + + int lzham_lib_z_deflateInit(lzham_z_streamp pStream, int level); + int lzham_lib_z_deflateInit2(lzham_z_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy); + int lzham_lib_z_deflateReset(lzham_z_streamp pStream); + int lzham_lib_z_deflate(lzham_z_streamp pStream, int flush); + int lzham_lib_z_deflateEnd(lzham_z_streamp pStream); + lzham_z_ulong lzham_lib_z_deflateBound(lzham_z_streamp pStream, lzham_z_ulong source_len); + int lzham_lib_z_compress2(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len, int level); + int lzham_lib_z_compress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len); + lzham_z_ulong lzham_lib_z_compressBound(lzham_z_ulong source_len); + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp.cpp b/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp.cpp new file mode 100644 index 00000000..4e54c736 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp.cpp @@ -0,0 +1,611 @@ +// File: lzham_lzcomp.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "../include/lzham_core.h" +#include "../include/lzham.h" +#include "lzham_comp.h" +#include "lzham_lzcomp_internal.h" + +using namespace lzham; + +namespace lzham +{ + struct lzham_compress_state + { + // task_pool requires 8 or 16 alignment + task_pool m_tp; + lzcompressor m_compressor; + + uint m_dict_size_log2; + + const uint8 *m_pIn_buf; + size_t *m_pIn_buf_size; + uint8 *m_pOut_buf; + size_t *m_pOut_buf_size; + + size_t m_comp_data_ofs; + + bool m_finished_compression; + + lzham_compress_params m_params; + + lzham_compress_status_t m_status; + }; + + static lzham_compress_status_t create_internal_init_params(lzcompressor::init_params &internal_params, const lzham_compress_params *pParams) + { + if ((pParams->m_dict_size_log2 < CLZBase::cMinDictSizeLog2) || (pParams->m_dict_size_log2 > CLZBase::cMaxDictSizeLog2)) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + + if (pParams->m_cpucache_total_lines) + { + if (!math::is_power_of_2(pParams->m_cpucache_line_size)) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + } + + internal_params.m_dict_size_log2 = pParams->m_dict_size_log2; + + if (pParams->m_max_helper_threads < 0) + internal_params.m_max_helper_threads = lzham_get_max_helper_threads(); + else + internal_params.m_max_helper_threads = pParams->m_max_helper_threads; + internal_params.m_max_helper_threads = LZHAM_MIN(LZHAM_MAX_HELPER_THREADS, internal_params.m_max_helper_threads); + + internal_params.m_num_cachelines = pParams->m_cpucache_total_lines; + internal_params.m_cacheline_size = pParams->m_cpucache_line_size; + internal_params.m_lzham_compress_flags = pParams->m_compress_flags; + + if (pParams->m_num_seed_bytes) + { + if ((!pParams->m_pSeed_bytes) || (pParams->m_num_seed_bytes > (1U << pParams->m_dict_size_log2))) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + + internal_params.m_num_seed_bytes = pParams->m_num_seed_bytes; + internal_params.m_pSeed_bytes = pParams->m_pSeed_bytes; + } + + switch (pParams->m_level) + { + case LZHAM_COMP_LEVEL_FASTEST: internal_params.m_compression_level = cCompressionLevelFastest; break; + case LZHAM_COMP_LEVEL_FASTER: internal_params.m_compression_level = cCompressionLevelFaster; break; + case LZHAM_COMP_LEVEL_DEFAULT: internal_params.m_compression_level = cCompressionLevelDefault; break; + case LZHAM_COMP_LEVEL_BETTER: internal_params.m_compression_level = cCompressionLevelBetter; break; + case LZHAM_COMP_LEVEL_UBER: internal_params.m_compression_level = cCompressionLevelUber; break; + default: + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + }; + + return LZHAM_COMP_STATUS_SUCCESS; + } + + lzham_compress_state_ptr LZHAM_CDECL lzham_lib_compress_init(const lzham_compress_params *pParams) + { + if ((!pParams) || (pParams->m_struct_size != sizeof(lzham_compress_params))) + return NULL; + + if ((pParams->m_dict_size_log2 < CLZBase::cMinDictSizeLog2) || (pParams->m_dict_size_log2 > CLZBase::cMaxDictSizeLog2)) + return NULL; + + lzcompressor::init_params internal_params; + lzham_compress_status_t status = create_internal_init_params(internal_params, pParams); + if (status != LZHAM_COMP_STATUS_SUCCESS) + return NULL; + + lzham_compress_state *pState = lzham_new(); + if (!pState) + return NULL; + + pState->m_params = *pParams; + + pState->m_pIn_buf = NULL; + pState->m_pIn_buf_size = NULL; + pState->m_pOut_buf = NULL; + pState->m_pOut_buf_size = NULL; + pState->m_status = LZHAM_COMP_STATUS_NOT_FINISHED; + pState->m_comp_data_ofs = 0; + pState->m_finished_compression = false; + + if (internal_params.m_max_helper_threads) + { + if (!pState->m_tp.init(internal_params.m_max_helper_threads)) + { + lzham_delete(pState); + return NULL; + } + if (pState->m_tp.get_num_threads() >= internal_params.m_max_helper_threads) + { + internal_params.m_pTask_pool = &pState->m_tp; + } + else + { + internal_params.m_max_helper_threads = 0; + } + } + + if (!pState->m_compressor.init(internal_params)) + { + lzham_delete(pState); + return NULL; + } + + return pState; + } + + lzham_compress_state_ptr LZHAM_CDECL lzham_lib_compress_reinit(lzham_compress_state_ptr p) + { + lzham_compress_state *pState = static_cast(p); + if (pState) + { + if (!pState->m_compressor.reset()) + return NULL; + + pState->m_pIn_buf = NULL; + pState->m_pIn_buf_size = NULL; + pState->m_pOut_buf = NULL; + pState->m_pOut_buf_size = NULL; + pState->m_status = LZHAM_COMP_STATUS_NOT_FINISHED; + pState->m_comp_data_ofs = 0; + pState->m_finished_compression = false; + } + + return pState; + } + + lzham_compress_checksums* LZHAM_CDECL lzham_lib_compress_deinit(lzham_compress_state_ptr p) + { + lzham_compress_state *pState = static_cast(p); + if (!pState) + return nullptr; + + lzham_compress_checksums* checksums = new lzham_compress_checksums(); + checksums->adler32 = pState->m_compressor.get_src_adler32(); + checksums->crc32 = pState->m_compressor.get_src_crc32(); + + printf("checksums->adler32 %zX\n", checksums->adler32); + printf("checksums->crc32 %zX\n", checksums->crc32); + + lzham_delete(pState); + return checksums; + } + + lzham_compress_status_t LZHAM_CDECL lzham_lib_compress( + lzham_compress_state_ptr p, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_bool no_more_input_bytes_flag) + { + return lzham_lib_compress2(p, pIn_buf, pIn_buf_size, pOut_buf, pOut_buf_size, no_more_input_bytes_flag ? LZHAM_FINISH : LZHAM_NO_FLUSH); + } + + lzham_compress_status_t LZHAM_CDECL lzham_lib_compress2( + lzham_compress_state_ptr p, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_flush_t flush_type) + { + lzham_compress_state *pState = static_cast(p); + + if ((!pState) || (!pState->m_params.m_dict_size_log2) || (pState->m_status >= LZHAM_COMP_STATUS_FIRST_SUCCESS_OR_FAILURE_CODE) || (!pIn_buf_size) || (!pOut_buf_size)) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + + if ((*pIn_buf_size) && (!pIn_buf)) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + + if ((!*pOut_buf_size) || (!pOut_buf)) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + + byte_vec &comp_data = pState->m_compressor.get_compressed_data(); + size_t num_bytes_written_to_out_buf = 0; + if (pState->m_comp_data_ofs < comp_data.size()) + { + size_t n = LZHAM_MIN(comp_data.size() - pState->m_comp_data_ofs, *pOut_buf_size); + + memcpy(pOut_buf, comp_data.get_ptr() + pState->m_comp_data_ofs, n); + + pState->m_comp_data_ofs += n; + + const bool has_no_more_output = (pState->m_comp_data_ofs >= comp_data.size()); + if (has_no_more_output) + { + pOut_buf += n; + *pOut_buf_size -= n; + num_bytes_written_to_out_buf += n; + } + else + { + *pIn_buf_size = 0; + *pOut_buf_size = n; + pState->m_status = LZHAM_COMP_STATUS_HAS_MORE_OUTPUT; + return pState->m_status; + } + } + + comp_data.try_resize(0); + pState->m_comp_data_ofs = 0; + + if (pState->m_finished_compression) + { + if ((*pIn_buf_size) || (flush_type != LZHAM_FINISH)) + { + pState->m_status = LZHAM_COMP_STATUS_INVALID_PARAMETER; + return pState->m_status; + } + + *pIn_buf_size = 0; + *pOut_buf_size = num_bytes_written_to_out_buf; + + pState->m_status = LZHAM_COMP_STATUS_SUCCESS; + return pState->m_status; + } + + const size_t cMaxBytesToPutPerIteration = 4*1024*1024; + size_t bytes_to_put = LZHAM_MIN(cMaxBytesToPutPerIteration, *pIn_buf_size); + const bool consumed_entire_input_buf = (bytes_to_put == *pIn_buf_size); + + if (bytes_to_put) + { + if (!pState->m_compressor.put_bytes(pIn_buf, (uint)bytes_to_put)) + { + *pIn_buf_size = 0; + *pOut_buf_size = num_bytes_written_to_out_buf; + pState->m_status = LZHAM_COMP_STATUS_FAILED; + return pState->m_status; + } + } + + if ((consumed_entire_input_buf) && (flush_type != LZHAM_NO_FLUSH)) + { + if ((flush_type == LZHAM_SYNC_FLUSH) || (flush_type == LZHAM_FULL_FLUSH) || (flush_type == LZHAM_TABLE_FLUSH)) + { + if (!pState->m_compressor.flush(flush_type)) + { + *pIn_buf_size = 0; + *pOut_buf_size = num_bytes_written_to_out_buf; + pState->m_status = LZHAM_COMP_STATUS_FAILED; + return pState->m_status; + } + } + else if (!pState->m_finished_compression) + { + if (!pState->m_compressor.put_bytes(NULL, 0)) + { + *pIn_buf_size = 0; + *pOut_buf_size = num_bytes_written_to_out_buf; + pState->m_status = LZHAM_COMP_STATUS_FAILED; + return pState->m_status; + } + pState->m_finished_compression = true; + } + } + + size_t num_comp_bytes_to_output = LZHAM_MIN(comp_data.size() - pState->m_comp_data_ofs, *pOut_buf_size); + if (num_comp_bytes_to_output) + { + memcpy(pOut_buf, comp_data.get_ptr() + pState->m_comp_data_ofs, num_comp_bytes_to_output); + + pState->m_comp_data_ofs += num_comp_bytes_to_output; + } + + *pIn_buf_size = bytes_to_put; + *pOut_buf_size = num_bytes_written_to_out_buf + num_comp_bytes_to_output; + + const bool has_no_more_output = (pState->m_comp_data_ofs >= comp_data.size()); + if ((has_no_more_output) && (flush_type == LZHAM_FINISH) && (pState->m_finished_compression)) + pState->m_status = LZHAM_COMP_STATUS_SUCCESS; + else if ((has_no_more_output) && (consumed_entire_input_buf) && (flush_type == LZHAM_NO_FLUSH)) + pState->m_status = LZHAM_COMP_STATUS_NEEDS_MORE_INPUT; + else + pState->m_status = has_no_more_output ? LZHAM_COMP_STATUS_NOT_FINISHED : LZHAM_COMP_STATUS_HAS_MORE_OUTPUT; + + return pState->m_status; + } + + lzham_compress_status_t LZHAM_CDECL lzham_lib_compress_memory(const lzham_compress_params *pParams, lzham_uint8* pDst_buf, size_t *pDst_len, const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32, lzham_uint32 *pCrc32) + { + if ((!pParams) || (!pDst_len)) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + + if (src_len) + { + if (!pSrc_buf) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + } + + if (sizeof(size_t) > sizeof(uint32)) + { + if (src_len > UINT32_MAX) + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + } + + lzcompressor::init_params internal_params; + lzham_compress_status_t status = create_internal_init_params(internal_params, pParams); + if (status != LZHAM_COMP_STATUS_SUCCESS) + return status; + + task_pool *pTP = NULL; + if (internal_params.m_max_helper_threads) + { + pTP = lzham_new(); + if (!pTP->init(internal_params.m_max_helper_threads)) + return LZHAM_COMP_STATUS_FAILED; + + internal_params.m_pTask_pool = pTP; + } + + lzcompressor *pCompressor = lzham_new(); + if (!pCompressor) + { + lzham_delete(pTP); + return LZHAM_COMP_STATUS_FAILED; + } + + if (!pCompressor->init(internal_params)) + { + lzham_delete(pTP); + lzham_delete(pCompressor); + return LZHAM_COMP_STATUS_INVALID_PARAMETER; + } + + if (src_len) + { + if (!pCompressor->put_bytes(pSrc_buf, static_cast(src_len))) + { + *pDst_len = 0; + lzham_delete(pTP); + lzham_delete(pCompressor); + return LZHAM_COMP_STATUS_FAILED; + } + } + + if (!pCompressor->put_bytes(NULL, 0)) + { + *pDst_len = 0; + lzham_delete(pTP); + lzham_delete(pCompressor); + return LZHAM_COMP_STATUS_FAILED; + } + + const byte_vec &comp_data = pCompressor->get_compressed_data(); + + size_t dst_buf_size = *pDst_len; + *pDst_len = comp_data.size(); + + if (pAdler32) + *pAdler32 = pCompressor->get_src_adler32(); + if (pCrc32) + *pCrc32 = pCompressor->get_src_crc32(); + + if (comp_data.size() > dst_buf_size) + { + lzham_delete(pTP); + lzham_delete(pCompressor); + return LZHAM_COMP_STATUS_OUTPUT_BUF_TOO_SMALL; + } + + memcpy(pDst_buf, comp_data.get_ptr(), comp_data.size()); + + lzham_delete(pTP); + lzham_delete(pCompressor); + return LZHAM_COMP_STATUS_SUCCESS; + } + + // ----------------- zlib-style API's + + int lzham_lib_z_deflateInit(lzham_z_streamp pStream, int level) + { + return lzham_lib_z_deflateInit2(pStream, level, LZHAM_Z_LZHAM, LZHAM_Z_DEFAULT_WINDOW_BITS, 9, LZHAM_Z_DEFAULT_STRATEGY); + } + + int lzham_lib_z_deflateInit2(lzham_z_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy) + { + LZHAM_NOTE_UNUSED(strategy); + + if (!pStream) + return LZHAM_Z_STREAM_ERROR; + if ((mem_level < 1) || (mem_level > 9)) + return LZHAM_Z_PARAM_ERROR; + if ((method != LZHAM_Z_DEFLATED) && (method != LZHAM_Z_LZHAM)) + return LZHAM_Z_PARAM_ERROR; + + if (level == LZHAM_Z_DEFAULT_COMPRESSION) + level = 9; + + if (method == LZHAM_Z_DEFLATED) + { + // Force Deflate to LZHAM with default window_bits. + method = LZHAM_Z_LZHAM; + window_bits = LZHAM_Z_DEFAULT_WINDOW_BITS; + } + +#ifdef LZHAM_Z_API_FORCE_WINDOW_BITS + window_bits = LZHAM_Z_API_FORCE_WINDOW_BITS; +#endif + + int max_window_bits = LZHAM_64BIT_POINTERS ? LZHAM_MAX_DICT_SIZE_LOG2_X64 : LZHAM_MAX_DICT_SIZE_LOG2_X86; + if ((labs(window_bits) < LZHAM_MIN_DICT_SIZE_LOG2) || (labs(window_bits) > max_window_bits)) + return LZHAM_Z_PARAM_ERROR; + + lzham_compress_params comp_params; + + utils::zero_object(comp_params); + comp_params.m_struct_size = sizeof(lzham_compress_params); + + comp_params.m_level = LZHAM_COMP_LEVEL_UBER; + if (level <= 1) + comp_params.m_level = LZHAM_COMP_LEVEL_FASTEST; + else if (level <= 3) + comp_params.m_level = LZHAM_COMP_LEVEL_FASTER; + else if (level <= 5) + comp_params.m_level = LZHAM_COMP_LEVEL_DEFAULT; + else if (level <= 7) + comp_params.m_level = LZHAM_COMP_LEVEL_BETTER; + + if (level == 10) + comp_params.m_compress_flags |= LZHAM_COMP_FLAG_EXTREME_PARSING; + + // Use all CPU's. TODO: This is not always the best idea depending on the dictionary size and the # of bytes to compress. + comp_params.m_max_helper_threads = -1; + + comp_params.m_dict_size_log2 = labs(window_bits); + + if (window_bits > 0) + comp_params.m_compress_flags |= LZHAM_COMP_FLAG_WRITE_ZLIB_STREAM; + + pStream->data_type = 0; + pStream->adler32 = LZHAM_Z_ADLER32_INIT; + pStream->msg = NULL; + pStream->reserved = 0; + pStream->total_in = 0; + pStream->total_out = 0; + + lzham_compress_state_ptr pComp = lzham_lib_compress_init(&comp_params); + if (!pComp) + return LZHAM_Z_PARAM_ERROR; + + pStream->state = (struct lzham_z_internal_state *)pComp; + + return LZHAM_Z_OK; + } + + int lzham_lib_z_deflateReset(lzham_z_streamp pStream) + { + if (!pStream) + return LZHAM_Z_STREAM_ERROR; + + lzham_compress_state_ptr pComp = (lzham_compress_state_ptr)pStream->state; + if (!pComp) + return LZHAM_Z_STREAM_ERROR; + + pComp = lzham_lib_compress_reinit(pComp); + if (!pComp) + return LZHAM_Z_STREAM_ERROR; + + pStream->state = (struct lzham_z_internal_state *)pComp; + + return LZHAM_Z_OK; + } + + int lzham_lib_z_deflate(lzham_z_streamp pStream, int flush) + { + if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > LZHAM_Z_FINISH) || (!pStream->next_out)) + return LZHAM_Z_STREAM_ERROR; + + if (!pStream->avail_out) + return LZHAM_Z_BUF_ERROR; + + if (flush == LZHAM_Z_PARTIAL_FLUSH) + flush = LZHAM_Z_SYNC_FLUSH; + + int lzham_status = LZHAM_Z_OK; + lzham_z_ulong orig_total_in = pStream->total_in, orig_total_out = pStream->total_out; + for ( ; ; ) + { + size_t in_bytes = pStream->avail_in, out_bytes = pStream->avail_out; + + lzham_compress_state_ptr pComp = (lzham_compress_state_ptr)pStream->state; + lzham_compress_state *pState = static_cast(pComp); + + lzham_compress_status_t status = lzham_lib_compress2( + pComp, + pStream->next_in, &in_bytes, + pStream->next_out, &out_bytes, + (lzham_flush_t)flush); + + pStream->next_in += (uint)in_bytes; + pStream->avail_in -= (uint)in_bytes; + pStream->total_in += (uint)in_bytes; + + pStream->next_out += (uint)out_bytes; + pStream->avail_out -= (uint)out_bytes; + pStream->total_out += (uint)out_bytes; + + pStream->adler32 = pState->m_compressor.get_src_adler32(); + pStream->crc32 = pState->m_compressor.get_src_crc32(); + + if (status >= LZHAM_COMP_STATUS_FIRST_FAILURE_CODE) + { + lzham_status = LZHAM_Z_STREAM_ERROR; + break; + } + else if (status == LZHAM_COMP_STATUS_SUCCESS) + { + lzham_status = LZHAM_Z_STREAM_END; + break; + } + else if (!pStream->avail_out) + break; + else if ((!pStream->avail_in) && (flush != LZHAM_Z_FINISH)) + { + if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out)) + break; + return LZHAM_Z_BUF_ERROR; // Can't make forward progress without some input. + } + } + return lzham_status; + } + + int lzham_lib_z_deflateEnd(lzham_z_streamp pStream) + { + if (!pStream) + return LZHAM_Z_STREAM_ERROR; + + lzham_compress_state_ptr pComp = (lzham_compress_state_ptr)pStream->state; + if (pComp) + { + lzham_compress_checksums* checksums = lzham_lib_compress_deinit(pComp); + + pStream->adler32 = checksums->adler32; + pStream->crc32 = checksums->crc32; + + pStream->state = NULL; + } + + return LZHAM_Z_OK; + } + + lzham_z_ulong lzham_lib_z_deflateBound(lzham_z_streamp pStream, lzham_z_ulong source_len) + { + LZHAM_NOTE_UNUSED(pStream); + return 64 + source_len + ((source_len + 4095) / 4096) * 4; + } + + int lzham_lib_z_compress2(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len, int level) + { + int status; + lzham_z_stream stream; + memset(&stream, 0, sizeof(stream)); + + // In case lzham_z_ulong is 64-bits (argh I hate longs). + if ((source_len | *pDest_len) > 0xFFFFFFFFU) + return LZHAM_Z_PARAM_ERROR; + + stream.next_in = pSource; + stream.avail_in = (uint)source_len; + stream.next_out = pDest; + stream.avail_out = (uint)*pDest_len; + + status = lzham_lib_z_deflateInit(&stream, level); + if (status != LZHAM_Z_OK) + return status; + + status = lzham_lib_z_deflate(&stream, LZHAM_Z_FINISH); + if (status != LZHAM_Z_STREAM_END) + { + lzham_lib_z_deflateEnd(&stream); + return (status == LZHAM_Z_OK) ? LZHAM_Z_BUF_ERROR : status; + } + + *pDest_len = stream.total_out; + return lzham_lib_z_deflateEnd(&stream); + } + + int lzham_lib_z_compress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len) + { + return lzham_lib_z_compress2(pDest, pDest_len, pSource, source_len, (int)LZHAM_Z_DEFAULT_COMPRESSION); + } + + lzham_z_ulong lzham_lib_z_compressBound(lzham_z_ulong source_len) + { + return lzham_lib_z_deflateBound(NULL, source_len); + } + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.cpp b/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.cpp new file mode 100644 index 00000000..55ac4149 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.cpp @@ -0,0 +1,1972 @@ +// File: lzham_lzcomp_internal.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "../include/lzham_core.h" +#include "lzham_lzcomp_internal.h" +#include "../include/lzham_checksum.h" +#include "../include/lzham_timer.h" +#include "../include/lzham_lzbase.h" +#include + +// Update and print high-level coding statistics if set to 1. +// TODO: Add match distance coding statistics. +#define LZHAM_UPDATE_STATS 0 + +// Only parse on the main thread, for easier debugging. +#define LZHAM_FORCE_SINGLE_THREADED_PARSING 0 + +// Verify all computed match costs against the generic/slow state::get_cost() method. +#define LZHAM_VERIFY_MATCH_COSTS 0 + +// Set to 1 to force all blocks to be uncompressed (raw). +#define LZHAM_FORCE_ALL_RAW_BLOCKS 0 + +namespace lzham +{ + static comp_settings s_level_settings[cCompressionLevelCount] = + { + // cCompressionLevelFastest + { + 8, // m_fast_bytes + true, // m_fast_adaptive_huffman_updating + true, // m_use_polar_codes + 1, // m_match_accel_max_matches_per_probe + 2, // m_match_accel_max_probes + }, + // cCompressionLevelFaster + { + 24, // m_fast_bytes + true, // m_fast_adaptive_huffman_updating + true, // m_use_polar_codes + 6, // m_match_accel_max_matches_per_probe + 12, // m_match_accel_max_probes + }, + // cCompressionLevelDefault + { + 32, // m_fast_bytes + false, // m_fast_adaptive_huffman_updating + true, // m_use_polar_codes + UINT_MAX, // m_match_accel_max_matches_per_probe + 16, // m_match_accel_max_probes + }, + // cCompressionLevelBetter + { + 48, // m_fast_bytes + false, // m_fast_adaptive_huffman_updating + false, // m_use_polar_codes + UINT_MAX, // m_match_accel_max_matches_per_probe + 32, // m_match_accel_max_probes + }, + // cCompressionLevelUber + { + 64, // m_fast_bytes + false, // m_fast_adaptive_huffman_updating + false, // m_use_polar_codes + UINT_MAX, // m_match_accel_max_matches_per_probe + cMatchAccelMaxSupportedProbes, // m_match_accel_max_probes + } + }; + + lzcompressor::lzcompressor() : + m_src_size(-1), + m_src_adler32(0), + m_src_crc32(0), + m_step(0), + m_block_start_dict_ofs(0), + m_block_index(0), + m_finished(false), + m_num_parse_threads(0), + m_parse_jobs_remaining(0), + m_block_history_size(0), + m_block_history_next(0) + { + LZHAM_VERIFY( ((uint32_ptr)this & (LZHAM_GET_ALIGNMENT(lzcompressor) - 1)) == 0); + } + + bool lzcompressor::init_seed_bytes() + { + uint cur_seed_ofs = 0; + + while (cur_seed_ofs < m_params.m_num_seed_bytes) + { + uint total_bytes_remaining = m_params.m_num_seed_bytes - cur_seed_ofs; + uint num_bytes_to_add = math::minimum(total_bytes_remaining, m_params.m_block_size); + + if (!m_accel.add_bytes_begin(num_bytes_to_add, static_cast(m_params.m_pSeed_bytes) + cur_seed_ofs)) + return false; + m_accel.add_bytes_end(); + + m_accel.advance_bytes(num_bytes_to_add); + + cur_seed_ofs += num_bytes_to_add; + } + + return true; + } + + bool lzcompressor::init(const init_params& params) + { + clear(); + + if ((params.m_dict_size_log2 < CLZBase::cMinDictSizeLog2) || (params.m_dict_size_log2 > CLZBase::cMaxDictSizeLog2)) + return false; + if ((params.m_compression_level < 0) || (params.m_compression_level > cCompressionLevelCount)) + return false; + + m_params = params; + m_use_task_pool = (m_params.m_pTask_pool) && (m_params.m_pTask_pool->get_num_threads() != 0) && (m_params.m_max_helper_threads > 0); + if ((m_params.m_max_helper_threads) && (!m_use_task_pool)) + return false; + m_settings = s_level_settings[params.m_compression_level]; + + const uint dict_size = 1U << m_params.m_dict_size_log2; + + if (params.m_num_seed_bytes) + { + if (!params.m_pSeed_bytes) + return false; + if (params.m_num_seed_bytes > dict_size) + return false; + } + + if (m_params.m_lzham_compress_flags & LZHAM_COMP_FLAG_FORCE_POLAR_CODING) + m_settings.m_use_polar_codes = true; + + uint max_block_size = dict_size / 8; + if (m_params.m_block_size > max_block_size) + { + m_params.m_block_size = max_block_size; + } + + m_num_parse_threads = 1; + +#if !LZHAM_FORCE_SINGLE_THREADED_PARSING + if (params.m_max_helper_threads > 0) + { + LZHAM_ASSUME(cMaxParseThreads >= 4); + + if (m_params.m_block_size < 16384) + { + m_num_parse_threads = LZHAM_MIN(cMaxParseThreads, params.m_max_helper_threads + 1); + } + else + { + if ((params.m_max_helper_threads == 1) || (m_params.m_compression_level == cCompressionLevelFastest)) + { + m_num_parse_threads = 1; + } + else if (params.m_max_helper_threads <= 3) + { + m_num_parse_threads = 2; + } + else if (params.m_max_helper_threads <= 7) + { + if ((m_params.m_lzham_compress_flags & LZHAM_COMP_FLAG_EXTREME_PARSING) && (m_params.m_compression_level == cCompressionLevelUber)) + m_num_parse_threads = 4; + else + m_num_parse_threads = 2; + } + else + { + // 8-16 + m_num_parse_threads = 4; + } + } + } +#endif + + int num_parse_jobs = m_num_parse_threads - 1; + uint match_accel_helper_threads = LZHAM_MAX(0, (int)params.m_max_helper_threads - num_parse_jobs); + + LZHAM_ASSERT(m_num_parse_threads >= 1); + LZHAM_ASSERT(m_num_parse_threads <= cMaxParseThreads); + + if (!m_use_task_pool) + { + LZHAM_ASSERT(!match_accel_helper_threads && (m_num_parse_threads == 1)); + } + else + { + LZHAM_ASSERT((match_accel_helper_threads + (m_num_parse_threads - 1)) <= params.m_max_helper_threads); + } + + if (!m_accel.init(this, params.m_pTask_pool, match_accel_helper_threads, dict_size, m_settings.m_match_accel_max_matches_per_probe, false, m_settings.m_match_accel_max_probes)) + return false; + + init_position_slots(params.m_dict_size_log2); + init_slot_tabs(); + + if (!m_state.init(*this, m_settings.m_fast_adaptive_huffman_updating, m_settings.m_use_polar_codes)) + return false; + + if (!m_block_buf.try_reserve(m_params.m_block_size)) + return false; + + if (!m_comp_buf.try_reserve(m_params.m_block_size*2)) + return false; + + for (uint i = 0; i < m_num_parse_threads; i++) + { + if (!m_parse_thread_state[i].m_initial_state.init(*this, m_settings.m_fast_adaptive_huffman_updating, m_settings.m_use_polar_codes)) + return false; + } + + m_block_history_size = 0; + m_block_history_next = 0; + + if (params.m_num_seed_bytes) + { + if (!init_seed_bytes()) + return false; + } + + if (!send_zlib_header()) + return false; + + m_src_size = 0; + + return true; + } + + // See http://www.gzip.org/zlib/rfc-zlib.html + // Method is set to 14 (LZHAM) and CINFO is (window_size - 15). + bool lzcompressor::send_zlib_header() + { + if ((m_params.m_lzham_compress_flags & LZHAM_COMP_FLAG_WRITE_ZLIB_STREAM) == 0) + return true; + + // set CM (method) and CINFO (dictionary size) fields + int cmf = LZHAM_Z_LZHAM | ((m_params.m_dict_size_log2 - 15) << 4); + + // set FLEVEL by mapping LZHAM's compression level to zlib's + int flg = 0; + switch (m_params.m_compression_level) + { + case LZHAM_COMP_LEVEL_FASTEST: + { + flg = 0 << 6; + break; + } + case LZHAM_COMP_LEVEL_FASTER: + { + flg = 1 << 6; + break; + } + case LZHAM_COMP_LEVEL_DEFAULT: + case LZHAM_COMP_LEVEL_BETTER: + { + flg = 2 << 6; + break; + } + default: + { + flg = 3 << 6; + break; + } + } + + // set FDICT flag + if (m_params.m_pSeed_bytes) + flg |= 32; + + int check = ((cmf << 8) + flg) % 31; + if (check) + flg += (31 - check); + + LZHAM_ASSERT(0 == (((cmf << 8) + flg) % 31)); + if (!m_comp_buf.try_push_back(static_cast(cmf))) + return false; + if (!m_comp_buf.try_push_back(static_cast(flg))) + return false; + + if (m_params.m_pSeed_bytes) + { + // send adler32 of DICT + uint dict_adler32 = adler32(m_params.m_pSeed_bytes, m_params.m_num_seed_bytes); + for (uint i = 0; i < 4; i++) + { + if (!m_comp_buf.try_push_back(static_cast(dict_adler32 >> 24))) + return false; + dict_adler32 <<= 8; + } + } + + return true; + } + + void lzcompressor::clear() + { + m_codec.clear(); + m_src_size = -1; + m_src_adler32 = cInitAdler32; + m_src_crc32 = cInitCRC32; + m_block_buf.clear(); + m_comp_buf.clear(); + + m_step = 0; + m_finished = false; + m_use_task_pool = false; + m_block_start_dict_ofs = 0; + m_block_index = 0; + m_state.clear(); + m_num_parse_threads = 0; + m_parse_jobs_remaining = 0; + + for (uint i = 0; i < cMaxParseThreads; i++) + { + parse_thread_state &parse_state = m_parse_thread_state[i]; + parse_state.m_initial_state.clear(); + + for (uint j = 0; j <= cMaxParseGraphNodes; j++) + parse_state.m_nodes[j].clear(); + + parse_state.m_start_ofs = 0; + parse_state.m_bytes_to_match = 0; + parse_state.m_best_decisions.clear(); + parse_state.m_issue_reset_state_partial = false; + parse_state.m_emit_decisions_backwards = false; + parse_state.m_failed = false; + } + + m_block_history_size = 0; + m_block_history_next = 0; + } + + bool lzcompressor::reset() + { + if (m_src_size < 0) + return false; + + m_accel.reset(); + m_codec.reset(); + m_stats.clear(); + m_src_size = 0; + m_src_adler32 = cInitAdler32; + m_src_crc32 = cInitCRC32; + m_block_buf.try_resize(0); + m_comp_buf.try_resize(0); + + m_step = 0; + m_finished = false; + m_block_start_dict_ofs = 0; + m_block_index = 0; + m_state.reset(); + + m_block_history_size = 0; + m_block_history_next = 0; + + if (m_params.m_num_seed_bytes) + { + if (!init_seed_bytes()) + return false; + } + + return send_zlib_header(); + } + + bool lzcompressor::code_decision(lzdecision lzdec, uint& cur_ofs, uint& bytes_to_match) + { +#ifdef LZHAM_LZDEBUG + if (!m_codec.encode_bits(CLZBase::cLZHAMDebugSyncMarkerValue, CLZBase::cLZHAMDebugSyncMarkerBits)) return false; + if (!m_codec.encode_bits(lzdec.is_match(), 1)) return false; + if (!m_codec.encode_bits(lzdec.get_len(), 17)) return false; + if (!m_codec.encode_bits(m_state.m_cur_state, 4)) return false; +#endif + +#ifdef LZHAM_LZVERIFY + if (lzdec.is_match()) + { + uint match_dist = lzdec.get_match_dist(m_state); + + LZHAM_VERIFY(m_accel[cur_ofs] == m_accel[(cur_ofs - match_dist) & (m_accel.get_max_dict_size() - 1)]); + } +#endif + + const uint len = lzdec.get_len(); + + if (!m_state.encode(m_codec, *this, m_accel, lzdec)) + return false; + + cur_ofs += len; + LZHAM_ASSERT(bytes_to_match >= len); + bytes_to_match -= len; + + m_accel.advance_bytes(len); + + m_step++; + + return true; + } + + bool lzcompressor::send_sync_block(lzham_flush_t flush_type) + { + m_codec.reset(); + + if (!m_codec.start_encoding(128)) + return false; +#ifdef LZHAM_LZDEBUG + if (!m_codec.encode_bits(166, 12)) + return false; +#endif + if (!m_codec.encode_bits(cSyncBlock, cBlockHeaderBits)) + return false; + + int flush_code = 0; + switch (flush_type) + { + case LZHAM_FULL_FLUSH: + flush_code = 2; + break; + case LZHAM_TABLE_FLUSH: + flush_code = 1; + break; + case LZHAM_SYNC_FLUSH: + case LZHAM_NO_FLUSH: + case LZHAM_FINISH: + flush_code = 0; + break; + } + if (!m_codec.encode_bits(flush_code, cBlockFlushTypeBits)) + return false; + + if (!m_codec.encode_align_to_byte()) + return false; + if (!m_codec.encode_bits(0x0000, 16)) + return false; + if (!m_codec.encode_bits(0xFFFF, 16)) + return false; + if (!m_codec.stop_encoding(true)) + return false; + if (!m_comp_buf.append(m_codec.get_encoding_buf())) + return false; + + m_block_index++; + return true; + } + + bool lzcompressor::flush(lzham_flush_t flush_type) + { + LZHAM_ASSERT(!m_finished); + if (m_finished) + return false; + + bool status = true; + if (m_block_buf.size()) + { + status = compress_block(m_block_buf.get_ptr(), m_block_buf.size()); + + m_block_buf.try_resize(0); + } + + if (status) + { + status = send_sync_block(flush_type); + + if (LZHAM_FULL_FLUSH == flush_type) + { + m_accel.flush(); + m_state.reset(); + } + } + + lzham_flush_buffered_printf(); + + return status; + } + + bool lzcompressor::put_bytes(const void* pBuf, uint buf_len) + { + LZHAM_ASSERT(!m_finished); + if (m_finished) + return false; + + bool status = true; + + if (!pBuf) + { + // Last block - flush whatever's left and send the final block. + if (m_block_buf.size()) + { + status = compress_block(m_block_buf.get_ptr(), m_block_buf.size()); + + m_block_buf.try_resize(0); + } + + if (status) + { + if (!send_final_block()) + { + status = false; + } + } + + m_finished = true; + } + else + { + // Compress blocks. + const uint8 *pSrcBuf = static_cast(pBuf); + uint num_src_bytes_remaining = buf_len; + + while (num_src_bytes_remaining) + { + const uint num_bytes_to_copy = LZHAM_MIN(num_src_bytes_remaining, m_params.m_block_size - m_block_buf.size()); + + if (num_bytes_to_copy == m_params.m_block_size) + { + LZHAM_ASSERT(!m_block_buf.size()); + + // Full-block available - compress in-place. + status = compress_block(pSrcBuf, num_bytes_to_copy); + } + else + { + // Less than a full block available - append to already accumulated bytes. + if (!m_block_buf.append(static_cast(pSrcBuf), num_bytes_to_copy)) + return false; + + LZHAM_ASSERT(m_block_buf.size() <= m_params.m_block_size); + + if (m_block_buf.size() == m_params.m_block_size) + { + status = compress_block(m_block_buf.get_ptr(), m_block_buf.size()); + + m_block_buf.try_resize(0); + } + } + + if (!status) + return false; + + pSrcBuf += num_bytes_to_copy; + num_src_bytes_remaining -= num_bytes_to_copy; + } + } + + lzham_flush_buffered_printf(); + + return status; + } + + bool lzcompressor::send_final_block() + { + if (!m_codec.start_encoding(16)) + return false; + +#ifdef LZHAM_LZDEBUG + if (!m_codec.encode_bits(166, 12)) + return false; +#endif + + if (!m_block_index) + { + if (!send_configuration()) + return false; + } + + if (!m_codec.encode_bits(cEOFBlock, cBlockHeaderBits)) + return false; + + if (!m_codec.encode_align_to_byte()) + return false; + + if (!m_codec.encode_bits(m_src_adler32, 32)) + return false; + + if (!m_codec.encode_bits(m_src_crc32, 32)) + return false; + + if (!m_codec.stop_encoding(true)) + return false; + + if (m_comp_buf.empty()) + { + m_comp_buf.swap(m_codec.get_encoding_buf()); + } + else + { + if (!m_comp_buf.append(m_codec.get_encoding_buf())) + return false; + } + + m_block_index++; + +#if LZHAM_UPDATE_STATS + m_stats.print(); +#endif + + return true; + } + + bool lzcompressor::send_configuration() + { + if (!m_codec.encode_bits(m_settings.m_fast_adaptive_huffman_updating, 1)) + return false; + if (!m_codec.encode_bits(m_settings.m_use_polar_codes, 1)) + return false; + + return true; + } + + void lzcompressor::node::add_state( + int parent_index, int parent_state_index, + const lzdecision &lzdec, state &parent_state, + bit_cost_t total_cost, + uint total_complexity) + { + state_base trial_state; + parent_state.save_partial_state(trial_state); + trial_state.partial_advance(lzdec); + + for (int i = m_num_node_states - 1; i >= 0; i--) + { + node_state &cur_node_state = m_node_states[i]; + if (cur_node_state.m_saved_state == trial_state) + { + if ( (total_cost < cur_node_state.m_total_cost) || + ((total_cost == cur_node_state.m_total_cost) && (total_complexity < cur_node_state.m_total_complexity)) ) + { + cur_node_state.m_parent_index = static_cast(parent_index); + cur_node_state.m_parent_state_index = static_cast(parent_state_index); + cur_node_state.m_lzdec = lzdec; + cur_node_state.m_total_cost = total_cost; + cur_node_state.m_total_complexity = total_complexity; + + while (i > 0) + { + if ((m_node_states[i].m_total_cost < m_node_states[i - 1].m_total_cost) || + ((m_node_states[i].m_total_cost == m_node_states[i - 1].m_total_cost) && (m_node_states[i].m_total_complexity < m_node_states[i - 1].m_total_complexity))) + { + std::swap(m_node_states[i], m_node_states[i - 1]); + i--; + } + else + break; + } + } + + return; + } + } + + int insert_index; + for (insert_index = m_num_node_states; insert_index > 0; insert_index--) + { + node_state &cur_node_state = m_node_states[insert_index - 1]; + + if ( (total_cost > cur_node_state.m_total_cost) || + ((total_cost == cur_node_state.m_total_cost) && (total_complexity >= cur_node_state.m_total_complexity)) ) + { + break; + } + } + + if (insert_index == cMaxNodeStates) + return; + + uint num_behind = m_num_node_states - insert_index; + uint num_to_move = (m_num_node_states < cMaxNodeStates) ? num_behind : (num_behind - 1); + if (num_to_move) + { + LZHAM_ASSERT((insert_index + 1 + num_to_move) <= cMaxNodeStates); + memmove( &m_node_states[insert_index + 1], &m_node_states[insert_index], sizeof(node_state) * num_to_move); + } + + node_state *pNew_node_state = &m_node_states[insert_index]; + pNew_node_state->m_parent_index = static_cast(parent_index); + pNew_node_state->m_parent_state_index = static_cast(parent_state_index); + pNew_node_state->m_lzdec = lzdec; + pNew_node_state->m_total_cost = total_cost; + pNew_node_state->m_total_complexity = total_complexity; + pNew_node_state->m_saved_state = trial_state; + + m_num_node_states = LZHAM_MIN(m_num_node_states + 1, static_cast(cMaxNodeStates)); + +#ifdef LZHAM_LZVERIFY + for (uint i = 0; i < (m_num_node_states - 1); ++i) + { + node_state &a = m_node_states[i]; + node_state &b = m_node_states[i + 1]; + LZHAM_VERIFY( + (a.m_total_cost < b.m_total_cost) || + ((a.m_total_cost == b.m_total_cost) && (a.m_total_complexity <= b.m_total_complexity)) ); + } +#endif + } + + // The "extreme" parser tracks the best node::cMaxNodeStates (4) candidate LZ decisions per lookahead character. + // This allows the compressor to make locally suboptimal decisions that ultimately result in a better parse. + // It assumes the input statistics are locally stationary over the input block to parse. + bool lzcompressor::extreme_parse(parse_thread_state &parse_state) + { + LZHAM_ASSERT(parse_state.m_bytes_to_match <= cMaxParseGraphNodes); + + parse_state.m_failed = false; + parse_state.m_emit_decisions_backwards = true; + + node *pNodes = parse_state.m_nodes; + for (uint i = 0; i <= cMaxParseGraphNodes; i++) + { + pNodes[i].clear(); + } + + state &approx_state = parse_state.m_initial_state; + + pNodes[0].m_num_node_states = 1; + node_state &first_node_state = pNodes[0].m_node_states[0]; + approx_state.save_partial_state(first_node_state.m_saved_state); + first_node_state.m_parent_index = -1; + first_node_state.m_parent_state_index = -1; + first_node_state.m_total_cost = 0; + first_node_state.m_total_complexity = 0; + + const uint bytes_to_parse = parse_state.m_bytes_to_match; + + const uint lookahead_start_ofs = m_accel.get_lookahead_pos() & m_accel.get_max_dict_size_mask(); + + uint cur_dict_ofs = parse_state.m_start_ofs; + uint cur_lookahead_ofs = cur_dict_ofs - lookahead_start_ofs; + uint cur_node_index = 0; + + enum { cMaxFullMatches = cMatchAccelMaxSupportedProbes }; + uint match_lens[cMaxFullMatches]; + uint match_distances[cMaxFullMatches]; + + bit_cost_t lzdec_bitcosts[cMaxMatchLen + 1]; + + node prev_lit_node; + prev_lit_node.clear(); + + while (cur_node_index < bytes_to_parse) + { + node* pCur_node = &pNodes[cur_node_index]; + + const uint max_admissable_match_len = LZHAM_MIN(static_cast(CLZBase::cMaxMatchLen), bytes_to_parse - cur_node_index); + const uint find_dict_size = m_accel.get_cur_dict_size() + cur_lookahead_ofs; + + const uint lit_pred0 = approx_state.get_pred_char(m_accel, cur_dict_ofs, 1); + + const uint8* pLookahead = &m_accel.m_dict[cur_dict_ofs]; + + // full matches + uint max_full_match_len = 0; + uint num_full_matches = 0; + uint len2_match_dist = 0; + + if (max_admissable_match_len >= CLZBase::cMinMatchLen) + { + const dict_match* pMatches = m_accel.find_matches(cur_lookahead_ofs); + if (pMatches) + { + for ( ; ; ) + { + uint match_len = pMatches->get_len(); + LZHAM_ASSERT((pMatches->get_dist() > 0) && (pMatches->get_dist() <= m_dict_size)); + match_len = LZHAM_MIN(match_len, max_admissable_match_len); + + if (match_len > max_full_match_len) + { + max_full_match_len = match_len; + + match_lens[num_full_matches] = match_len; + match_distances[num_full_matches] = pMatches->get_dist(); + num_full_matches++; + } + + if (pMatches->is_last()) + break; + pMatches++; + } + } + + len2_match_dist = m_accel.get_len2_match(cur_lookahead_ofs); + } + + for (uint cur_node_state_index = 0; cur_node_state_index < pCur_node->m_num_node_states; cur_node_state_index++) + { + node_state &cur_node_state = pCur_node->m_node_states[cur_node_state_index]; + + if (cur_node_index) + { + LZHAM_ASSERT(cur_node_state.m_parent_index >= 0); + + approx_state.restore_partial_state(cur_node_state.m_saved_state); + } + + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(lit_pred0, approx_state.m_cur_state); + + const bit_cost_t cur_node_total_cost = cur_node_state.m_total_cost; + const uint cur_node_total_complexity = cur_node_state.m_total_complexity; + + // rep matches + uint match_hist_max_len = 0; + uint match_hist_min_match_len = 1; + for (uint rep_match_index = 0; rep_match_index < cMatchHistSize; rep_match_index++) + { + uint hist_match_len = 0; + + uint dist = approx_state.m_match_hist[rep_match_index]; + if (dist <= find_dict_size) + { + const uint comp_pos = static_cast((m_accel.m_lookahead_pos + cur_lookahead_ofs - dist) & m_accel.m_max_dict_size_mask); + const uint8* pComp = &m_accel.m_dict[comp_pos]; + + for (hist_match_len = 0; hist_match_len < max_admissable_match_len; hist_match_len++) + if (pComp[hist_match_len] != pLookahead[hist_match_len]) + break; + } + + if (hist_match_len >= match_hist_min_match_len) + { + match_hist_max_len = math::maximum(match_hist_max_len, hist_match_len); + + approx_state.get_rep_match_costs(cur_dict_ofs, lzdec_bitcosts, rep_match_index, match_hist_min_match_len, hist_match_len, is_match_model_index); + + uint rep_match_total_complexity = cur_node_total_complexity + (cRep0Complexity + rep_match_index); + for (uint l = match_hist_min_match_len; l <= hist_match_len; l++) + { +#if LZHAM_VERIFY_MATCH_COSTS + { + lzdecision actual_dec(cur_dict_ofs, l, -((int)rep_match_index + 1)); + bit_cost_t actual_cost = approx_state.get_cost(*this, m_accel, actual_dec); + LZHAM_ASSERT(actual_cost == lzdec_bitcosts[l]); + } +#endif + node& dst_node = pCur_node[l]; + + bit_cost_t rep_match_total_cost = cur_node_total_cost + lzdec_bitcosts[l]; + + dst_node.add_state(cur_node_index, cur_node_state_index, lzdecision(cur_dict_ofs, l, -((int)rep_match_index + 1)), approx_state, rep_match_total_cost, rep_match_total_complexity); + } + } + + match_hist_min_match_len = CLZBase::cMinMatchLen; + } + + uint min_truncate_match_len = match_hist_max_len; + + // nearest len2 match + if (len2_match_dist) + { + lzdecision lzdec(cur_dict_ofs, 2, len2_match_dist); + bit_cost_t actual_cost = approx_state.get_cost(*this, m_accel, lzdec); + pCur_node[2].add_state(cur_node_index, cur_node_state_index, lzdec, approx_state, cur_node_total_cost + actual_cost, cur_node_total_complexity + cShortMatchComplexity); + + min_truncate_match_len = LZHAM_MAX(min_truncate_match_len, 2); + } + + // full matches + if (max_full_match_len > min_truncate_match_len) + { + uint prev_max_match_len = LZHAM_MAX(1, min_truncate_match_len); + for (uint full_match_index = 0; full_match_index < num_full_matches; full_match_index++) + { + uint end_len = match_lens[full_match_index]; + if (end_len <= min_truncate_match_len) + continue; + + uint start_len = prev_max_match_len + 1; + uint match_dist = match_distances[full_match_index]; + + LZHAM_ASSERT(start_len <= end_len); + + approx_state.get_full_match_costs(*this, cur_dict_ofs, lzdec_bitcosts, match_dist, start_len, end_len, is_match_model_index); + + for (uint l = start_len; l <= end_len; l++) + { + uint match_complexity = (l >= cLongMatchComplexityLenThresh) ? cLongMatchComplexity : cShortMatchComplexity; + +#if LZHAM_VERIFY_MATCH_COSTS + { + lzdecision actual_dec(cur_dict_ofs, l, match_dist); + bit_cost_t actual_cost = approx_state.get_cost(*this, m_accel, actual_dec); + LZHAM_ASSERT(actual_cost == lzdec_bitcosts[l]); + } +#endif + node& dst_node = pCur_node[l]; + + bit_cost_t match_total_cost = cur_node_total_cost + lzdec_bitcosts[l]; + uint match_total_complexity = cur_node_total_complexity + match_complexity; + + dst_node.add_state( cur_node_index, cur_node_state_index, lzdecision(cur_dict_ofs, l, match_dist), approx_state, match_total_cost, match_total_complexity); + } + + prev_max_match_len = end_len; + } + } + + // literal + bit_cost_t lit_cost = approx_state.get_lit_cost(m_accel, cur_dict_ofs, lit_pred0, is_match_model_index); + bit_cost_t lit_total_cost = cur_node_total_cost + lit_cost; + uint lit_total_complexity = cur_node_total_complexity + cLitComplexity; +#if LZHAM_VERIFY_MATCH_COSTS + { + lzdecision actual_dec(cur_dict_ofs, 0, 0); + bit_cost_t actual_cost = approx_state.get_cost(*this, m_accel, actual_dec); + LZHAM_ASSERT(actual_cost == lit_cost); + } +#endif + + pCur_node[1].add_state( cur_node_index, cur_node_state_index, lzdecision(cur_dict_ofs, 0, 0), approx_state, lit_total_cost, lit_total_complexity); + + } // cur_node_state_index + + cur_dict_ofs++; + cur_lookahead_ofs++; + cur_node_index++; + } + + // Now get the optimal decisions by starting from the goal node. + // m_best_decisions is filled backwards. + if (!parse_state.m_best_decisions.try_reserve(bytes_to_parse)) + { + parse_state.m_failed = true; + return false; + } + + bit_cost_t lowest_final_cost = cBitCostMax; //math::cNearlyInfinite; + int node_state_index = 0; + node_state *pLast_node_states = pNodes[bytes_to_parse].m_node_states; + for (uint i = 0; i < pNodes[bytes_to_parse].m_num_node_states; i++) + { + if (pLast_node_states[i].m_total_cost < lowest_final_cost) + { + lowest_final_cost = pLast_node_states[i].m_total_cost; + node_state_index = i; + } + } + + int node_index = bytes_to_parse; + lzdecision *pDst_dec = parse_state.m_best_decisions.get_ptr(); + do + { + LZHAM_ASSERT((node_index >= 0) && (node_index <= (int)cMaxParseGraphNodes)); + + node& cur_node = pNodes[node_index]; + const node_state &cur_node_state = cur_node.m_node_states[node_state_index]; + + *pDst_dec++ = cur_node_state.m_lzdec; + + node_index = cur_node_state.m_parent_index; + node_state_index = cur_node_state.m_parent_state_index; + + } while (node_index > 0); + + parse_state.m_best_decisions.try_resize(static_cast(pDst_dec - parse_state.m_best_decisions.get_ptr())); + + return true; + } + + // Parsing notes: + // The regular "optimal" parser only tracks the single cheapest candidate LZ decision per lookahead character. + // This function finds the shortest path through an extremely dense node graph using a streamlined/simplified Dijkstra's algorithm with some coding heuristics. + // Graph edges are LZ "decisions", cost is measured in fractional bits needed to code each graph edge, and graph nodes are lookahead characters. + // There is no need to track visited/unvisted nodes, or find the next cheapest unvisted node in each iteration. The search always proceeds sequentially, visiting each lookahead character in turn from left/right. + // The major CPU expense of this function is the complexity of LZ decision cost evaluation, so a lot of implementation effort is spent here reducing this overhead. + // To simplify the problem, it assumes the input statistics are locally stationary over the input block to parse. (Otherwise, it would need to store, track, and update + // unique symbol statistics for each lookahead character, which would be very costly.) + // This function always sequentially pushes "forward" the unvisited node horizon. This horizon frequently collapses to a single node, which guarantees that the shortest path through the + // graph must pass through this node. LZMA tracks cumulative bitprices relative to this node, while LZHAM currently always tracks cumulative bitprices relative to the first node in the lookahead buffer. + // In very early versions of LZHAM the parse was much more understandable (straight Dijkstra with almost no bit price optimizations or coding heuristics). + bool lzcompressor::optimal_parse(parse_thread_state &parse_state) + { + LZHAM_ASSERT(parse_state.m_bytes_to_match <= cMaxParseGraphNodes); + + parse_state.m_failed = false; + parse_state.m_emit_decisions_backwards = true; + + node_state *pNodes = reinterpret_cast(parse_state.m_nodes); + pNodes[0].m_parent_index = -1; + pNodes[0].m_total_cost = 0; + pNodes[0].m_total_complexity = 0; + +#if 0 + for (uint i = 1; i <= cMaxParseGraphNodes; i++) + { + pNodes[i].clear(); + } +#else + memset( &pNodes[1], 0xFF, cMaxParseGraphNodes * sizeof(node_state)); +#endif + + state &approx_state = parse_state.m_initial_state; + + const uint bytes_to_parse = parse_state.m_bytes_to_match; + + const uint lookahead_start_ofs = m_accel.get_lookahead_pos() & m_accel.get_max_dict_size_mask(); + + uint cur_dict_ofs = parse_state.m_start_ofs; + uint cur_lookahead_ofs = cur_dict_ofs - lookahead_start_ofs; + uint cur_node_index = 0; + + enum { cMaxFullMatches = cMatchAccelMaxSupportedProbes }; + uint match_lens[cMaxFullMatches]; + uint match_distances[cMaxFullMatches]; + + bit_cost_t lzdec_bitcosts[cMaxMatchLen + 1]; + + while (cur_node_index < bytes_to_parse) + { + node_state* pCur_node = &pNodes[cur_node_index]; + + const uint max_admissable_match_len = LZHAM_MIN(static_cast(CLZBase::cMaxMatchLen), bytes_to_parse - cur_node_index); + const uint find_dict_size = m_accel.m_cur_dict_size + cur_lookahead_ofs; + + if (cur_node_index) + { + LZHAM_ASSERT(pCur_node->m_parent_index >= 0); + + // Move to this node's state using the lowest cost LZ decision found. + approx_state.restore_partial_state(pCur_node->m_saved_state); + approx_state.partial_advance(pCur_node->m_lzdec); + } + + const bit_cost_t cur_node_total_cost = pCur_node->m_total_cost; + // This assert includes a fudge factor - make sure we don't overflow our scaled costs. + LZHAM_ASSERT((cBitCostMax - cur_node_total_cost) > (cBitCostScale * 64)); + const uint cur_node_total_complexity = pCur_node->m_total_complexity; + + const uint lit_pred0 = approx_state.get_pred_char(m_accel, cur_dict_ofs, 1); + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(lit_pred0, approx_state.m_cur_state); + + const uint8* pLookahead = &m_accel.m_dict[cur_dict_ofs]; + + // rep matches + uint match_hist_max_len = 0; + uint match_hist_min_match_len = 1; + for (uint rep_match_index = 0; rep_match_index < cMatchHistSize; rep_match_index++) + { + uint hist_match_len = 0; + + uint dist = approx_state.m_match_hist[rep_match_index]; + if (dist <= find_dict_size) + { + const uint comp_pos = static_cast((m_accel.m_lookahead_pos + cur_lookahead_ofs - dist) & m_accel.m_max_dict_size_mask); + const uint8* pComp = &m_accel.m_dict[comp_pos]; + + for (hist_match_len = 0; hist_match_len < max_admissable_match_len; hist_match_len++) + if (pComp[hist_match_len] != pLookahead[hist_match_len]) + break; + } + + if (hist_match_len >= match_hist_min_match_len) + { + match_hist_max_len = math::maximum(match_hist_max_len, hist_match_len); + + approx_state.get_rep_match_costs(cur_dict_ofs, lzdec_bitcosts, rep_match_index, match_hist_min_match_len, hist_match_len, is_match_model_index); + + uint rep_match_total_complexity = cur_node_total_complexity + (cRep0Complexity + rep_match_index); + for (uint l = match_hist_min_match_len; l <= hist_match_len; l++) + { +#if LZHAM_VERIFY_MATCH_COSTS + { + lzdecision actual_dec(cur_dict_ofs, l, -((int)rep_match_index + 1)); + bit_cost_t actual_cost = approx_state.get_cost(*this, m_accel, actual_dec); + LZHAM_ASSERT(actual_cost == lzdec_bitcosts[l]); + } +#endif + node_state& dst_node = pCur_node[l]; + + bit_cost_t rep_match_total_cost = cur_node_total_cost + lzdec_bitcosts[l]; + + if ((rep_match_total_cost > dst_node.m_total_cost) || ((rep_match_total_cost == dst_node.m_total_cost) && (rep_match_total_complexity >= dst_node.m_total_complexity))) + continue; + + dst_node.m_total_cost = rep_match_total_cost; + dst_node.m_total_complexity = rep_match_total_complexity; + dst_node.m_parent_index = (uint16)cur_node_index; + approx_state.save_partial_state(dst_node.m_saved_state); + dst_node.m_lzdec.init(cur_dict_ofs, l, -((int)rep_match_index + 1)); + dst_node.m_lzdec.m_len = l; + } + } + + match_hist_min_match_len = CLZBase::cMinMatchLen; + } + + uint max_match_len = match_hist_max_len; + + if (max_match_len >= m_settings.m_fast_bytes) + { + cur_dict_ofs += max_match_len; + cur_lookahead_ofs += max_match_len; + cur_node_index += max_match_len; + continue; + } + + // full matches + if (max_admissable_match_len >= CLZBase::cMinMatchLen) + { + uint num_full_matches = 0; + + if (match_hist_max_len < 2) + { + // Get the nearest len2 match if we didn't find a rep len2. + uint len2_match_dist = m_accel.get_len2_match(cur_lookahead_ofs); + if (len2_match_dist) + { + bit_cost_t cost = approx_state.get_len2_match_cost(*this, cur_dict_ofs, len2_match_dist, is_match_model_index); + +#if LZHAM_VERIFY_MATCH_COSTS + { + lzdecision actual_dec(cur_dict_ofs, 2, len2_match_dist); + bit_cost_t actual_cost = approx_state.get_cost(*this, m_accel, actual_dec); + LZHAM_ASSERT(actual_cost == cost); + } +#endif + + node_state& dst_node = pCur_node[2]; + + bit_cost_t match_total_cost = cur_node_total_cost + cost; + uint match_total_complexity = cur_node_total_complexity + cShortMatchComplexity; + + if ((match_total_cost < dst_node.m_total_cost) || ((match_total_cost == dst_node.m_total_cost) && (match_total_complexity < dst_node.m_total_complexity))) + { + dst_node.m_total_cost = match_total_cost; + dst_node.m_total_complexity = match_total_complexity; + dst_node.m_parent_index = (uint16)cur_node_index; + approx_state.save_partial_state(dst_node.m_saved_state); + dst_node.m_lzdec.init(cur_dict_ofs, 2, len2_match_dist); + } + + max_match_len = 2; + } + } + + const uint min_truncate_match_len = max_match_len; + + // Now get all full matches: the nearest matches at each match length. (Actually, we don't + // always get the nearest match. The match finder favors those matches which have the lowest value + // in the nibble of each match distance, all other things being equal, to help exploit how the lowest + // nibble of match distances is separately coded.) + const dict_match* pMatches = m_accel.find_matches(cur_lookahead_ofs); + if (pMatches) + { + for ( ; ; ) + { + uint match_len = pMatches->get_len(); + LZHAM_ASSERT((pMatches->get_dist() > 0) && (pMatches->get_dist() <= m_dict_size)); + match_len = LZHAM_MIN(match_len, max_admissable_match_len); + + if (match_len > max_match_len) + { + max_match_len = match_len; + + match_lens[num_full_matches] = match_len; + match_distances[num_full_matches] = pMatches->get_dist(); + num_full_matches++; + } + + if (pMatches->is_last()) + break; + pMatches++; + } + } + + if (num_full_matches) + { + uint prev_max_match_len = LZHAM_MAX(1, min_truncate_match_len); + for (uint full_match_index = 0; full_match_index < num_full_matches; full_match_index++) + { + uint start_len = prev_max_match_len + 1; + uint end_len = match_lens[full_match_index]; + uint match_dist = match_distances[full_match_index]; + + LZHAM_ASSERT(start_len <= end_len); + + approx_state.get_full_match_costs(*this, cur_dict_ofs, lzdec_bitcosts, match_dist, start_len, end_len, is_match_model_index); + + for (uint l = start_len; l <= end_len; l++) + { + uint match_complexity = (l >= cLongMatchComplexityLenThresh) ? cLongMatchComplexity : cShortMatchComplexity; + +#if LZHAM_VERIFY_MATCH_COSTS + { + lzdecision actual_dec(cur_dict_ofs, l, match_dist); + bit_cost_t actual_cost = approx_state.get_cost(*this, m_accel, actual_dec); + LZHAM_ASSERT(actual_cost == lzdec_bitcosts[l]); + } +#endif + node_state& dst_node = pCur_node[l]; + + bit_cost_t match_total_cost = cur_node_total_cost + lzdec_bitcosts[l]; + uint match_total_complexity = cur_node_total_complexity + match_complexity; + + if ((match_total_cost > dst_node.m_total_cost) || ((match_total_cost == dst_node.m_total_cost) && (match_total_complexity >= dst_node.m_total_complexity))) + continue; + + dst_node.m_total_cost = match_total_cost; + dst_node.m_total_complexity = match_total_complexity; + dst_node.m_parent_index = (uint16)cur_node_index; + approx_state.save_partial_state(dst_node.m_saved_state); + dst_node.m_lzdec.init(cur_dict_ofs, l, match_dist); + } + + prev_max_match_len = end_len; + } + } + } + + if (max_match_len >= m_settings.m_fast_bytes) + { + cur_dict_ofs += max_match_len; + cur_lookahead_ofs += max_match_len; + cur_node_index += max_match_len; + continue; + } + + // literal + bit_cost_t lit_cost = approx_state.get_lit_cost(m_accel, cur_dict_ofs, lit_pred0, is_match_model_index); + bit_cost_t lit_total_cost = cur_node_total_cost + lit_cost; + uint lit_total_complexity = cur_node_total_complexity + cLitComplexity; +#if LZHAM_VERIFY_MATCH_COSTS + { + lzdecision actual_dec(cur_dict_ofs, 0, 0); + bit_cost_t actual_cost = approx_state.get_cost(*this, m_accel, actual_dec); + LZHAM_ASSERT(actual_cost == lit_cost); + } +#endif + if ((lit_total_cost < pCur_node[1].m_total_cost) || ((lit_total_cost == pCur_node[1].m_total_cost) && (lit_total_complexity < pCur_node[1].m_total_complexity))) + { + pCur_node[1].m_total_cost = lit_total_cost; + pCur_node[1].m_total_complexity = lit_total_complexity; + pCur_node[1].m_parent_index = (int16)cur_node_index; + approx_state.save_partial_state(pCur_node[1].m_saved_state); + pCur_node[1].m_lzdec.init(cur_dict_ofs, 0, 0); + } + + cur_dict_ofs++; + cur_lookahead_ofs++; + cur_node_index++; + + } // graph search + + // Now get the optimal decisions by starting from the goal node. + // m_best_decisions is filled backwards. + if (!parse_state.m_best_decisions.try_reserve(bytes_to_parse)) + { + parse_state.m_failed = true; + return false; + } + + int node_index = bytes_to_parse; + lzdecision *pDst_dec = parse_state.m_best_decisions.get_ptr(); + do + { + LZHAM_ASSERT((node_index >= 0) && (node_index <= (int)cMaxParseGraphNodes)); + node_state& cur_node = pNodes[node_index]; + + *pDst_dec++ = cur_node.m_lzdec; + + node_index = cur_node.m_parent_index; + + } while (node_index > 0); + + parse_state.m_best_decisions.try_resize(static_cast(pDst_dec - parse_state.m_best_decisions.get_ptr())); + + return true; + } + + void lzcompressor::parse_job_callback(uint64 data, void* pData_ptr) + { + const uint parse_job_index = (uint)data; + scoped_perf_section parse_job_timer(cVarArgs, "parse_job_callback %u", parse_job_index); + + (void)pData_ptr; + + parse_thread_state &parse_state = m_parse_thread_state[parse_job_index]; + + if ((m_params.m_lzham_compress_flags & LZHAM_COMP_FLAG_EXTREME_PARSING) && (m_params.m_compression_level == cCompressionLevelUber)) + extreme_parse(parse_state); + else + optimal_parse(parse_state); + + LZHAM_MEMORY_EXPORT_BARRIER + + if (atomic_decrement32(&m_parse_jobs_remaining) == 0) + { + m_parse_jobs_complete.release(); + } + } + + // ofs is the absolute dictionary offset, must be >= the lookahead offset. + // TODO: Doesn't find len2 matches + int lzcompressor::enumerate_lz_decisions(uint ofs, const state& cur_state, lzham::vector& decisions, uint min_match_len, uint max_match_len) + { + LZHAM_ASSERT(min_match_len >= 1); + + uint start_ofs = m_accel.get_lookahead_pos() & m_accel.get_max_dict_size_mask(); + LZHAM_ASSERT(ofs >= start_ofs); + const uint lookahead_ofs = ofs - start_ofs; + + uint largest_index = 0; + uint largest_len; + bit_cost_t largest_cost; + + if (min_match_len <= 1) + { + if (!decisions.try_resize(1)) + return -1; + + lzpriced_decision& lit_dec = decisions[0]; + lit_dec.init(ofs, 0, 0, 0); + lit_dec.m_cost = cur_state.get_cost(*this, m_accel, lit_dec); + largest_cost = lit_dec.m_cost; + + largest_len = 1; + } + else + { + if (!decisions.try_resize(0)) + return -1; + + largest_len = 0; + largest_cost = cBitCostMax; + } + + uint match_hist_max_len = 0; + + // Add rep matches. + for (uint i = 0; i < cMatchHistSize; i++) + { + uint hist_match_len = m_accel.get_match_len(lookahead_ofs, cur_state.m_match_hist[i], max_match_len); + if (hist_match_len < min_match_len) + continue; + + if ( ((hist_match_len == 1) && (i == 0)) || (hist_match_len >= CLZBase::cMinMatchLen) ) + { + match_hist_max_len = math::maximum(match_hist_max_len, hist_match_len); + + lzpriced_decision dec(ofs, hist_match_len, -((int)i + 1)); + dec.m_cost = cur_state.get_cost(*this, m_accel, dec); + + if (!decisions.try_push_back(dec)) + return -1; + + if ( (hist_match_len > largest_len) || ((hist_match_len == largest_len) && (dec.m_cost < largest_cost)) ) + { + largest_index = decisions.size() - 1; + largest_len = hist_match_len; + largest_cost = dec.m_cost; + } + } + } + + // Now add full matches. + if ((max_match_len >= CLZBase::cMinMatchLen) && (match_hist_max_len < m_settings.m_fast_bytes)) + { + const dict_match* pMatches = m_accel.find_matches(lookahead_ofs); + + if (pMatches) + { + for ( ; ; ) + { + uint match_len = math::minimum(pMatches->get_len(), max_match_len); + LZHAM_ASSERT((pMatches->get_dist() > 0) && (pMatches->get_dist() <= m_dict_size)); + + // Full matches are very likely to be more expensive than rep matches of the same length, so don't bother evaluating them. + if ((match_len >= min_match_len) && (match_len > match_hist_max_len)) + { + if ((max_match_len > CLZBase::cMaxMatchLen) && (match_len == CLZBase::cMaxMatchLen)) + { + match_len = m_accel.get_match_len(lookahead_ofs, pMatches->get_dist(), max_match_len, CLZBase::cMaxMatchLen); + } + + lzpriced_decision dec(ofs, match_len, pMatches->get_dist()); + dec.m_cost = cur_state.get_cost(*this, m_accel, dec); + + if (!decisions.try_push_back(dec)) + return -1; + + if ( (match_len > largest_len) || ((match_len == largest_len) && (dec.get_cost() < largest_cost)) ) + { + largest_index = decisions.size() - 1; + largest_len = match_len; + largest_cost = dec.get_cost(); + } + } + if (pMatches->is_last()) + break; + pMatches++; + } + } + } + + return largest_index; + } + + bool lzcompressor::greedy_parse(parse_thread_state &parse_state) + { + parse_state.m_failed = true; + parse_state.m_emit_decisions_backwards = false; + + const uint bytes_to_parse = parse_state.m_bytes_to_match; + + const uint lookahead_start_ofs = m_accel.get_lookahead_pos() & m_accel.get_max_dict_size_mask(); + + uint cur_dict_ofs = parse_state.m_start_ofs; + uint cur_lookahead_ofs = cur_dict_ofs - lookahead_start_ofs; + uint cur_ofs = 0; + + state &approx_state = parse_state.m_initial_state; + + lzham::vector &decisions = parse_state.m_temp_decisions; + + if (!decisions.try_reserve(384)) + return false; + + if (!parse_state.m_best_decisions.try_resize(0)) + return false; + + while (cur_ofs < bytes_to_parse) + { + const uint max_admissable_match_len = LZHAM_MIN(static_cast(CLZBase::cMaxHugeMatchLen), bytes_to_parse - cur_ofs); + + int largest_dec_index = enumerate_lz_decisions(cur_dict_ofs, approx_state, decisions, 1, max_admissable_match_len); + if (largest_dec_index < 0) + return false; + + const lzpriced_decision &dec = decisions[largest_dec_index]; + + if (!parse_state.m_best_decisions.try_push_back(dec)) + return false; + + approx_state.partial_advance(dec); + + uint match_len = dec.get_len(); + LZHAM_ASSERT(match_len <= max_admissable_match_len); + cur_dict_ofs += match_len; + cur_lookahead_ofs += match_len; + cur_ofs += match_len; + + if (parse_state.m_best_decisions.size() >= parse_state.m_max_greedy_decisions) + { + parse_state.m_greedy_parse_total_bytes_coded = cur_ofs; + parse_state.m_greedy_parse_gave_up = true; + return false; + } + } + + parse_state.m_greedy_parse_total_bytes_coded = cur_ofs; + + LZHAM_ASSERT(cur_ofs == bytes_to_parse); + + parse_state.m_failed = false; + + return true; + } + + bool lzcompressor::compress_block(const void* pBuf, uint buf_len) + { + uint cur_ofs = 0; + uint bytes_remaining = buf_len; + while (bytes_remaining) + { + uint bytes_to_compress = math::minimum(m_accel.get_max_add_bytes(), bytes_remaining); + if (!compress_block_internal(static_cast(pBuf) + cur_ofs, bytes_to_compress)) + return false; + + cur_ofs += bytes_to_compress; + bytes_remaining -= bytes_to_compress; + } + return true; + } + + void lzcompressor::update_block_history(uint comp_size, uint src_size, uint ratio, bool raw_block, bool reset_update_rate) + { + block_history& cur_block_history = m_block_history[m_block_history_next]; + m_block_history_next++; + m_block_history_next %= cMaxBlockHistorySize; + + cur_block_history.m_comp_size = comp_size; + cur_block_history.m_src_size = src_size; + cur_block_history.m_ratio = ratio; + cur_block_history.m_raw_block = raw_block; + cur_block_history.m_reset_update_rate = reset_update_rate; + + m_block_history_size = LZHAM_MIN(m_block_history_size + 1, static_cast(cMaxBlockHistorySize)); + } + + uint lzcompressor::get_recent_block_ratio() + { + if (!m_block_history_size) + return 0; + + uint64 total_scaled_ratio = 0; + for (uint i = 0; i < m_block_history_size; i++) + total_scaled_ratio += m_block_history[i].m_ratio; + total_scaled_ratio /= m_block_history_size; + + return static_cast(total_scaled_ratio); + } + + uint lzcompressor::get_min_block_ratio() + { + if (!m_block_history_size) + return 0; + uint min_scaled_ratio = UINT_MAX; + for (uint i = 0; i < m_block_history_size; i++) + min_scaled_ratio = LZHAM_MIN(m_block_history[i].m_ratio, min_scaled_ratio); + return min_scaled_ratio; + } + + uint lzcompressor::get_max_block_ratio() + { + if (!m_block_history_size) + return 0; + uint max_scaled_ratio = 0; + for (uint i = 0; i < m_block_history_size; i++) + max_scaled_ratio = LZHAM_MAX(m_block_history[i].m_ratio, max_scaled_ratio); + return max_scaled_ratio; + } + + uint lzcompressor::get_total_recent_reset_update_rate() + { + uint total_resets = 0; + for (uint i = 0; i < m_block_history_size; i++) + total_resets += m_block_history[i].m_reset_update_rate; + return total_resets; + } + + bool lzcompressor::compress_block_internal(const void* pBuf, uint buf_len) + { + scoped_perf_section compress_block_timer(cVarArgs, "****** compress_block %u", m_block_index); + + LZHAM_ASSERT(pBuf); + LZHAM_ASSERT(buf_len <= m_params.m_block_size); + + LZHAM_ASSERT(m_src_size >= 0); + if (m_src_size < 0) + return false; + + m_src_size += buf_len; + + // Important: Don't do any expensive work until after add_bytes_begin() is called, to increase parallelism. + if (!m_accel.add_bytes_begin(buf_len, static_cast(pBuf))) + return false; + + m_start_of_block_state = m_state; + + m_src_adler32 = adler32(pBuf, buf_len, m_src_adler32); + m_src_crc32 = crc32(m_src_adler32, (const lzham_uint8*)pBuf, buf_len); + + m_block_start_dict_ofs = m_accel.get_lookahead_pos() & (m_accel.get_max_dict_size() - 1); + + uint cur_dict_ofs = m_block_start_dict_ofs; + + uint bytes_to_match = buf_len; + + if (!m_codec.start_encoding((buf_len * 9) / 8)) + return false; + + if (!m_block_index) + { + if (!send_configuration()) + return false; + } + +#ifdef LZHAM_LZDEBUG + m_codec.encode_bits(166, 12); +#endif + + if (!m_codec.encode_bits(cCompBlock, cBlockHeaderBits)) + return false; + + if (!m_codec.encode_arith_init()) + return false; + + m_state.start_of_block(m_accel, cur_dict_ofs, m_block_index); + + bool emit_reset_update_rate_command = false; + + // Determine if it makes sense to reset the Huffman table update frequency back to their initial (maximum) rates. + if ((m_block_history_size) && (m_params.m_lzham_compress_flags & LZHAM_COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO)) + { + const block_history& prev_block_history = m_block_history[m_block_history_next ? (m_block_history_next - 1) : (cMaxBlockHistorySize - 1)]; + + if (prev_block_history.m_raw_block) + emit_reset_update_rate_command = true; + else if (get_total_recent_reset_update_rate() == 0) + { + if (get_recent_block_ratio() > (cBlockHistoryCompRatioScale * 95U / 100U)) + emit_reset_update_rate_command = true; + else + { + uint recent_min_block_ratio = get_min_block_ratio(); + //uint recent_max_block_ratio = get_max_block_ratio(); + + // Compression ratio has recently dropped quite a bit - slam the table update rates back up. + if (prev_block_history.m_ratio > (recent_min_block_ratio * 3U) / 2U) + { + //printf("Emitting reset: %u %u\n", prev_block_history.m_ratio, recent_min_block_ratio); + emit_reset_update_rate_command = true; + } + } + } + } + + if (emit_reset_update_rate_command) + m_state.reset_update_rate(); + + m_codec.encode_bits(emit_reset_update_rate_command ? 1 : 0, cBlockFlushTypeBits); + + //coding_stats initial_stats(m_stats); + + uint initial_step = m_step; + + while (bytes_to_match) + { + const uint cAvgAcceptableGreedyMatchLen = 384; + if ((m_params.m_pSeed_bytes) && (bytes_to_match >= cAvgAcceptableGreedyMatchLen)) + { + parse_thread_state &greedy_parse_state = m_parse_thread_state[cMaxParseThreads]; + + greedy_parse_state.m_initial_state = m_state; + greedy_parse_state.m_initial_state.m_cur_ofs = cur_dict_ofs; + + greedy_parse_state.m_issue_reset_state_partial = false; + greedy_parse_state.m_start_ofs = cur_dict_ofs; + greedy_parse_state.m_bytes_to_match = LZHAM_MIN(bytes_to_match, static_cast(CLZBase::cMaxHugeMatchLen)); + + greedy_parse_state.m_max_greedy_decisions = LZHAM_MAX((bytes_to_match / cAvgAcceptableGreedyMatchLen), 2); + greedy_parse_state.m_greedy_parse_gave_up = false; + greedy_parse_state.m_greedy_parse_total_bytes_coded = 0; + + if (!greedy_parse(greedy_parse_state)) + { + if (!greedy_parse_state.m_greedy_parse_gave_up) + return false; + } + + uint num_greedy_decisions_to_code = 0; + + const lzham::vector &best_decisions = greedy_parse_state.m_best_decisions; + + if (!greedy_parse_state.m_greedy_parse_gave_up) + num_greedy_decisions_to_code = best_decisions.size(); + else + { + uint num_small_decisions = 0; + uint total_match_len = 0; + uint max_match_len = 0; + + uint i; + for (i = 0; i < best_decisions.size(); i++) + { + const lzdecision &dec = best_decisions[i]; + if (dec.get_len() <= CLZBase::cMaxMatchLen) + { + num_small_decisions++; + if (num_small_decisions > 16) + break; + } + + total_match_len += dec.get_len(); + max_match_len = LZHAM_MAX(max_match_len, dec.get_len()); + } + + if (max_match_len > CLZBase::cMaxMatchLen) + { + if ((total_match_len / i) >= cAvgAcceptableGreedyMatchLen) + { + num_greedy_decisions_to_code = i; + } + } + } + + if (num_greedy_decisions_to_code) + { + for (uint i = 0; i < num_greedy_decisions_to_code; i++) + { + LZHAM_ASSERT(best_decisions[i].m_pos == (int)cur_dict_ofs); + //LZHAM_ASSERT(i >= 0); + LZHAM_ASSERT(i < best_decisions.size()); + +#if LZHAM_UPDATE_STATS + bit_cost_t cost = m_state.get_cost(*this, m_accel, best_decisions[i]); + m_stats.update(best_decisions[i], m_state, m_accel, cost); +#endif + + if (!code_decision(best_decisions[i], cur_dict_ofs, bytes_to_match)) + return false; + } + + if ((!greedy_parse_state.m_greedy_parse_gave_up) || (!bytes_to_match)) + continue; + } + } + + uint num_parse_jobs = LZHAM_MIN(m_num_parse_threads, (bytes_to_match + cMaxParseGraphNodes - 1) / cMaxParseGraphNodes); + if ((m_params.m_lzham_compress_flags & LZHAM_COMP_FLAG_DETERMINISTIC_PARSING) == 0) + { + if (m_use_task_pool && m_accel.get_max_helper_threads()) + { + // Increase the number of active parse jobs as the match finder finishes up to keep CPU utilization up. + num_parse_jobs += m_accel.get_num_completed_helper_threads(); + num_parse_jobs = LZHAM_MIN(num_parse_jobs, cMaxParseThreads); + } + } + if (bytes_to_match < 1536) + num_parse_jobs = 1; + + // Reduce block size near the beginning of the file so statistical models get going a bit faster. + bool force_small_block = false; + if ((!m_block_index) && ((cur_dict_ofs - m_block_start_dict_ofs) < cMaxParseGraphNodes)) + { + num_parse_jobs = 1; + force_small_block = true; + } + + uint parse_thread_start_ofs = cur_dict_ofs; + uint parse_thread_total_size = LZHAM_MIN(bytes_to_match, cMaxParseGraphNodes * num_parse_jobs); + if (force_small_block) + { + parse_thread_total_size = LZHAM_MIN(parse_thread_total_size, 1536); + } + + uint parse_thread_remaining = parse_thread_total_size; + for (uint parse_thread_index = 0; parse_thread_index < num_parse_jobs; parse_thread_index++) + { + parse_thread_state &parse_thread = m_parse_thread_state[parse_thread_index]; + + parse_thread.m_initial_state = m_state; + parse_thread.m_initial_state.m_cur_ofs = parse_thread_start_ofs; + + if (parse_thread_index > 0) + { + parse_thread.m_initial_state.reset_state_partial(); + parse_thread.m_issue_reset_state_partial = true; + } + else + { + parse_thread.m_issue_reset_state_partial = false; + } + + parse_thread.m_start_ofs = parse_thread_start_ofs; + if (parse_thread_index == (num_parse_jobs - 1)) + parse_thread.m_bytes_to_match = parse_thread_remaining; + else + parse_thread.m_bytes_to_match = parse_thread_total_size / num_parse_jobs; + + parse_thread.m_bytes_to_match = LZHAM_MIN(parse_thread.m_bytes_to_match, cMaxParseGraphNodes); + LZHAM_ASSERT(parse_thread.m_bytes_to_match > 0); + + parse_thread.m_max_greedy_decisions = UINT_MAX; + parse_thread.m_greedy_parse_gave_up = false; + + parse_thread_start_ofs += parse_thread.m_bytes_to_match; + parse_thread_remaining -= parse_thread.m_bytes_to_match; + } + + { + scoped_perf_section parse_timer("parsing"); + + if ((m_use_task_pool) && (num_parse_jobs > 1)) + { + m_parse_jobs_remaining = num_parse_jobs; + + { + scoped_perf_section queue_task_timer("queuing parse tasks"); + + if (!m_params.m_pTask_pool->queue_multiple_object_tasks(this, &lzcompressor::parse_job_callback, 1, num_parse_jobs - 1)) + return false; + } + + parse_job_callback(0, NULL); + + { + scoped_perf_section wait_timer("waiting for jobs"); + + m_parse_jobs_complete.wait(); + } + } + else + { + m_parse_jobs_remaining = INT_MAX; + for (uint parse_thread_index = 0; parse_thread_index < num_parse_jobs; parse_thread_index++) + { + parse_job_callback(parse_thread_index, NULL); + } + } + } + + { + scoped_perf_section coding_timer("coding"); + + for (uint parse_thread_index = 0; parse_thread_index < num_parse_jobs; parse_thread_index++) + { + parse_thread_state &parse_thread = m_parse_thread_state[parse_thread_index]; + if (parse_thread.m_failed) + return false; + + const lzham::vector &best_decisions = parse_thread.m_best_decisions; + + if (parse_thread.m_issue_reset_state_partial) + { + if (!m_state.encode_reset_state_partial(m_codec, m_accel, cur_dict_ofs)) + return false; + m_step++; + } + + if (best_decisions.size()) + { + int i = 0; + int end_dec_index = static_cast(best_decisions.size()) - 1; + int dec_step = 1; + if (parse_thread.m_emit_decisions_backwards) + { + i = static_cast(best_decisions.size()) - 1; + end_dec_index = 0; + dec_step = -1; + LZHAM_ASSERT(best_decisions.back().m_pos == (int)parse_thread.m_start_ofs); + } + else + { + LZHAM_ASSERT(best_decisions.front().m_pos == (int)parse_thread.m_start_ofs); + } + + // Loop rearranged to avoid bad x64 codegen problem with MSVC2008. + for ( ; ; ) + { + LZHAM_ASSERT(best_decisions[i].m_pos == (int)cur_dict_ofs); + LZHAM_ASSERT(i >= 0); + LZHAM_ASSERT(i < (int)best_decisions.size()); + +#if LZHAM_UPDATE_STATS + bit_cost_t cost = m_state.get_cost(*this, m_accel, best_decisions[i]); + m_stats.update(best_decisions[i], m_state, m_accel, cost); + //m_state.print(m_codec, *this, m_accel, best_decisions[i]); +#endif + + if (!code_decision(best_decisions[i], cur_dict_ofs, bytes_to_match)) + return false; + if (i == end_dec_index) + break; + i += dec_step; + } + + LZHAM_NOTE_UNUSED(i); + } + + LZHAM_ASSERT(cur_dict_ofs == parse_thread.m_start_ofs + parse_thread.m_bytes_to_match); + + } // parse_thread_index + + } + } + + { + scoped_perf_section add_bytes_timer("add_bytes_end"); + m_accel.add_bytes_end(); + } + + if (!m_state.encode_eob(m_codec, m_accel, cur_dict_ofs)) + return false; + +#ifdef LZHAM_LZDEBUG + if (!m_codec.encode_bits(366, 12)) return false; +#endif + + { + scoped_perf_section stop_encoding_timer("stop_encoding"); + if (!m_codec.stop_encoding(true)) return false; + } + + // Coded the entire block - now see if it makes more sense to just send a raw/uncompressed block. + + uint compressed_size = m_codec.get_encoding_buf().size(); + LZHAM_NOTE_UNUSED(compressed_size); + + bool used_raw_block = false; + +#if !LZHAM_FORCE_ALL_RAW_BLOCKS + #if (defined(LZHAM_DISABLE_RAW_BLOCKS) || defined(LZHAM_LZDEBUG)) + if (0) + #else + if (compressed_size >= buf_len) + #endif +#endif + { + // Failed to compress the block, so go back to our original state and just code a raw block. + m_state = m_start_of_block_state; + m_step = initial_step; + //m_stats = initial_stats; + + m_codec.reset(); + + if (!m_codec.start_encoding(buf_len + 16)) + return false; + + if (!m_block_index) + { + if (!send_configuration()) + return false; + } + +#ifdef LZHAM_LZDEBUG + if (!m_codec.encode_bits(166, 12)) + return false; +#endif + + if (!m_codec.encode_bits(cRawBlock, cBlockHeaderBits)) + return false; + + LZHAM_ASSERT(buf_len <= 0x1000000); + if (!m_codec.encode_bits(buf_len - 1, 24)) + return false; + + // Write buf len check bits, to help increase the probability of detecting corrupted data more early. + uint buf_len0 = (buf_len - 1) & 0xFF; + uint buf_len1 = ((buf_len - 1) >> 8) & 0xFF; + uint buf_len2 = ((buf_len - 1) >> 16) & 0xFF; + if (!m_codec.encode_bits((buf_len0 ^ buf_len1) ^ buf_len2, 8)) + return false; + + if (!m_codec.encode_align_to_byte()) + return false; + + const uint8* pSrc = m_accel.get_ptr(m_block_start_dict_ofs); + + for (uint i = 0; i < buf_len; i++) + { + if (!m_codec.encode_bits(*pSrc++, 8)) + return false; + } + + if (!m_codec.stop_encoding(true)) + return false; + + used_raw_block = true; + emit_reset_update_rate_command = false; + } + + uint comp_size = m_codec.get_encoding_buf().size(); + uint scaled_ratio = (comp_size * cBlockHistoryCompRatioScale) / buf_len; + update_block_history(comp_size, buf_len, scaled_ratio, used_raw_block, emit_reset_update_rate_command); + + //printf("\n%u, %u, %u, %u\n", m_block_index, 500*emit_reset_update_rate_command, scaled_ratio, get_recent_block_ratio()); + + { + scoped_perf_section append_timer("append"); + + if (m_comp_buf.empty()) + { + m_comp_buf.swap(m_codec.get_encoding_buf()); + } + else + { + if (!m_comp_buf.append(m_codec.get_encoding_buf())) + return false; + } + } +#if LZHAM_UPDATE_STATS + LZHAM_VERIFY(m_stats.m_total_bytes == m_src_size); + if (emit_reset_update_rate_command) + m_stats.m_total_update_rate_resets++; +#endif + + m_block_index++; + + return true; + } + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.h b/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.h new file mode 100644 index 00000000..b2991570 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.h @@ -0,0 +1,481 @@ +// File: lzham_lzcomp_internal.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once +#include "../include/lzham_match_accel.h" +#include "../include/lzham_symbol_codec.h" +#include "../include/lzham_lzbase.h" + +namespace lzham +{ + typedef lzham::vector byte_vec; + + const uint cMaxParseGraphNodes = 3072; + const uint cMaxParseThreads = 8; + + enum compression_level + { + cCompressionLevelFastest, + cCompressionLevelFaster, + cCompressionLevelDefault, + cCompressionLevelBetter, + cCompressionLevelUber, + + cCompressionLevelCount + }; + + struct comp_settings + { + uint m_fast_bytes; + bool m_fast_adaptive_huffman_updating; + bool m_use_polar_codes; + uint m_match_accel_max_matches_per_probe; + uint m_match_accel_max_probes; + }; + + class lzcompressor : public CLZBase + { + public: + lzcompressor(); + + struct init_params + { + enum + { + cMinDictSizeLog2 = CLZBase::cMinDictSizeLog2, + cMaxDictSizeLog2 = CLZBase::cMaxDictSizeLog2, + cDefaultBlockSize = 1024U*512U + }; + + init_params() : + m_pTask_pool(NULL), + m_max_helper_threads(0), + m_compression_level(cCompressionLevelDefault), + m_dict_size_log2(22), + m_block_size(cDefaultBlockSize), + m_num_cachelines(0), + m_cacheline_size(0), + m_lzham_compress_flags(0), + m_pSeed_bytes(0), + m_num_seed_bytes(0) + { + } + + task_pool* m_pTask_pool; + uint m_max_helper_threads; + + compression_level m_compression_level; + uint m_dict_size_log2; + + uint m_block_size; + + uint m_num_cachelines; + uint m_cacheline_size; + + uint m_lzham_compress_flags; + + const void *m_pSeed_bytes; + uint m_num_seed_bytes; + }; + + bool init(const init_params& params); + void clear(); + + // sync, or sync+dictionary flush + bool flush(lzham_flush_t flush_type); + + bool reset(); + + bool put_bytes(const void* pBuf, uint buf_len); + + const byte_vec& get_compressed_data() const { return m_comp_buf; } + byte_vec& get_compressed_data() { return m_comp_buf; } + + uint32 get_src_adler32() const { return m_src_adler32; } + uint32 get_src_crc32() const { return m_src_crc32; } + + private: + class state; + + enum + { + cLitComplexity = 1, + cRep0Complexity = 2, + cRep3Complexity = 5, + + cLongMatchComplexity = 6, + cLongMatchComplexityLenThresh = 9, + + cShortMatchComplexity = 7 + }; + + struct lzdecision + { + int m_pos; // dict position where decision was evaluated + int m_len; // 0 if literal, 1+ if match + int m_dist; // <0 if match rep, else >=1 is match dist + + inline lzdecision() { } + inline lzdecision(int pos, int len, int dist) : m_pos(pos), m_len(len), m_dist(dist) { } + + inline void init(int pos, int len, int dist) { m_pos = pos; m_len = len; m_dist = dist; } + + inline bool is_lit() const { return !m_len; } + inline bool is_match() const { return m_len > 0; } // may be a rep or full match + inline bool is_full_match() const { return (m_len > 0) && (m_dist >= 1); } + inline uint get_len() const { return math::maximum(m_len, 1); } + inline bool is_rep() const { return m_dist < 0; } + inline bool is_rep0() const { return m_dist == -1; } + + uint get_match_dist(const state& s) const; + + inline uint get_complexity() const + { + if (is_lit()) + return cLitComplexity; + else if (is_rep()) + { + LZHAM_ASSUME(cRep0Complexity == 2); + return 1 + -m_dist; // 2, 3, 4, or 5 + } + else if (get_len() >= cLongMatchComplexityLenThresh) + return cLongMatchComplexity; + else + return cShortMatchComplexity; + } + + inline uint get_min_codable_len() const + { + if (is_lit() || is_rep0()) + return 1; + else + return CLZBase::cMinMatchLen; + } + }; + + struct lzpriced_decision : lzdecision + { + lzpriced_decision() { } + + inline lzpriced_decision(int pos, int len, int dist) : lzdecision(pos, len, dist) { } + inline lzpriced_decision(int pos, int len, int dist, bit_cost_t cost) : lzdecision(pos, len, dist), m_cost(cost) { } + + inline void init(int pos, int len, int dist, bit_cost_t cost) { lzdecision::init(pos, len, dist); m_cost = cost; } + + inline bit_cost_t get_cost() const { return m_cost; } + + bit_cost_t m_cost; + }; + + struct state_base + { + uint m_cur_ofs; + uint m_cur_state; + uint m_match_hist[CLZBase::cMatchHistSize]; + + inline bool operator== (const state_base &rhs) const + { + if (m_cur_state != rhs.m_cur_state) + return false; + for (uint i = 0; i < CLZBase::cMatchHistSize; i++) + if (m_match_hist[i] != rhs.m_match_hist[i]) + return false; + return true; + } + + void partial_advance(const lzdecision& lzdec); + + inline void save_partial_state(state_base& dst) + { + dst.m_cur_ofs = m_cur_ofs; + dst.m_cur_state = m_cur_state; + memcpy(dst.m_match_hist, m_match_hist, sizeof(m_match_hist)); + } + + inline void restore_partial_state(const state_base& src) + { + m_cur_ofs = src.m_cur_ofs; + m_cur_state = src.m_cur_state; + memcpy(m_match_hist, src.m_match_hist, sizeof(m_match_hist)); + } + }; + + class state : public state_base + { + public: + state(); + + void clear(); + + bool init(CLZBase& lzbase, bool fast_adaptive_huffman_updating, bool use_polar_codes); + void reset(); + + bit_cost_t get_cost(CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec) const; + bit_cost_t get_len2_match_cost(CLZBase& lzbase, uint dict_pos, uint len2_match_dist, uint is_match_model_index); + bit_cost_t get_lit_cost(const search_accelerator& dict, uint dict_pos, uint lit_pred0, uint is_match_model_index) const; + + // Returns actual cost. + void get_rep_match_costs(uint dict_pos, bit_cost_t *pBitcosts, uint match_hist_index, int min_len, int max_len, uint is_match_model_index) const; + void get_full_match_costs(CLZBase& lzbase, uint dict_pos, bit_cost_t *pBitcosts, uint match_dist, int min_len, int max_len, uint is_match_model_index) const; + + bit_cost_t update_stats(CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec); + + bool advance(CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec); + bool encode(symbol_codec& codec, CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec); + + void print(symbol_codec& codec, CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec); + + bool encode_eob(symbol_codec& codec, const search_accelerator& dict, uint dict_pos); + bool encode_reset_state_partial(symbol_codec& codec, const search_accelerator& dict, uint dict_pos); + + void update_match_hist(uint match_dist); + int find_match_dist(uint match_hist) const; + + void reset_state_partial(); + void start_of_block(const search_accelerator& dict, uint cur_ofs, uint block_index); + + void reset_update_rate(); + + uint get_pred_char(const search_accelerator& dict, int pos, int backward_ofs) const; + + inline bool will_reference_last_match(const lzdecision& lzdec) const + { + return (!lzdec.is_match()) && (m_cur_state >= CLZBase::cNumLitStates); + } + + uint m_block_start_dict_ofs; + + adaptive_bit_model m_is_match_model[CLZBase::cNumStates * (1 << CLZBase::cNumIsMatchContextBits)]; + + adaptive_bit_model m_is_rep_model[CLZBase::cNumStates]; + adaptive_bit_model m_is_rep0_model[CLZBase::cNumStates]; + adaptive_bit_model m_is_rep0_single_byte_model[CLZBase::cNumStates]; + adaptive_bit_model m_is_rep1_model[CLZBase::cNumStates]; + adaptive_bit_model m_is_rep2_model[CLZBase::cNumStates]; + +#if LZHAM_USE_ALL_ARITHMETIC_CODING + typedef adaptive_arith_data_model sym_data_model; +#else + typedef quasi_adaptive_huffman_data_model sym_data_model; +#endif + + sym_data_model m_lit_table[1 << CLZBase::cNumLitPredBits]; + sym_data_model m_delta_lit_table[1 << CLZBase::cNumDeltaLitPredBits]; + + sym_data_model m_main_table; + sym_data_model m_rep_len_table[2]; + sym_data_model m_large_len_table[2]; + sym_data_model m_dist_lsb_table; + }; + + class tracked_stat + { + public: + tracked_stat() { clear(); } + + void clear() { m_num = 0; m_total = 0.0f; m_total2 = 0.0f; m_min_val = 9e+99; m_max_val = -9e+99; } + + void update(double val) { m_num++; m_total += val; m_total2 += val * val; m_min_val = LZHAM_MIN(m_min_val, val); m_max_val = LZHAM_MAX(m_max_val, val); } + + tracked_stat &operator += (double val) { update(val); return *this; } + operator double() const { return m_total; } + + uint64 get_number_of_values() { return m_num; } + uint32 get_number_of_values32() { return static_cast(LZHAM_MIN(UINT_MAX, m_num)); } + double get_total() const { return m_total; } + double get_average() const { return m_num ? m_total / m_num : 0.0f; }; + double get_std_dev() const { return m_num ? sqrt( m_num * m_total2 - m_total * m_total ) / m_num: 0.0f; } + double get_min_val() const { return m_num ? m_min_val : 0.0f; } + double get_max_val() const { return m_num ? m_max_val : 0.0f; } + + private: + uint64 m_num; + double m_total; + double m_total2; + double m_min_val; + double m_max_val; + }; + + struct coding_stats + { + coding_stats() { clear(); } + + void clear(); + + void update(const lzdecision& lzdec, const state& cur_state, const search_accelerator& dict, bit_cost_t cost); + void print(); + + uint m_total_bytes; + uint m_total_contexts; + double m_total_cost; + + tracked_stat m_context_stats; + + double m_total_match_bits_cost; + double m_worst_match_bits_cost; + double m_total_is_match0_bits_cost; + double m_total_is_match1_bits_cost; + + uint m_total_truncated_matches; + uint m_match_truncation_len_hist[CLZBase::cMaxMatchLen + 1]; + uint m_match_truncation_hist[CLZBase::cMaxMatchLen + 1]; + uint m_match_type_truncation_hist[CLZBase::cNumStates][5]; + uint m_match_type_was_not_truncated_hist[CLZBase::cNumStates][5]; + + uint m_total_nonmatches; + uint m_total_matches; + + tracked_stat m_lit_stats; + tracked_stat m_delta_lit_stats; + + tracked_stat m_rep_stats[CLZBase::cMatchHistSize]; + tracked_stat m_rep0_len1_stats; + tracked_stat m_rep0_len2_plus_stats; + + tracked_stat m_full_match_stats[cMaxMatchLen + 1]; + + uint m_total_far_len2_matches; + uint m_total_near_len2_matches; + + uint m_total_update_rate_resets; + + uint m_max_len2_dist; + }; + + init_params m_params; + comp_settings m_settings; + + int64 m_src_size; + uint32 m_src_adler32; + uint32 m_src_crc32; + + search_accelerator m_accel; + + symbol_codec m_codec; + + coding_stats m_stats; + + byte_vec m_block_buf; + byte_vec m_comp_buf; + + uint m_step; + + uint m_block_start_dict_ofs; + + uint m_block_index; + + bool m_finished; + bool m_use_task_pool; + + struct node_state + { + LZHAM_FORCE_INLINE void clear() + { + m_total_cost = cBitCostMax; //math::cNearlyInfinite; + m_total_complexity = UINT_MAX; + } + + // the lzdecision that led from parent to this node_state + lzdecision m_lzdec; + + // This is either the state of the parent node (optimal parsing), or the state of the child node (extreme parsing). + state::state_base m_saved_state; + + // Total cost to arrive at this node state. + bit_cost_t m_total_cost; + uint m_total_complexity; + + // Parent node index. + int16 m_parent_index; + + // Parent node state index (only valid when extreme parsing). + int8 m_parent_state_index; + }; + + struct node + { + LZHAM_FORCE_INLINE void clear() + { + m_num_node_states = 0; + } + + uint m_num_node_states; + enum { cMaxNodeStates = 4 }; + node_state m_node_states[cMaxNodeStates]; + + void add_state(int parent_index, int parent_state_index, const lzdecision &lzdec, state &parent_state, bit_cost_t total_cost, uint total_complexity); + }; + + state m_start_of_block_state; // state at start of block + + state m_state; // main thread's current coding state + + struct raw_parse_thread_state + { + uint m_start_ofs; + uint m_bytes_to_match; + + state m_initial_state; + + node m_nodes[cMaxParseGraphNodes + 1]; + + lzham::vector m_best_decisions; + bool m_emit_decisions_backwards; + + lzham::vector m_temp_decisions; + + uint m_max_greedy_decisions; + uint m_greedy_parse_total_bytes_coded; + bool m_greedy_parse_gave_up; + + bool m_issue_reset_state_partial; + bool m_failed; + }; + + struct parse_thread_state : raw_parse_thread_state + { + uint8 m_unused_alignment_array[128 - (sizeof(raw_parse_thread_state) & 127)]; + }; + + uint m_num_parse_threads; + parse_thread_state m_parse_thread_state[cMaxParseThreads + 1]; // +1 extra for the greedy parser thread (only used for delta compression) + + volatile atomic32_t m_parse_jobs_remaining; + semaphore m_parse_jobs_complete; + + enum { cMaxBlockHistorySize = 6, cBlockHistoryCompRatioScale = 1000U }; + struct block_history + { + uint m_comp_size; + uint m_src_size; + uint m_ratio; + bool m_raw_block; + bool m_reset_update_rate; + }; + block_history m_block_history[cMaxBlockHistorySize]; + uint m_block_history_size; + uint m_block_history_next; + void update_block_history(uint comp_size, uint src_size, uint ratio, bool raw_block, bool reset_update_rate); + uint get_recent_block_ratio(); + uint get_min_block_ratio(); + uint get_max_block_ratio(); + uint get_total_recent_reset_update_rate(); + + bool send_zlib_header(); + bool init_seed_bytes(); + bool send_final_block(); + bool send_configuration(); + bool extreme_parse(parse_thread_state &parse_state); + bool optimal_parse(parse_thread_state &parse_state); + int enumerate_lz_decisions(uint ofs, const state& cur_state, lzham::vector& decisions, uint min_match_len, uint max_match_len); + bool greedy_parse(parse_thread_state &parse_state); + void parse_job_callback(uint64 data, void* pData_ptr); + bool compress_block(const void* pBuf, uint buf_len); + bool compress_block_internal(const void* pBuf, uint buf_len); + bool code_decision(lzdecision lzdec, uint& cur_ofs, uint& bytes_to_match); + bool send_sync_block(lzham_flush_t flush_type); + }; + +} // namespace lzham + + + diff --git a/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_state.cpp b/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_state.cpp new file mode 100644 index 00000000..b6d6798c --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_state.cpp @@ -0,0 +1,1463 @@ +// File: lzham_lzcomp_state.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "../include/lzham_core.h" +#include "lzham_lzcomp_internal.h" + +namespace lzham +{ + static uint get_huge_match_code_len(uint len) + { + LZHAM_ASSERT((len > CLZBase::cMaxMatchLen) && (len <= CLZBase::cMaxHugeMatchLen)); + len -= (CLZBase::cMaxMatchLen + 1); + + if (len < 256) + return 1 + 8; + else if (len < (256 + 1024)) + return 2 + 10; + else if (len < (256 + 1024 + 4096)) + return 3 + 12; + else + return 3 + 16; + } + + static uint get_huge_match_code_bits(uint len) + { + LZHAM_ASSERT((len > CLZBase::cMaxMatchLen) && (len <= CLZBase::cMaxHugeMatchLen)); + len -= (CLZBase::cMaxMatchLen + 1); + + uint c; + if (len < 256) + c = len; + else if (len < (256 + 1024)) + { + uint r = (len - 256); + LZHAM_ASSERT(r <= 1023); + c = r | (2 << 10); + } + else if (len < (256 + 1024 + 4096)) + { + uint r = (len - (256 + 1024)); + LZHAM_ASSERT(r <= 4095); + c = r | (6 << 12); + } + else + { + uint r = (len - (256 + 1024 + 4096)); + LZHAM_ASSERT(r <= 65535); + c = r | (7 << 16); + } + + return c; + } + + uint lzcompressor::lzdecision::get_match_dist(const state& cur_state) const + { + if (!is_match()) + return 0; + else if (is_rep()) + { + int index = -m_dist - 1; + LZHAM_ASSERT(index < CLZBase::cMatchHistSize); + return cur_state.m_match_hist[index]; + } + else + return m_dist; + } + + lzcompressor::state::state() + { + clear(); + } + + void lzcompressor::state::clear() + { + m_cur_ofs = 0; + m_cur_state = 0; + m_block_start_dict_ofs = 0; + + for (uint i = 0; i < 2; i++) + { + m_rep_len_table[i].clear(); + m_large_len_table[i].clear(); + } + m_main_table.clear(); + m_dist_lsb_table.clear(); + + for (uint i = 0; i < (1 << CLZBase::cNumLitPredBits); i++) + m_lit_table[i].clear(); + + for (uint i = 0; i < (1 << CLZBase::cNumDeltaLitPredBits); i++) + m_delta_lit_table[i].clear(); + + m_match_hist[0] = 1; + m_match_hist[1] = 1; + m_match_hist[2] = 1; + m_match_hist[3] = 1; + } + + void lzcompressor::state::reset() + { + m_cur_ofs = 0; + m_cur_state = 0; + m_block_start_dict_ofs = 0; + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_match_model); i++) + m_is_match_model[i].clear(); + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_rep_model); i++) + m_is_rep_model[i].clear(); + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_rep0_model); i++) + m_is_rep0_model[i].clear(); + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_rep0_single_byte_model); i++) + m_is_rep0_single_byte_model[i].clear(); + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_rep1_model); i++) + m_is_rep1_model[i].clear(); + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_rep2_model); i++) + m_is_rep2_model[i].clear(); + + for (uint i = 0; i < 2; i++) + { + m_rep_len_table[i].reset(); + m_large_len_table[i].reset(); + } + m_main_table.reset(); + m_dist_lsb_table.reset(); + + // Only reset the first table in the array, then just clone it to the others because they're all the same when reset. (This is ~9x faster than resetting each one.) + m_lit_table[0].reset(); + for (uint i = 1; i < LZHAM_ARRAY_SIZE(m_lit_table); i++) + m_lit_table[i] = m_lit_table[0]; + + m_delta_lit_table[0].reset(); + for (uint i = 1; i < LZHAM_ARRAY_SIZE(m_delta_lit_table); i++) + m_delta_lit_table[i] = m_delta_lit_table[0]; + + m_match_hist[0] = 1; + m_match_hist[1] = 1; + m_match_hist[2] = 1; + m_match_hist[3] = 1; + } + + bool lzcompressor::state::init(CLZBase& lzbase, bool fast_adaptive_huffman_updating, bool use_polar_codes) + { + m_cur_ofs = 0; + m_cur_state = 0; + + if (!m_rep_len_table[0].init(true, CLZBase::cNumHugeMatchCodes + (CLZBase::cMaxMatchLen - CLZBase::cMinMatchLen + 1), fast_adaptive_huffman_updating, use_polar_codes)) + return false; + if (!m_rep_len_table[1].assign(m_rep_len_table[0])) + return false; + + if (!m_large_len_table[0].init(true, CLZBase::cNumHugeMatchCodes + CLZBase::cLZXNumSecondaryLengths, fast_adaptive_huffman_updating, use_polar_codes)) + return false; + if (!m_large_len_table[1].assign(m_large_len_table[0])) + return false; + + if (!m_main_table.init(true, CLZBase::cLZXNumSpecialLengths + (lzbase.m_num_lzx_slots - CLZBase::cLZXLowestUsableMatchSlot) * 8, fast_adaptive_huffman_updating, use_polar_codes)) + return false; + if (!m_dist_lsb_table.init(true, 16, fast_adaptive_huffman_updating, use_polar_codes)) + return false; + + if (!m_lit_table[0].init(true, 256, fast_adaptive_huffman_updating, use_polar_codes)) + return false; + for (uint i = 1; i < (1 << CLZBase::cNumLitPredBits); i++) + if (!m_lit_table[i].assign(m_lit_table[0])) + return false; + + if (!m_delta_lit_table[0].init(true, 256, fast_adaptive_huffman_updating, use_polar_codes)) + return false; + for (uint i = 1; i < (1 << CLZBase::cNumDeltaLitPredBits); i++) + if (!m_delta_lit_table[i].assign(m_delta_lit_table[0])) + return false; + + m_match_hist[0] = 1; + m_match_hist[1] = 1; + m_match_hist[2] = 1; + m_match_hist[3] = 1; + + return true; + } + + void lzcompressor::state_base::partial_advance(const lzdecision& lzdec) + { + if (lzdec.m_len == 0) + { + if (m_cur_state < 4) m_cur_state = 0; else if (m_cur_state < 10) m_cur_state -= 3; else m_cur_state -= 6; + } + else + { + if (lzdec.m_dist < 0) + { + int match_hist_index = -lzdec.m_dist - 1; + + if (!match_hist_index) + { + if (lzdec.m_len == 1) + { + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 9 : 11; + } + else + { + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 8 : 11; + } + } + else + { + if (match_hist_index == 1) + { + std::swap(m_match_hist[0], m_match_hist[1]); + } + else if (match_hist_index == 2) + { + int dist = m_match_hist[2]; + m_match_hist[2] = m_match_hist[1]; + m_match_hist[1] = m_match_hist[0]; + m_match_hist[0] = dist; + } + else + { + LZHAM_ASSERT(match_hist_index == 3); + + int dist = m_match_hist[3]; + m_match_hist[3] = m_match_hist[2]; + m_match_hist[2] = m_match_hist[1]; + m_match_hist[1] = m_match_hist[0]; + m_match_hist[0] = dist; + } + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 8 : 11; + } + } + else + { + // full + LZHAM_ASSUME(CLZBase::cMatchHistSize == 4); + m_match_hist[3] = m_match_hist[2]; + m_match_hist[2] = m_match_hist[1]; + m_match_hist[1] = m_match_hist[0]; + m_match_hist[0] = lzdec.m_dist; + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? CLZBase::cNumLitStates : CLZBase::cNumLitStates + 3; + } + } + + m_cur_ofs = lzdec.m_pos + lzdec.get_len(); + } + + uint lzcompressor::state::get_pred_char(const search_accelerator& dict, int pos, int backward_ofs) const + { + LZHAM_ASSERT(pos >= (int)m_block_start_dict_ofs); + int limit = pos - m_block_start_dict_ofs; + if (backward_ofs > limit) + return 0; + return dict[pos - backward_ofs]; + } + + bit_cost_t lzcompressor::state::get_cost(CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec) const + { + const uint lit_pred0 = get_pred_char(dict, lzdec.m_pos, 1); + + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(lit_pred0, m_cur_state); + LZHAM_ASSERT(is_match_model_index < LZHAM_ARRAY_SIZE(m_is_match_model)); + bit_cost_t cost = m_is_match_model[is_match_model_index].get_cost(lzdec.is_match()); + + if (!lzdec.is_match()) + { + const uint lit = dict[lzdec.m_pos]; + + if (m_cur_state < CLZBase::cNumLitStates) + { + const uint lit_pred1 = get_pred_char(dict, lzdec.m_pos, 2); + + uint lit_pred = (lit_pred0 >> (8 - CLZBase::cNumLitPredBits/2)) | + (((lit_pred1 >> (8 - CLZBase::cNumLitPredBits/2)) << CLZBase::cNumLitPredBits/2)); + + // literal + cost += m_lit_table[lit_pred].get_cost(lit); + } + else + { + // delta literal + const uint rep_lit0 = dict[(lzdec.m_pos - m_match_hist[0]) & dict.m_max_dict_size_mask]; + const uint rep_lit1 = dict[(lzdec.m_pos - m_match_hist[0] - 1) & dict.m_max_dict_size_mask]; + + uint delta_lit = rep_lit0 ^ lit; + + uint lit_pred = (rep_lit0 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) | + ((rep_lit1 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) << CLZBase::cNumDeltaLitPredBits/2); + + cost += m_delta_lit_table[lit_pred].get_cost(delta_lit); + } + } + else + { + // match + if (lzdec.m_dist < 0) + { + // rep match + cost += m_is_rep_model[m_cur_state].get_cost(1); + + int match_hist_index = -lzdec.m_dist - 1; + + if (!match_hist_index) + { + // rep0 match + cost += m_is_rep0_model[m_cur_state].get_cost(1); + + if (lzdec.m_len == 1) + { + // single byte rep0 + cost += m_is_rep0_single_byte_model[m_cur_state].get_cost(1); + } + else + { + // normal rep0 + cost += m_is_rep0_single_byte_model[m_cur_state].get_cost(0); + + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + cost += get_huge_match_code_len(lzdec.m_len) + m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates].get_cost((CLZBase::cMaxMatchLen + 1) - CLZBase::cMinMatchLen); + } + else + { + cost += m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates].get_cost(lzdec.m_len - CLZBase::cMinMatchLen); + } + } + } + else + { + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + cost += get_huge_match_code_len(lzdec.m_len) + m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates].get_cost((CLZBase::cMaxMatchLen + 1) - CLZBase::cMinMatchLen); + } + else + { + cost += m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates].get_cost(lzdec.m_len - CLZBase::cMinMatchLen); + } + + // rep1-rep3 match + cost += m_is_rep0_model[m_cur_state].get_cost(0); + + if (match_hist_index == 1) + { + // rep1 + cost += m_is_rep1_model[m_cur_state].get_cost(1); + } + else + { + cost += m_is_rep1_model[m_cur_state].get_cost(0); + + if (match_hist_index == 2) + { + // rep2 + cost += m_is_rep2_model[m_cur_state].get_cost(1); + } + else + { + LZHAM_ASSERT(match_hist_index == 3); + // rep3 + cost += m_is_rep2_model[m_cur_state].get_cost(0); + } + } + } + } + else + { + cost += m_is_rep_model[m_cur_state].get_cost(0); + + LZHAM_ASSERT(lzdec.m_len >= CLZBase::cMinMatchLen); + + // full match + uint match_slot, match_extra; + lzbase.compute_lzx_position_slot(lzdec.m_dist, match_slot, match_extra); + + uint match_low_sym = 0; + if (lzdec.m_len >= 9) + { + match_low_sym = 7; + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + cost += get_huge_match_code_len(lzdec.m_len) + m_large_len_table[m_cur_state >= CLZBase::cNumLitStates].get_cost((CLZBase::cMaxMatchLen + 1) - 9); + } + else + { + cost += m_large_len_table[m_cur_state >= CLZBase::cNumLitStates].get_cost(lzdec.m_len - 9); + } + } + else + match_low_sym = lzdec.m_len - 2; + + uint match_high_sym = 0; + + LZHAM_ASSERT(match_slot >= CLZBase::cLZXLowestUsableMatchSlot && (match_slot < lzbase.m_num_lzx_slots)); + match_high_sym = match_slot - CLZBase::cLZXLowestUsableMatchSlot; + + uint main_sym = match_low_sym | (match_high_sym << 3); + + cost += m_main_table.get_cost(CLZBase::cLZXNumSpecialLengths + main_sym); + + uint num_extra_bits = lzbase.m_lzx_position_extra_bits[match_slot]; + if (num_extra_bits < 3) + cost += convert_to_scaled_bitcost(num_extra_bits); + else + { + if (num_extra_bits > 4) + cost += convert_to_scaled_bitcost(num_extra_bits - 4); + + cost += m_dist_lsb_table.get_cost(match_extra & 15); + } + } + } + + return cost; + } + + bit_cost_t lzcompressor::state::get_len2_match_cost(CLZBase& lzbase, uint dict_pos, uint len2_match_dist, uint is_match_model_index) + { + LZHAM_NOTE_UNUSED(dict_pos); + + bit_cost_t cost = m_is_match_model[is_match_model_index].get_cost(1); + + cost += m_is_rep_model[m_cur_state].get_cost(0); + + // full match + uint match_slot, match_extra; + lzbase.compute_lzx_position_slot(len2_match_dist, match_slot, match_extra); + + const uint match_len = 2; + uint match_low_sym = match_len - 2; + + uint match_high_sym = 0; + + LZHAM_ASSERT(match_slot >= CLZBase::cLZXLowestUsableMatchSlot && (match_slot < lzbase.m_num_lzx_slots)); + match_high_sym = match_slot - CLZBase::cLZXLowestUsableMatchSlot; + + uint main_sym = match_low_sym | (match_high_sym << 3); + + cost += m_main_table.get_cost(CLZBase::cLZXNumSpecialLengths + main_sym); + + uint num_extra_bits = lzbase.m_lzx_position_extra_bits[match_slot]; + if (num_extra_bits < 3) + cost += convert_to_scaled_bitcost(num_extra_bits); + else + { + if (num_extra_bits > 4) + cost += convert_to_scaled_bitcost(num_extra_bits - 4); + + cost += m_dist_lsb_table.get_cost(match_extra & 15); + } + + return cost; + } + + bit_cost_t lzcompressor::state::get_lit_cost(const search_accelerator& dict, uint dict_pos, uint lit_pred0, uint is_match_model_index) const + { + bit_cost_t cost = m_is_match_model[is_match_model_index].get_cost(0); + + const uint lit = dict[dict_pos]; + + if (m_cur_state < CLZBase::cNumLitStates) + { + // literal + const uint lit_pred1 = get_pred_char(dict, dict_pos, 2); + + uint lit_pred = (lit_pred0 >> (8 - CLZBase::cNumLitPredBits/2)) | + (((lit_pred1 >> (8 - CLZBase::cNumLitPredBits/2)) << CLZBase::cNumLitPredBits/2)); + + cost += m_lit_table[lit_pred].get_cost(lit); + } + else + { + // delta literal + const uint rep_lit0 = dict[(dict_pos - m_match_hist[0]) & dict.m_max_dict_size_mask]; + const uint rep_lit1 = dict[(dict_pos - m_match_hist[0] - 1) & dict.m_max_dict_size_mask]; + + uint delta_lit = rep_lit0 ^ lit; + + uint lit_pred = (rep_lit0 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) | + ((rep_lit1 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) << CLZBase::cNumDeltaLitPredBits/2); + + cost += m_delta_lit_table[lit_pred].get_cost(delta_lit); + } + + return cost; + } + + void lzcompressor::state::get_rep_match_costs(uint dict_pos, bit_cost_t *pBitcosts, uint match_hist_index, int min_len, int max_len, uint is_match_model_index) const + { + LZHAM_NOTE_UNUSED(dict_pos); + // match + const sym_data_model &rep_len_table = m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates]; + + bit_cost_t base_cost = m_is_match_model[is_match_model_index].get_cost(1); + + base_cost += m_is_rep_model[m_cur_state].get_cost(1); + + if (!match_hist_index) + { + // rep0 match + base_cost += m_is_rep0_model[m_cur_state].get_cost(1); + } + else + { + // rep1-rep3 matches + base_cost += m_is_rep0_model[m_cur_state].get_cost(0); + + if (match_hist_index == 1) + { + // rep1 + base_cost += m_is_rep1_model[m_cur_state].get_cost(1); + } + else + { + base_cost += m_is_rep1_model[m_cur_state].get_cost(0); + + if (match_hist_index == 2) + { + // rep2 + base_cost += m_is_rep2_model[m_cur_state].get_cost(1); + } + else + { + // rep3 + base_cost += m_is_rep2_model[m_cur_state].get_cost(0); + } + } + } + + // rep match + if (!match_hist_index) + { + if (min_len == 1) + { + // single byte rep0 + pBitcosts[1] = base_cost + m_is_rep0_single_byte_model[m_cur_state].get_cost(1); + min_len++; + } + + bit_cost_t rep0_match_base_cost = base_cost + m_is_rep0_single_byte_model[m_cur_state].get_cost(0); + for (int match_len = min_len; match_len <= max_len; match_len++) + { + // normal rep0 + if (match_len > CLZBase::cMaxMatchLen) + { + pBitcosts[match_len] = get_huge_match_code_len(match_len) + rep0_match_base_cost + rep_len_table.get_cost((CLZBase::cMaxMatchLen + 1) - CLZBase::cMinMatchLen); + } + else + { + pBitcosts[match_len] = rep0_match_base_cost + rep_len_table.get_cost(match_len - CLZBase::cMinMatchLen); + } + } + } + else + { + for (int match_len = min_len; match_len <= max_len; match_len++) + { + if (match_len > CLZBase::cMaxMatchLen) + { + pBitcosts[match_len] = get_huge_match_code_len(match_len) + base_cost + rep_len_table.get_cost((CLZBase::cMaxMatchLen + 1) - CLZBase::cMinMatchLen); + } + else + { + pBitcosts[match_len] = base_cost + rep_len_table.get_cost(match_len - CLZBase::cMinMatchLen); + } + } + } + } + + void lzcompressor::state::get_full_match_costs(CLZBase& lzbase, uint dict_pos, bit_cost_t *pBitcosts, uint match_dist, int min_len, int max_len, uint is_match_model_index) const + { + LZHAM_NOTE_UNUSED(dict_pos); + LZHAM_ASSERT(min_len >= CLZBase::cMinMatchLen); + + bit_cost_t cost = m_is_match_model[is_match_model_index].get_cost(1); + + cost += m_is_rep_model[m_cur_state].get_cost(0); + + uint match_slot, match_extra; + lzbase.compute_lzx_position_slot(match_dist, match_slot, match_extra); + LZHAM_ASSERT(match_slot >= CLZBase::cLZXLowestUsableMatchSlot && (match_slot < lzbase.m_num_lzx_slots)); + + uint num_extra_bits = lzbase.m_lzx_position_extra_bits[match_slot]; + + if (num_extra_bits < 3) + cost += convert_to_scaled_bitcost(num_extra_bits); + else + { + if (num_extra_bits > 4) + cost += convert_to_scaled_bitcost(num_extra_bits - 4); + + cost += m_dist_lsb_table.get_cost(match_extra & 15); + } + + uint match_high_sym = match_slot - CLZBase::cLZXLowestUsableMatchSlot; + + const sym_data_model &large_len_table = m_large_len_table[m_cur_state >= CLZBase::cNumLitStates]; + + for (int match_len = min_len; match_len <= max_len; match_len++) + { + bit_cost_t len_cost = cost; + + uint match_low_sym = 0; + if (match_len >= 9) + { + match_low_sym = 7; + if (match_len > CLZBase::cMaxMatchLen) + { + len_cost += get_huge_match_code_len(match_len) + large_len_table.get_cost((CLZBase::cMaxMatchLen + 1) - 9); + } + else + { + len_cost += large_len_table.get_cost(match_len - 9); + } + } + else + match_low_sym = match_len - 2; + + uint main_sym = match_low_sym | (match_high_sym << 3); + + pBitcosts[match_len] = len_cost + m_main_table.get_cost(CLZBase::cLZXNumSpecialLengths + main_sym); + } + } + + bool lzcompressor::state::advance(CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec) + { + const uint lit_pred0 = get_pred_char(dict, lzdec.m_pos, 1); + + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(lit_pred0, m_cur_state); + m_is_match_model[is_match_model_index].update(lzdec.is_match()); + + if (!lzdec.is_match()) + { + const uint lit = dict[lzdec.m_pos]; + + if (m_cur_state < CLZBase::cNumLitStates) + { + const uint lit_pred1 = get_pred_char(dict, lzdec.m_pos, 2); + + uint lit_pred = (lit_pred0 >> (8 - CLZBase::cNumLitPredBits/2)) | + (((lit_pred1 >> (8 - CLZBase::cNumLitPredBits/2)) << CLZBase::cNumLitPredBits/2)); + + // literal + if (!m_lit_table[lit_pred].update(lit)) return false; + } + else + { + // delta literal + const uint rep_lit0 = dict[(lzdec.m_pos - m_match_hist[0]) & dict.m_max_dict_size_mask]; + const uint rep_lit1 = dict[(lzdec.m_pos - m_match_hist[0] - 1) & dict.m_max_dict_size_mask]; + + uint delta_lit = rep_lit0 ^ lit; + + uint lit_pred = (rep_lit0 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) | + ((rep_lit1 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) << CLZBase::cNumDeltaLitPredBits/2); + + if (!m_delta_lit_table[lit_pred].update(delta_lit)) return false; + } + + if (m_cur_state < 4) m_cur_state = 0; else if (m_cur_state < 10) m_cur_state -= 3; else m_cur_state -= 6; + } + else + { + // match + if (lzdec.m_dist < 0) + { + // rep match + m_is_rep_model[m_cur_state].update(1); + + int match_hist_index = -lzdec.m_dist - 1; + + if (!match_hist_index) + { + // rep0 match + m_is_rep0_model[m_cur_state].update(1); + + if (lzdec.m_len == 1) + { + // single byte rep0 + m_is_rep0_single_byte_model[m_cur_state].update(1); + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 9 : 11; + } + else + { + // normal rep0 + m_is_rep0_single_byte_model[m_cur_state].update(0); + + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + if (!m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates].update((CLZBase::cMaxMatchLen + 1) - CLZBase::cMinMatchLen)) return false; + } + else + { + if (!m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates].update(lzdec.m_len - CLZBase::cMinMatchLen)) return false; + } + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 8 : 11; + } + } + else + { + // rep1-rep3 match + m_is_rep0_model[m_cur_state].update(0); + + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + if (!m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates].update((CLZBase::cMaxMatchLen + 1) - CLZBase::cMinMatchLen)) return false; + } + else + { + if (!m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates].update(lzdec.m_len - CLZBase::cMinMatchLen)) return false; + } + + if (match_hist_index == 1) + { + // rep1 + m_is_rep1_model[m_cur_state].update(1); + + std::swap(m_match_hist[0], m_match_hist[1]); + } + else + { + m_is_rep1_model[m_cur_state].update(0); + + if (match_hist_index == 2) + { + // rep2 + m_is_rep2_model[m_cur_state].update(1); + + int dist = m_match_hist[2]; + m_match_hist[2] = m_match_hist[1]; + m_match_hist[1] = m_match_hist[0]; + m_match_hist[0] = dist; + } + else + { + // rep3 + m_is_rep2_model[m_cur_state].update(0); + + int dist = m_match_hist[3]; + m_match_hist[3] = m_match_hist[2]; + m_match_hist[2] = m_match_hist[1]; + m_match_hist[1] = m_match_hist[0]; + m_match_hist[0] = dist; + } + } + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 8 : 11; + } + } + else + { + m_is_rep_model[m_cur_state].update(0); + + LZHAM_ASSERT(lzdec.m_len >= CLZBase::cMinMatchLen); + + // full match + uint match_slot, match_extra; + lzbase.compute_lzx_position_slot(lzdec.m_dist, match_slot, match_extra); + + uint match_low_sym = 0; + int large_len_sym = -1; + if (lzdec.m_len >= 9) + { + match_low_sym = 7; + + large_len_sym = lzdec.m_len - 9; + } + else + match_low_sym = lzdec.m_len - 2; + + uint match_high_sym = 0; + + LZHAM_ASSERT(match_slot >= CLZBase::cLZXLowestUsableMatchSlot && (match_slot < lzbase.m_num_lzx_slots)); + match_high_sym = match_slot - CLZBase::cLZXLowestUsableMatchSlot; + + uint main_sym = match_low_sym | (match_high_sym << 3); + + if (!m_main_table.update(CLZBase::cLZXNumSpecialLengths + main_sym)) return false; + + if (large_len_sym >= 0) + { + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + if (!m_large_len_table[m_cur_state >= CLZBase::cNumLitStates].update((CLZBase::cMaxMatchLen + 1) - 9)) return false; + } + else + { + if (!m_large_len_table[m_cur_state >= CLZBase::cNumLitStates].update(large_len_sym)) return false; + } + } + + uint num_extra_bits = lzbase.m_lzx_position_extra_bits[match_slot]; + if (num_extra_bits >= 3) + { + if (!m_dist_lsb_table.update(match_extra & 15)) return false; + } + + update_match_hist(lzdec.m_dist); + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? CLZBase::cNumLitStates : CLZBase::cNumLitStates + 3; + } + } + + m_cur_ofs = lzdec.m_pos + lzdec.get_len(); + return true; + } + + bool lzcompressor::state::encode(symbol_codec& codec, CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec) + { + const uint lit_pred0 = get_pred_char(dict, lzdec.m_pos, 1); + + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(lit_pred0, m_cur_state); + if (!codec.encode(lzdec.is_match(), m_is_match_model[is_match_model_index])) return false; + + if (!lzdec.is_match()) + { + const uint lit = dict[lzdec.m_pos]; + +#ifdef LZHAM_LZDEBUG + if (!codec.encode_bits(lit, 8)) return false; +#endif + + if (m_cur_state < CLZBase::cNumLitStates) + { + const uint lit_pred1 = get_pred_char(dict, lzdec.m_pos, 2); + + uint lit_pred = (lit_pred0 >> (8 - CLZBase::cNumLitPredBits/2)) | + (((lit_pred1 >> (8 - CLZBase::cNumLitPredBits/2)) << CLZBase::cNumLitPredBits/2)); + + // literal + if (!codec.encode(lit, m_lit_table[lit_pred])) return false; + } + else + { + // delta literal + const uint rep_lit0 = dict[(lzdec.m_pos - m_match_hist[0]) & dict.m_max_dict_size_mask]; + const uint rep_lit1 = dict[(lzdec.m_pos - m_match_hist[0] - 1) & dict.m_max_dict_size_mask]; + + uint delta_lit = rep_lit0 ^ lit; + + uint lit_pred = (rep_lit0 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) | + ((rep_lit1 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) << CLZBase::cNumDeltaLitPredBits/2); + +#ifdef LZHAM_LZDEBUG + if (!codec.encode_bits(rep_lit0, 8)) return false; +#endif + + if (!codec.encode(delta_lit, m_delta_lit_table[lit_pred])) return false; + } + + if (m_cur_state < 4) m_cur_state = 0; else if (m_cur_state < 10) m_cur_state -= 3; else m_cur_state -= 6; + } + else + { + // match + if (lzdec.m_dist < 0) + { + // rep match + if (!codec.encode(1, m_is_rep_model[m_cur_state])) return false; + + int match_hist_index = -lzdec.m_dist - 1; + + if (!match_hist_index) + { + // rep0 match + if (!codec.encode(1, m_is_rep0_model[m_cur_state])) return false; + + if (lzdec.m_len == 1) + { + // single byte rep0 + if (!codec.encode(1, m_is_rep0_single_byte_model[m_cur_state])) return false; + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 9 : 11; + } + else + { + // normal rep0 + if (!codec.encode(0, m_is_rep0_single_byte_model[m_cur_state])) return false; + + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + if (!codec.encode((CLZBase::cMaxMatchLen + 1) - CLZBase::cMinMatchLen, m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates])) return false; + if (!codec.encode_bits(get_huge_match_code_bits(lzdec.m_len), get_huge_match_code_len(lzdec.m_len))) return false; + } + else + { + if (!codec.encode(lzdec.m_len - CLZBase::cMinMatchLen, m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates])) return false; + } + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 8 : 11; + } + } + else + { + // rep1-rep3 match + if (!codec.encode(0, m_is_rep0_model[m_cur_state])) return false; + + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + if (!codec.encode((CLZBase::cMaxMatchLen + 1) - CLZBase::cMinMatchLen, m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates])) return false; + if (!codec.encode_bits(get_huge_match_code_bits(lzdec.m_len), get_huge_match_code_len(lzdec.m_len))) return false; + } + else + { + if (!codec.encode(lzdec.m_len - CLZBase::cMinMatchLen, m_rep_len_table[m_cur_state >= CLZBase::cNumLitStates])) return false; + } + + if (match_hist_index == 1) + { + // rep1 + if (!codec.encode(1, m_is_rep1_model[m_cur_state])) return false; + + std::swap(m_match_hist[0], m_match_hist[1]); + } + else + { + if (!codec.encode(0, m_is_rep1_model[m_cur_state])) return false; + + if (match_hist_index == 2) + { + // rep2 + if (!codec.encode(1, m_is_rep2_model[m_cur_state])) return false; + + int dist = m_match_hist[2]; + m_match_hist[2] = m_match_hist[1]; + m_match_hist[1] = m_match_hist[0]; + m_match_hist[0] = dist; + } + else + { + // rep3 + if (!codec.encode(0, m_is_rep2_model[m_cur_state])) return false; + + int dist = m_match_hist[3]; + m_match_hist[3] = m_match_hist[2]; + m_match_hist[2] = m_match_hist[1]; + m_match_hist[1] = m_match_hist[0]; + m_match_hist[0] = dist; + } + } + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? 8 : 11; + } + } + else + { + if (!codec.encode(0, m_is_rep_model[m_cur_state])) return false; + + LZHAM_ASSERT(lzdec.m_len >= CLZBase::cMinMatchLen); + + // full match + uint match_slot, match_extra; + lzbase.compute_lzx_position_slot(lzdec.m_dist, match_slot, match_extra); + + uint match_low_sym = 0; + int large_len_sym = -1; + if (lzdec.m_len >= 9) + { + match_low_sym = 7; + + large_len_sym = lzdec.m_len - 9; + } + else + match_low_sym = lzdec.m_len - 2; + + uint match_high_sym = 0; + + LZHAM_ASSERT(match_slot >= CLZBase::cLZXLowestUsableMatchSlot && (match_slot < lzbase.m_num_lzx_slots)); + match_high_sym = match_slot - CLZBase::cLZXLowestUsableMatchSlot; + + uint main_sym = match_low_sym | (match_high_sym << 3); + + if (!codec.encode(CLZBase::cLZXNumSpecialLengths + main_sym, m_main_table)) return false; + + if (large_len_sym >= 0) + { + if (lzdec.m_len > CLZBase::cMaxMatchLen) + { + if (!codec.encode((CLZBase::cMaxMatchLen + 1) - 9, m_large_len_table[m_cur_state >= CLZBase::cNumLitStates])) return false; + if (!codec.encode_bits(get_huge_match_code_bits(lzdec.m_len), get_huge_match_code_len(lzdec.m_len))) return false; + } + else + { + if (!codec.encode(large_len_sym, m_large_len_table[m_cur_state >= CLZBase::cNumLitStates])) return false; + } + } + + uint num_extra_bits = lzbase.m_lzx_position_extra_bits[match_slot]; + if (num_extra_bits < 3) + { + if (!codec.encode_bits(match_extra, num_extra_bits)) return false; + } + else + { + if (num_extra_bits > 4) + { + if (!codec.encode_bits((match_extra >> 4), num_extra_bits - 4)) return false; + } + + if (!codec.encode(match_extra & 15, m_dist_lsb_table)) return false; + } + + update_match_hist(lzdec.m_dist); + + m_cur_state = (m_cur_state < CLZBase::cNumLitStates) ? CLZBase::cNumLitStates : CLZBase::cNumLitStates + 3; + } + +#ifdef LZHAM_LZDEBUG + if (!codec.encode_bits(m_match_hist[0], 29)) return false; +#endif + } + + m_cur_ofs = lzdec.m_pos + lzdec.get_len(); + return true; + } + + void lzcompressor::state::print(symbol_codec& codec, CLZBase& lzbase, const search_accelerator& dict, const lzdecision& lzdec) + { + LZHAM_NOTE_UNUSED(codec), LZHAM_NOTE_UNUSED(lzbase), LZHAM_NOTE_UNUSED(dict); + + const uint lit_pred0 = get_pred_char(dict, lzdec.m_pos, 1); + + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(lit_pred0, m_cur_state); + + printf(" pos: %u, state: %u, match_pred: %u, is_match_model_index: %u, is_match: %u, cost: %f\n", + lzdec.m_pos, + m_cur_state, + lit_pred0, is_match_model_index, lzdec.is_match(), get_cost(lzbase, dict, lzdec) / (float)cBitCostScale); + + if (!lzdec.is_match()) + { + const uint lit = dict[lzdec.m_pos]; + + if (m_cur_state < CLZBase::cNumLitStates) + { + const uint lit_pred1 = get_pred_char(dict, lzdec.m_pos, 2); + + uint lit_pred = (lit_pred0 >> (8 - CLZBase::cNumLitPredBits/2)) | + (((lit_pred1 >> (8 - CLZBase::cNumLitPredBits/2)) << CLZBase::cNumLitPredBits/2)); + + printf("---Regular lit: %u '%c', lit_pred: %u '%c'\n", + lit, ((lit >= 32) && (lit <= 127)) ? lit : '.', + lit_pred, ((lit_pred >= 32) && (lit_pred <= 127)) ? lit_pred : '.'); + } + else + { + // delta literal + const uint rep_lit0 = dict[(lzdec.m_pos - m_match_hist[0]) & dict.m_max_dict_size_mask]; + const uint rep_lit1 = dict[(lzdec.m_pos - m_match_hist[0] - 1) & dict.m_max_dict_size_mask]; + + uint delta_lit = rep_lit0 ^ lit; + + uint lit_pred = (rep_lit0 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) | + ((rep_lit1 >> (8 - CLZBase::cNumDeltaLitPredBits/2)) << CLZBase::cNumDeltaLitPredBits/2); + + printf("***Delta lit: %u '%c', Mismatch: %u '%c', Delta: 0x%02X, lit_pred: %u\n", + lit, ((lit >= 32) && (lit <= 127)) ? lit : '.', + rep_lit0, ((rep_lit0 >= 32) && (rep_lit0 <= 127)) ? rep_lit0 : '.', + delta_lit, lit_pred); + } + } + else + { + uint actual_match_len = dict.get_match_len(0, lzdec.get_match_dist(*this), CLZBase::cMaxMatchLen); + LZHAM_ASSERT(actual_match_len >= lzdec.get_len()); + + // match + if (lzdec.m_dist < 0) + { + int match_hist_index = -lzdec.m_dist - 1; + + if (!match_hist_index) + { + if (lzdec.m_len == 1) + { + printf("!!!Rep 0 len1\n"); + } + else + { + printf("!!!Rep 0 full len %u\n", lzdec.m_len); + } + } + else + { + printf("!!!Rep %u full len %u\n", match_hist_index, lzdec.m_len); + } + } + else + { + LZHAM_ASSERT(lzdec.m_len >= CLZBase::cMinMatchLen); + + // full match + uint match_slot, match_extra; + lzbase.compute_lzx_position_slot(lzdec.m_dist, match_slot, match_extra); + + uint match_low_sym = 0; LZHAM_NOTE_UNUSED(match_low_sym); + int large_len_sym = -1; LZHAM_NOTE_UNUSED(large_len_sym); + if (lzdec.m_len >= 9) + { + match_low_sym = 7; + + large_len_sym = lzdec.m_len - 9; + } + else + match_low_sym = lzdec.m_len - 2; + + uint match_high_sym = 0; LZHAM_NOTE_UNUSED(match_high_sym); + + LZHAM_ASSERT(match_slot >= CLZBase::cLZXLowestUsableMatchSlot && (match_slot < lzbase.m_num_lzx_slots)); + match_high_sym = match_slot - CLZBase::cLZXLowestUsableMatchSlot; + + //uint main_sym = match_low_sym | (match_high_sym << 3); + + uint num_extra_bits = lzbase.m_lzx_position_extra_bits[match_slot]; + printf("^^^Full match Len %u Dist %u, Slot %u, ExtraBits: %u", lzdec.m_len, lzdec.m_dist, match_slot, num_extra_bits); + + if (num_extra_bits < 3) + { + } + else + { + printf(" (Low 4 bits: %u vs. %u)", lzdec.m_dist & 15, match_extra & 15); + } + printf("\n"); + } + + if (actual_match_len > lzdec.get_len()) + { + printf(" TRUNCATED match, actual len is %u, shortened by %u\n", actual_match_len, actual_match_len - lzdec.get_len()); + } + } + } + + bool lzcompressor::state::encode_eob(symbol_codec& codec, const search_accelerator& dict, uint dict_pos) + { +#ifdef LZHAM_LZDEBUG + if (!codec.encode_bits(CLZBase::cLZHAMDebugSyncMarkerValue, CLZBase::cLZHAMDebugSyncMarkerBits)) return false; + if (!codec.encode_bits(1, 1)) return false; + if (!codec.encode_bits(0, 17)) return false; + if (!codec.encode_bits(m_cur_state, 4)) return false; +#endif + + const uint match_pred = get_pred_char(dict, dict_pos, 1); + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(match_pred, m_cur_state); + if (!codec.encode(1, m_is_match_model[is_match_model_index])) return false; + + // full match + if (!codec.encode(0, m_is_rep_model[m_cur_state])) return false; + + return codec.encode(CLZBase::cLZXSpecialCodeEndOfBlockCode, m_main_table); + } + + bool lzcompressor::state::encode_reset_state_partial(symbol_codec& codec, const search_accelerator& dict, uint dict_pos) + { +#ifdef LZHAM_LZDEBUG + if (!codec.encode_bits(CLZBase::cLZHAMDebugSyncMarkerValue, CLZBase::cLZHAMDebugSyncMarkerBits)) return false; + if (!codec.encode_bits(1, 1)) return false; + if (!codec.encode_bits(0, 17)) return false; + if (!codec.encode_bits(m_cur_state, 4)) return false; +#endif + + const uint match_pred = get_pred_char(dict, dict_pos, 1); + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(match_pred, m_cur_state); + if (!codec.encode(1, m_is_match_model[is_match_model_index])) return false; + + // full match + if (!codec.encode(0, m_is_rep_model[m_cur_state])) return false; + + if (!codec.encode(CLZBase::cLZXSpecialCodePartialStateReset, m_main_table)) + return false; + + reset_state_partial(); + return true; + } + + void lzcompressor::state::update_match_hist(uint match_dist) + { + LZHAM_ASSUME(CLZBase::cMatchHistSize == 4); + m_match_hist[3] = m_match_hist[2]; + m_match_hist[2] = m_match_hist[1]; + m_match_hist[1] = m_match_hist[0]; + m_match_hist[0] = match_dist; + } + + int lzcompressor::state::find_match_dist(uint match_dist) const + { + for (uint match_hist_index = 0; match_hist_index < CLZBase::cMatchHistSize; match_hist_index++) + if (match_dist == m_match_hist[match_hist_index]) + return match_hist_index; + + return -1; + } + + void lzcompressor::state::reset_state_partial() + { + LZHAM_ASSUME(CLZBase::cMatchHistSize == 4); + m_match_hist[0] = 1; + m_match_hist[1] = 1; + m_match_hist[2] = 1; + m_match_hist[3] = 1; + m_cur_state = 0; + } + + void lzcompressor::state::start_of_block(const search_accelerator& dict, uint cur_ofs, uint block_index) + { + LZHAM_NOTE_UNUSED(dict), LZHAM_NOTE_UNUSED(block_index); + + reset_state_partial(); + + m_cur_ofs = cur_ofs; + m_block_start_dict_ofs = cur_ofs; + } + + void lzcompressor::state::reset_update_rate() + { + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_lit_table); i++) + m_lit_table[i].reset_update_rate(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_delta_lit_table); i++) + m_delta_lit_table[i].reset_update_rate(); + + m_main_table.reset_update_rate(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_rep_len_table); i++) + m_rep_len_table[i].reset_update_rate(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_large_len_table); i++) + m_large_len_table[i].reset_update_rate(); + + m_dist_lsb_table.reset_update_rate(); + } + + void lzcompressor::coding_stats::clear() + { + m_total_bytes = 0; + m_total_contexts = 0; + m_total_match_bits_cost = 0; + m_worst_match_bits_cost = 0; + m_total_is_match0_bits_cost = 0; + m_total_is_match1_bits_cost = 0; + m_context_stats.clear(); + + m_total_nonmatches = 0; + m_total_matches = 0; + m_total_cost = 0.0f; + + m_lit_stats.clear(); + m_delta_lit_stats.clear(); + + m_rep0_len1_stats.clear(); + for (uint i = 0; i < CLZBase::cMatchHistSize; i++) + m_rep_stats[i].clear(); + m_rep0_len1_stats.clear(); + m_rep0_len2_plus_stats.clear(); + + for (uint i = 0; i <= CLZBase::cMaxMatchLen; i++) + m_full_match_stats[i].clear(); + + m_total_far_len2_matches = 0; + m_total_near_len2_matches = 0; + + m_total_truncated_matches = 0; + utils::zero_object(m_match_truncation_len_hist); + utils::zero_object(m_match_truncation_hist); + utils::zero_object(m_match_type_truncation_hist); + utils::zero_object(m_match_type_was_not_truncated_hist); + + m_total_update_rate_resets = 0; + + m_max_len2_dist = 0; + } + + void lzcompressor::coding_stats::print() + { + if (!m_total_contexts) + return; + + printf("-----------\n"); + printf("Coding statistics:\n"); + printf("Total update rate resets: %u\n", m_total_update_rate_resets); + printf("Total Bytes: %u, Total Contexts: %u, Total Cost: %f bits (%f bytes)\nContext ave cost: %f StdDev: %f Min: %f Max: %f\n", m_total_bytes, m_total_contexts, m_total_cost, m_total_cost / 8.0f, m_context_stats.get_average(), m_context_stats.get_std_dev(), m_context_stats.get_min_val(), m_context_stats.get_max_val()); + printf("Ave bytes per context: %f\n", m_total_bytes / (float)m_total_contexts); + + printf("IsMatch:\n"); + printf(" Total: %u, Cost: %f (%f bytes), Ave. Cost: %f, Worst Cost: %f\n", + m_total_contexts, m_total_match_bits_cost, m_total_match_bits_cost / 8.0f, m_total_match_bits_cost / math::maximum(1, m_total_contexts), m_worst_match_bits_cost); + + printf(" IsMatch(0): %u, Cost: %f (%f bytes), Ave. Cost: %f\n", + m_total_nonmatches, m_total_is_match0_bits_cost, m_total_is_match0_bits_cost / 8.0f, m_total_is_match0_bits_cost / math::maximum(1, m_total_nonmatches)); + + printf(" IsMatch(1): %u, Cost: %f (%f bytes), Ave. Cost: %f\n", + m_total_matches, m_total_is_match1_bits_cost, m_total_is_match1_bits_cost / 8.0f, m_total_is_match1_bits_cost / math::maximum(1, m_total_matches)); + + printf("Literal stats:\n"); + printf(" Count: %u, Cost: %f (%f bytes), Ave: %f StdDev: %f Min: %f Max: %f\n", m_lit_stats.get_number_of_values32(), m_lit_stats.get_total(), m_lit_stats.get_total() / 8.0f, m_lit_stats.get_average(), m_lit_stats.get_std_dev(), m_lit_stats.get_min_val(), m_lit_stats.get_max_val()); + + printf("Delta literal stats:\n"); + printf(" Count: %u, Cost: %f (%f bytes), Ave: %f StdDev: %f Min: %f Max: %f\n", m_delta_lit_stats.get_number_of_values32(), m_delta_lit_stats.get_total(), m_delta_lit_stats.get_total() / 8.0f, m_delta_lit_stats.get_average(), m_delta_lit_stats.get_std_dev(), m_delta_lit_stats.get_min_val(), m_delta_lit_stats.get_max_val()); + + printf("Rep0 Len1 stats:\n"); + printf(" Count: %u, Cost: %f (%f bytes), Ave. Cost: %f StdDev: %f Min: %f Max: %f\n", m_rep0_len1_stats.get_number_of_values32(), m_rep0_len1_stats.get_total(), m_rep0_len1_stats.get_total() / 8.0f, m_rep0_len1_stats.get_average(), m_rep0_len1_stats.get_std_dev(), m_rep0_len1_stats.get_min_val(), m_rep0_len1_stats.get_max_val()); + + printf("Rep0 Len2+ stats:\n"); + printf(" Count: %u, Cost: %f (%f bytes), Ave. Cost: %f StdDev: %f Min: %f Max: %f\n", m_rep0_len2_plus_stats.get_number_of_values32(), m_rep0_len2_plus_stats.get_total(), m_rep0_len2_plus_stats.get_total() / 8.0f, m_rep0_len2_plus_stats.get_average(), m_rep0_len2_plus_stats.get_std_dev(), m_rep0_len2_plus_stats.get_min_val(), m_rep0_len2_plus_stats.get_max_val()); + + for (uint i = 0; i < CLZBase::cMatchHistSize; i++) + { + printf("Rep %u stats:\n", i); + printf(" Count: %u, Cost: %f (%f bytes), Ave. Cost: %f StdDev: %f Min: %f Max: %f\n", m_rep_stats[i].get_number_of_values32(), m_rep_stats[i].get_total(), m_rep_stats[i].get_total() / 8.0f, m_rep_stats[i].get_average(), m_rep_stats[i].get_std_dev(), m_rep_stats[i].get_min_val(), m_rep_stats[i].get_max_val()); + } + + for (uint i = CLZBase::cMinMatchLen; i <= CLZBase::cMaxMatchLen; i++) + { + printf("Match %u: Total: %u, Cost: %f (%f bytes), Ave: %f StdDev: %f Min: %f Max: %f\n", i, + m_full_match_stats[i].get_number_of_values32(), m_full_match_stats[i].get_total(), m_full_match_stats[i].get_total() / 8.0f, + m_full_match_stats[i].get_average(), m_full_match_stats[i].get_std_dev(), m_full_match_stats[i].get_min_val(), m_full_match_stats[i].get_max_val()); + } + + printf("Total near len2 matches: %u, total far len2 matches: %u\n", m_total_near_len2_matches, m_total_far_len2_matches); + printf("Total matches: %u, truncated matches: %u\n", m_total_matches, m_total_truncated_matches); + printf("Max full match len2 distance: %u\n", m_max_len2_dist); + +#if 0 + printf("Size of truncation histogram:\n"); + for (uint i = 0; i <= CLZBase::cMaxMatchLen; i++) + { + printf("%05u ", m_match_truncation_len_hist[i]); + if ((i & 15) == 15) printf("\n"); + } + printf("\n"); + + printf("Number of truncations per encoded match length histogram:\n"); + for (uint i = 0; i <= CLZBase::cMaxMatchLen; i++) + { + printf("%05u ", m_match_truncation_hist[i]); + if ((i & 15) == 15) printf("\n"); + } + printf("\n"); + + for (uint s = 0; s < CLZBase::cNumStates; s++) + { + printf("-- Match type truncation hist for state %u:\n", s); + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_match_type_truncation_hist[s]); i++) + { + printf("%u truncated (%3.1f%%), %u not truncated\n", m_match_type_truncation_hist[s][i], 100.0f * (float)m_match_type_truncation_hist[s][i] / (m_match_type_truncation_hist[s][i] + m_match_type_was_not_truncated_hist[s][i]), m_match_type_was_not_truncated_hist[s][i]); + } + } +#endif + } + + void lzcompressor::coding_stats::update(const lzdecision& lzdec, const state& cur_state, const search_accelerator& dict, bit_cost_t cost) + { + m_total_bytes += lzdec.get_len(); + m_total_contexts++; + + float cost_in_bits = cost / (float)cBitCostScale; + LZHAM_ASSERT(cost_in_bits > 0.0f); + m_total_cost += cost_in_bits; + + m_context_stats.update(cost_in_bits); + + uint match_pred = cur_state.get_pred_char(dict, lzdec.m_pos, 1); + uint is_match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(match_pred, cur_state.m_cur_state); + + if (lzdec.m_len == 0) + { + float match_bit_cost = cur_state.m_is_match_model[is_match_model_index].get_cost(0) / (float)cBitCostScale; + + m_total_is_match0_bits_cost += match_bit_cost; + m_total_match_bits_cost += match_bit_cost; + m_worst_match_bits_cost = math::maximum(m_worst_match_bits_cost, static_cast(match_bit_cost)); + m_total_nonmatches++; + + if (cur_state.m_cur_state < CLZBase::cNumLitStates) + { + m_lit_stats.update(cost_in_bits); + } + else + { + m_delta_lit_stats.update(cost_in_bits); + } + } + else if (lzdec.m_len <= CLZBase::cMaxMatchLen) + { + const uint match_len = lzdec.get_len(); + + { + uint match_dist = lzdec.get_match_dist(cur_state); + + uint cur_lookahead_size = dict.get_lookahead_size(); + + uint actual_match_len = dict.get_match_len(0, match_dist, LZHAM_MIN(cur_lookahead_size, static_cast(CLZBase::cMaxMatchLen))); + LZHAM_VERIFY(match_len <= actual_match_len); + + m_total_truncated_matches += match_len < actual_match_len; + m_match_truncation_len_hist[math::maximum(0, actual_match_len - match_len)]++; + + uint type_index = 4; + if (!lzdec.is_full_match()) + { + LZHAM_ASSUME(CLZBase::cMatchHistSize == 4); + type_index = -lzdec.m_dist - 1; + } + + if (actual_match_len > match_len) + { + m_match_truncation_hist[match_len]++; + + m_match_type_truncation_hist[cur_state.m_cur_state][type_index]++; + } + else + { + m_match_type_was_not_truncated_hist[cur_state.m_cur_state][type_index]++; + } + } + + float match_bit_cost = cur_state.m_is_match_model[is_match_model_index].get_cost(1) / (float)cBitCostScale; + m_total_is_match1_bits_cost += match_bit_cost; + m_total_match_bits_cost += match_bit_cost; + m_worst_match_bits_cost = math::maximum(m_worst_match_bits_cost, static_cast(match_bit_cost)); + m_total_matches++; + + if (lzdec.m_dist < 0) + { + // rep match + int match_hist_index = -lzdec.m_dist - 1; + LZHAM_ASSERT(match_hist_index < CLZBase::cMatchHistSize); + + m_rep_stats[match_hist_index].update(cost_in_bits); + + if (!match_hist_index) + { + // rep0 match + if (lzdec.m_len == 1) + { + m_rep0_len1_stats.update(cost_in_bits); + } + else + { + m_rep0_len2_plus_stats.update(cost_in_bits); + } + } + } + else + { + m_full_match_stats[math::minimum(cMaxMatchLen, match_len)].update(cost_in_bits); + + if (match_len == 2) + { + if (lzdec.m_dist <= 512) + m_total_near_len2_matches++; + else + m_total_far_len2_matches++; + + m_max_len2_dist = LZHAM_MAX((int)m_max_len2_dist, lzdec.m_dist); + } + } + } + else + { + // TODO: Handle huge matches. + } + } +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/lzhamdecomp/lzham_decomp.h b/r5dev/thirdparty/lzham/lzhamdecomp/lzham_decomp.h new file mode 100644 index 00000000..eb9a74d7 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamdecomp/lzham_decomp.h @@ -0,0 +1,37 @@ +// File: lzham_decomp.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once +#include "../include/lzham.h" + +namespace lzham +{ + void LZHAM_CDECL lzham_lib_set_memory_callbacks(lzham_realloc_func pRealloc, lzham_msize_func pMSize, void* pUser_data); + + lzham_decompress_state_ptr LZHAM_CDECL lzham_lib_decompress_init(const lzham_decompress_params *pParams); + + lzham_decompress_state_ptr LZHAM_CDECL lzham_lib_decompress_reinit(lzham_decompress_state_ptr pState, const lzham_decompress_params *pParams); + + lzham_decompress_checksums* LZHAM_CDECL lzham_lib_decompress_deinit(lzham_decompress_state_ptr pState); + + lzham_decompress_status_t LZHAM_CDECL lzham_lib_decompress( + lzham_decompress_state_ptr pState, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_bool no_more_input_bytes_flag); + + lzham_decompress_status_t LZHAM_CDECL lzham_lib_decompress_memory(const lzham_decompress_params *pParams, + lzham_uint8* pDst_buf, size_t *pDst_len, + const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32, lzham_uint32* pCrc32); + + int LZHAM_CDECL lzham_lib_z_inflateInit2(lzham_z_streamp pStream, int window_bits); + int LZHAM_CDECL lzham_lib_z_inflateInit(lzham_z_streamp pStream); + int LZHAM_CDECL lzham_lib_z_inflateReset(lzham_z_streamp pStream); + int LZHAM_CDECL lzham_lib_z_inflate(lzham_z_streamp pStream, int flush); + int LZHAM_CDECL lzham_lib_z_inflateEnd(lzham_z_streamp pStream); + int LZHAM_CDECL lzham_lib_z_uncompress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len); + + const char * LZHAM_CDECL lzham_lib_z_error(int err); + lzham_z_ulong lzham_lib_z_adler32(lzham_z_ulong adler, const unsigned char *ptr, size_t buf_len); + lzham_z_ulong LZHAM_CDECL lzham_lib_z_crc32(lzham_z_ulong crc, const lzham_uint8 *ptr, size_t buf_len); + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecomp.cpp b/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecomp.cpp new file mode 100644 index 00000000..53deceb1 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecomp.cpp @@ -0,0 +1,1590 @@ +// File: lzham_lzdecomp.cpp +// See Copyright Notice and license at the end of include/lzham.h +// +// See "Coroutines in C": +// http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html +// Also see "Protothreads - Lightweight, Stackless Threads in C": +// http://www.sics.se/~adam/pt/ +#include "../include/lzham_core.h" +#include "lzham_decomp.h" +#include "../include/lzham_symbol_codec.h" +#include "../include/lzham_checksum.h" +#include "lzham_lzdecompbase.h" + +using namespace lzham; + +namespace lzham +{ + static const uint8 s_literal_next_state[24] = + { + 0, 0, 0, 0, 1, 2, 3, // 0-6: literal states + 4, 5, 6, 4, 5, // 7-11: match states + 7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10 // 12-23: unused + }; + + static const uint s_huge_match_base_len[4] = { CLZDecompBase::cMaxMatchLen + 1, CLZDecompBase::cMaxMatchLen + 1 + 256, CLZDecompBase::cMaxMatchLen + 1 + 256 + 1024, CLZDecompBase::cMaxMatchLen + 1 + 256 + 1024 + 4096 }; + static const uint8 s_huge_match_code_len[4] = { 8, 10, 12, 16 }; + + struct lzham_decompressor + { + void init(); + + template lzham_decompress_status_t decompress(); + + void reset_all_tables(); + void reset_huffman_table_update_rates(); + + int m_state; + + CLZDecompBase m_lzBase; + symbol_codec m_codec; + + uint32 m_raw_decomp_buf_size; + uint8 *m_pRaw_decomp_buf; + uint8 *m_pDecomp_buf; + uint32 m_decomp_adler32; + uint32 m_decomp_crc32; + + const uint8 *m_pIn_buf; + size_t *m_pIn_buf_size; + uint8 *m_pOut_buf; + size_t *m_pOut_buf_size; + bool m_no_more_input_bytes_flag; + + uint8 *m_pOrig_out_buf; + size_t m_orig_out_buf_size; + + lzham_decompress_params m_params; + + lzham_decompress_status_t m_status; + +#if LZHAM_USE_ALL_ARITHMETIC_CODING + typedef adaptive_arith_data_model sym_data_model; +#else + typedef quasi_adaptive_huffman_data_model sym_data_model; +#endif + + sym_data_model m_lit_table[1 << CLZDecompBase::cNumLitPredBits]; + sym_data_model m_delta_lit_table[1 << CLZDecompBase::cNumDeltaLitPredBits]; + sym_data_model m_main_table; + sym_data_model m_rep_len_table[2]; + sym_data_model m_large_len_table[2]; + sym_data_model m_dist_lsb_table; + + adaptive_bit_model m_is_match_model[CLZDecompBase::cNumStates * (1 << CLZDecompBase::cNumIsMatchContextBits)]; + adaptive_bit_model m_is_rep_model[CLZDecompBase::cNumStates]; + adaptive_bit_model m_is_rep0_model[CLZDecompBase::cNumStates]; + adaptive_bit_model m_is_rep0_single_byte_model[CLZDecompBase::cNumStates]; + adaptive_bit_model m_is_rep1_model[CLZDecompBase::cNumStates]; + adaptive_bit_model m_is_rep2_model[CLZDecompBase::cNumStates]; + + uint m_dst_ofs; + + uint m_step; + uint m_block_step; + uint m_initial_step; + + uint m_block_index; + + int m_match_hist0; + int m_match_hist1; + int m_match_hist2; + int m_match_hist3; + uint m_cur_state; + + uint m_start_block_dst_ofs; + uint m_prev_char; + uint m_prev_prev_char; + + uint m_block_type; + + const uint8 *m_pFlush_src; + size_t m_flush_num_bytes_remaining; + size_t m_flush_n; + + uint m_seed_bytes_to_ignore_when_flushing; + + uint m_file_src_file_adler32; + uint m_file_src_file_crc32; + + uint m_rep_lit0; + uint m_match_len; + uint m_match_slot; + uint m_extra_bits; + uint m_num_extra_bits; + + uint m_src_ofs; + const uint8* m_pCopy_src; + uint m_num_raw_bytes_remaining; + + uint m_debug_is_match; + uint m_debug_match_len; + uint m_debug_match_dist; + uint m_debug_lit; + + lzham_decompress_status_t m_z_last_status; + uint m_z_first_call; + uint m_z_has_flushed; + uint m_z_cmf; + uint m_z_flg; + uint m_z_dict_adler32; + + uint m_tmp; + }; + + // Ordinarily I dislike macros like this, but in this case I think using them makes the decompression function easier to follow. + + // Coroutine helpers. + #define LZHAM_CR_INITIAL_STATE 0 + #define LZHAM_CR_BEGIN(state) switch( state ) { case LZHAM_CR_INITIAL_STATE: + #define LZHAM_CR_RETURN(state, result) do { state = __LINE__; return (result); case __LINE__:; } while (0) + #define LZHAM_CR_FINISH } + + // Helpers to save/restore local variables (hopefully CPU registers) to memory. + #define LZHAM_RESTORE_STATE LZHAM_RESTORE_LOCAL_STATE \ + match_hist0 = m_match_hist0; match_hist1 = m_match_hist1; match_hist2 = m_match_hist2; match_hist3 = m_match_hist3; \ + cur_state = m_cur_state; prev_char = m_prev_char; prev_prev_char = m_prev_prev_char; dst_ofs = m_dst_ofs; + + #define LZHAM_SAVE_STATE LZHAM_SAVE_LOCAL_STATE \ + m_match_hist0 = match_hist0; m_match_hist1 = match_hist1; m_match_hist2 = match_hist2; m_match_hist3 = match_hist3; \ + m_cur_state = cur_state; m_prev_char = prev_char; m_prev_prev_char = prev_prev_char; m_dst_ofs = dst_ofs; + + // Helper that coroutine returns to the caller with a request for more input bytes. + #define LZHAM_DECODE_NEEDS_BYTES \ + LZHAM_SAVE_STATE \ + for ( ; ; ) \ + { \ + *m_pIn_buf_size = static_cast(m_codec.decode_get_bytes_consumed()); \ + *m_pOut_buf_size = 0; \ + LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_NEEDS_MORE_INPUT); \ + m_codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf, m_no_more_input_bytes_flag); \ + if ((m_codec.m_decode_buf_eof) || (m_codec.m_decode_buf_size)) break; \ + } \ + LZHAM_RESTORE_STATE + + #if LZHAM_PLATFORM_X360 + #define LZHAM_BULK_MEMCPY XMemCpy + #define LZHAM_MEMCPY memcpy + #else + #define LZHAM_BULK_MEMCPY memcpy + #define LZHAM_MEMCPY memcpy + #endif + // Flush the output buffer/dictionary by doing a coroutine return to the caller. + // The caller must permit the decompressor to flush total_bytes from the dictionary, or (in the + // case of corrupted data, or a bug) we must report a DEST_BUF_TOO_SMALL error. + #define LZHAM_FLUSH_OUTPUT_BUFFER(total_bytes) \ + LZHAM_SAVE_STATE \ + m_pFlush_src = m_pDecomp_buf + m_seed_bytes_to_ignore_when_flushing; \ + m_flush_num_bytes_remaining = total_bytes - m_seed_bytes_to_ignore_when_flushing; \ + m_seed_bytes_to_ignore_when_flushing = 0; \ + while (m_flush_num_bytes_remaining) \ + { \ + m_flush_n = LZHAM_MIN(m_flush_num_bytes_remaining, *m_pOut_buf_size); \ + if (0 == (m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_COMPUTE_ADLER32)) \ + { \ + LZHAM_BULK_MEMCPY(m_pOut_buf, m_pFlush_src, m_flush_n); \ + } \ + else \ + { \ + size_t copy_ofs = 0; \ + while (copy_ofs < m_flush_n) \ + { \ + const uint cBytesToMemCpyPerIteration = 8192U; \ + size_t bytes_to_copy = LZHAM_MIN((size_t)(m_flush_n - copy_ofs), cBytesToMemCpyPerIteration); \ + LZHAM_MEMCPY(m_pOut_buf + copy_ofs, m_pFlush_src + copy_ofs, bytes_to_copy); \ + m_decomp_adler32 = adler32(m_pFlush_src + copy_ofs, bytes_to_copy, m_decomp_adler32); \ + m_decomp_crc32 = crc32(m_decomp_crc32, m_pFlush_src + copy_ofs, bytes_to_copy); \ + copy_ofs += bytes_to_copy; \ + } \ + } \ + *m_pIn_buf_size = static_cast(m_codec.decode_get_bytes_consumed()); \ + *m_pOut_buf_size = m_flush_n; \ + LZHAM_CR_RETURN(m_state, m_flush_n ? LZHAM_DECOMP_STATUS_NOT_FINISHED : LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT); \ + m_codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf, m_no_more_input_bytes_flag); \ + m_pFlush_src += m_flush_n; \ + m_flush_num_bytes_remaining -= m_flush_n; \ + } \ + LZHAM_RESTORE_STATE \ + + #if LZHAM_USE_ALL_ARITHMETIC_CODING + #define LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, result, model) LZHAM_SYMBOL_CODEC_DECODE_ADAPTIVE_ARITHMETIC(codec, result, model) + #else + #define LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, result, model) LZHAM_SYMBOL_CODEC_DECODE_ADAPTIVE_HUFFMAN(codec, result, model) + #endif + + //------------------------------------------------------------------------------------------------------------------ + void lzham_decompressor::init() + { + m_lzBase.init_position_slots(m_params.m_dict_size_log2); + +#ifdef LZHAM_LZDEBUG + if (m_pDecomp_buf) + memset(m_pDecomp_buf, 0xCE, 1U << m_params.m_dict_size_log2); +#endif + + m_state = LZHAM_CR_INITIAL_STATE; + m_step = 0; + m_block_step = 0; + m_block_index = 0; + m_initial_step = 0; + + m_dst_ofs = 0; + + m_pIn_buf = NULL; + m_pIn_buf_size = NULL; + m_pOut_buf = NULL; + m_pOut_buf_size = NULL; + m_no_more_input_bytes_flag = false; + m_status = LZHAM_DECOMP_STATUS_NOT_FINISHED; + m_pOrig_out_buf = NULL; + m_orig_out_buf_size = 0; + m_decomp_adler32 = cInitAdler32; + m_decomp_crc32 = cInitCRC32; + m_seed_bytes_to_ignore_when_flushing = 0; + + m_z_last_status = LZHAM_DECOMP_STATUS_NOT_FINISHED; + m_z_first_call = 1; + m_z_has_flushed = 0; + m_z_cmf = 0; + m_z_flg = 0; + m_z_dict_adler32 = 0; + + m_tmp = 0; + } + + void lzham_decompressor::reset_all_tables() + { + m_lit_table[0].reset(); + for (uint i = 1; i < LZHAM_ARRAY_SIZE(m_lit_table); i++) + m_lit_table[i] = m_lit_table[0]; + + m_delta_lit_table[0].reset(); + for (uint i = 1; i < LZHAM_ARRAY_SIZE(m_delta_lit_table); i++) + m_delta_lit_table[i] = m_delta_lit_table[0]; + + m_main_table.reset(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_rep_len_table); i++) + m_rep_len_table[i].reset(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_large_len_table); i++) + m_large_len_table[i].reset(); + + m_dist_lsb_table.reset(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_match_model); i++) + m_is_match_model[i].clear(); + + for (uint i = 0; i < CLZDecompBase::cNumStates; i++) + { + m_is_rep_model[i].clear(); + m_is_rep0_model[i].clear(); + m_is_rep0_single_byte_model[i].clear(); + m_is_rep1_model[i].clear(); + m_is_rep2_model[i].clear(); + } + } + + void lzham_decompressor::reset_huffman_table_update_rates() + { + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_lit_table); i++) + m_lit_table[i].reset_update_rate(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_delta_lit_table); i++) + m_delta_lit_table[i].reset_update_rate(); + + m_main_table.reset_update_rate(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_rep_len_table); i++) + m_rep_len_table[i].reset_update_rate(); + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_large_len_table); i++) + m_large_len_table[i].reset_update_rate(); + + m_dist_lsb_table.reset_update_rate(); + } + + //------------------------------------------------------------------------------------------------------------------ + // Decompression method. Implemented as a coroutine so it can be paused and resumed to support streaming. + //------------------------------------------------------------------------------------------------------------------ + template + lzham_decompress_status_t lzham_decompressor::decompress() + { + // Important: This function is a coroutine. ANY locals variables that need to be preserved across coroutine + // returns must be either be a member variable, or a local which is saved/restored to a member variable at + // the right times. (This makes this function difficult to follow and freaking ugly due to the macros of doom - but hey it works.) + // The most often used variables are in locals so the compiler hopefully puts them into CPU registers. + symbol_codec &codec = m_codec; + const uint dict_size = 1U << m_params.m_dict_size_log2; + const uint dict_size_mask = unbuffered ? UINT_MAX : (dict_size - 1); + + int match_hist0 = 0, match_hist1 = 0, match_hist2 = 0, match_hist3 = 0; + uint cur_state = 0, prev_char = 0, prev_prev_char = 0, dst_ofs = 0; + + const size_t out_buf_size = *m_pOut_buf_size; + + uint8* pDst = unbuffered ? reinterpret_cast(m_pOut_buf) : reinterpret_cast(m_pDecomp_buf); + uint8* pDst_end = unbuffered ? (reinterpret_cast(m_pOut_buf) + out_buf_size) : (reinterpret_cast(m_pDecomp_buf) + dict_size); + + LZHAM_SYMBOL_CODEC_DECODE_DECLARE(codec); + +#define LZHAM_SAVE_LOCAL_STATE +#define LZHAM_RESTORE_LOCAL_STATE + + // Important: Do not use any switch() statements below here. + LZHAM_CR_BEGIN(m_state) + + if ((!unbuffered) && (m_params.m_num_seed_bytes)) + { + LZHAM_BULK_MEMCPY(pDst, m_params.m_pSeed_bytes, m_params.m_num_seed_bytes); + dst_ofs += m_params.m_num_seed_bytes; + if (dst_ofs >= dict_size) + dst_ofs = 0; + else + m_seed_bytes_to_ignore_when_flushing = dst_ofs; + } + + if (!m_codec.start_decoding(m_pIn_buf, *m_pIn_buf_size, m_no_more_input_bytes_flag, NULL, NULL)) + return LZHAM_DECOMP_STATUS_FAILED_INITIALIZING; + + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec); + + { + bool fast_table_updating, use_polar_codes; + + if (m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_READ_ZLIB_STREAM) + { + uint check; + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_z_cmf, 8); + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_z_flg, 8); + check = ((m_z_cmf << 8) + m_z_flg) % 31; + if ((check != 0) || ((m_z_cmf & 15) != LZHAM_Z_LZHAM)) + return LZHAM_DECOMP_STATUS_FAILED_BAD_ZLIB_HEADER; + if (m_z_flg & 32) + { + if ((!m_params.m_pSeed_bytes) || (unbuffered)) + return LZHAM_DECOMP_STATUS_FAILED_NEED_SEED_BYTES; + m_z_dict_adler32 = 0; + for (m_tmp = 0; m_tmp < 4; ++m_tmp) + { + uint n; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, n, 8); + m_z_dict_adler32 = (m_z_dict_adler32 << 8) | n; + } + if (adler32(m_params.m_pSeed_bytes, m_params.m_num_seed_bytes) != m_z_dict_adler32) + return LZHAM_DECOMP_STATUS_FAILED_BAD_SEED_BYTES; + } + } + + { + uint tmp; + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, tmp, 2); + fast_table_updating = (tmp & 2) != 0; + use_polar_codes = (tmp & 1) != 0; + } + + bool succeeded = m_lit_table[0].init(false, 256, fast_table_updating, use_polar_codes); + for (uint i = 1; i < LZHAM_ARRAY_SIZE(m_lit_table); i++) + succeeded = succeeded && m_lit_table[i].assign(m_lit_table[0]); + + succeeded = succeeded && m_delta_lit_table[0].init(false, 256, fast_table_updating, use_polar_codes); + for (uint i = 1; i < LZHAM_ARRAY_SIZE(m_delta_lit_table); i++) + succeeded = succeeded && m_delta_lit_table[i].assign(m_delta_lit_table[0]); + + succeeded = succeeded && m_main_table.init(false, CLZDecompBase::cLZXNumSpecialLengths + (m_lzBase.m_num_lzx_slots - CLZDecompBase::cLZXLowestUsableMatchSlot) * 8, fast_table_updating, use_polar_codes); + + for (uint i = 0; i < 2; i++) + { + succeeded = succeeded && m_rep_len_table[i].init(false, CLZDecompBase::cNumHugeMatchCodes + (CLZDecompBase::cMaxMatchLen - CLZDecompBase::cMinMatchLen + 1), fast_table_updating, use_polar_codes); + succeeded = succeeded && m_large_len_table[i].init(false, CLZDecompBase::cNumHugeMatchCodes + CLZDecompBase::cLZXNumSecondaryLengths, fast_table_updating, use_polar_codes); + } + + succeeded = succeeded && m_dist_lsb_table.init(false, 16, fast_table_updating, use_polar_codes); + if (!succeeded) + return LZHAM_DECOMP_STATUS_FAILED_INITIALIZING; + + for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_match_model); i++) + m_is_match_model[i].clear(); + + for (uint i = 0; i < CLZDecompBase::cNumStates; i++) + { + m_is_rep_model[i].clear(); + m_is_rep0_model[i].clear(); + m_is_rep0_single_byte_model[i].clear(); + m_is_rep1_model[i].clear(); + m_is_rep2_model[i].clear(); + } + } + + // Output block loop. + do + { +#ifdef LZHAM_LZDEBUG + uint outer_sync_marker; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, k, 12); + LZHAM_VERIFY(outer_sync_marker == 166); +#endif + + // Decode block type. + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_block_type, CLZDecompBase::cBlockHeaderBits); + + if (m_block_type == CLZDecompBase::cSyncBlock) + { + // Sync block + // Reset either the symbol table update rates, or all statistics, then force a coroutine return to give the caller a chance to handle the output right now. + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_tmp, CLZDecompBase::cBlockFlushTypeBits); + if (m_tmp == 1) + reset_huffman_table_update_rates(); + else if (m_tmp == 2) + reset_all_tables(); + + LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec); + + uint n; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, n, 16); + if (n != 0) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + *m_pIn_buf_size = static_cast(codec.decode_get_bytes_consumed()); + *m_pOut_buf_size = 0; + for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_BAD_SYNC_BLOCK); } + } + + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, n, 16); + if (n != 0xFFFF) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + *m_pIn_buf_size = static_cast(codec.decode_get_bytes_consumed()); + *m_pOut_buf_size = 0; + for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_BAD_SYNC_BLOCK); } + } + + if (m_tmp == 2) + { + // It's a full flush, so immediately give caller whatever output we have. Also gives the caller a chance to reposition the input stream ptr somewhere else before continuing. + // It would be nice to do this with partial flushes too, but the current way the output buffer is flushed makes this tricky. + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + + if ((!unbuffered) && (dst_ofs)) + { + LZHAM_FLUSH_OUTPUT_BUFFER(dst_ofs); + } + else + { + *m_pIn_buf_size = static_cast(codec.decode_get_bytes_consumed()); + *m_pOut_buf_size = dst_ofs; + + LZHAM_SAVE_STATE + LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_NOT_FINISHED); + LZHAM_RESTORE_STATE + + m_codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf, m_no_more_input_bytes_flag); + } + + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec); + + dst_ofs = 0; + } + } + else if (m_block_type == CLZDecompBase::cRawBlock) + { + // Raw block handling is complex because we ultimately want to (safely) handle as many bytes as possible using a small number of memcpy()'s. + uint num_raw_bytes_remaining; + num_raw_bytes_remaining = 0; + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE m_num_raw_bytes_remaining = num_raw_bytes_remaining; +#define LZHAM_RESTORE_LOCAL_STATE num_raw_bytes_remaining = m_num_raw_bytes_remaining; + + // Determine how large this raw block is. + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, num_raw_bytes_remaining, 24); + + // Get and verify raw block length check bits. + uint num_raw_bytes_check_bits; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, num_raw_bytes_check_bits, 8); + uint raw_bytes_remaining0, raw_bytes_remaining1, raw_bytes_remaining2; + raw_bytes_remaining0 = num_raw_bytes_remaining & 0xFF; + raw_bytes_remaining1 = (num_raw_bytes_remaining >> 8) & 0xFF; + raw_bytes_remaining2 = (num_raw_bytes_remaining >> 16) & 0xFF; + if (num_raw_bytes_check_bits != ((raw_bytes_remaining0 ^ raw_bytes_remaining1) ^ raw_bytes_remaining2)) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + *m_pIn_buf_size = static_cast(codec.decode_get_bytes_consumed()); + *m_pOut_buf_size = 0; + for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_BAD_RAW_BLOCK); } + } + + num_raw_bytes_remaining++; + + // Discard any partial bytes from the bit buffer (align up to the next byte). + LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec); + + // Flush any full bytes from the bit buffer. + do + { + int b; + LZHAM_SYMBOL_CODEC_DECODE_REMOVE_BYTE_FROM_BIT_BUF(codec, b); + if (b < 0) + break; + + if ((unbuffered) && (dst_ofs >= out_buf_size)) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + *m_pIn_buf_size = static_cast(codec.decode_get_bytes_consumed()); + *m_pOut_buf_size = 0; + for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_DEST_BUF_TOO_SMALL); } + } + + pDst[dst_ofs++] = static_cast(b); + + if ((!unbuffered) && (dst_ofs > dict_size_mask)) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + LZHAM_FLUSH_OUTPUT_BUFFER(dict_size); + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec); + dst_ofs = 0; + } + + num_raw_bytes_remaining--; + } while (num_raw_bytes_remaining); + + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + + // Now handle the bulk of the raw data with memcpy(). + while (num_raw_bytes_remaining) + { + uint64 in_buf_ofs, in_buf_remaining; + in_buf_ofs = codec.decode_get_bytes_consumed(); + in_buf_remaining = *m_pIn_buf_size - in_buf_ofs; + + while (!in_buf_remaining) + { + // We need more bytes from the caller. + *m_pIn_buf_size = static_cast(in_buf_ofs); + *m_pOut_buf_size = 0; + + if (m_no_more_input_bytes_flag) + { + for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_EXPECTED_MORE_RAW_BYTES); } + } + + LZHAM_SAVE_STATE + LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_NEEDS_MORE_INPUT); + LZHAM_RESTORE_STATE + + m_codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf, m_no_more_input_bytes_flag); + + in_buf_ofs = 0; + in_buf_remaining = *m_pIn_buf_size; + } + + // Determine how many bytes we can safely memcpy() in a single call. + uint num_bytes_to_copy; + num_bytes_to_copy = static_cast(LZHAM_MIN(num_raw_bytes_remaining, in_buf_remaining)); + if (!unbuffered) + num_bytes_to_copy = LZHAM_MIN(num_bytes_to_copy, dict_size - dst_ofs); + + if ((unbuffered) && ((dst_ofs + num_bytes_to_copy) > out_buf_size)) + { + // Output buffer is not large enough. + *m_pIn_buf_size = static_cast(in_buf_ofs); + *m_pOut_buf_size = 0; + for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_DEST_BUF_TOO_SMALL); } + } + + // Copy the raw bytes. + LZHAM_BULK_MEMCPY(pDst + dst_ofs, m_pIn_buf + in_buf_ofs, num_bytes_to_copy); + + in_buf_ofs += num_bytes_to_copy; + num_raw_bytes_remaining -= num_bytes_to_copy; + + codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf + in_buf_ofs, m_no_more_input_bytes_flag); + + dst_ofs += num_bytes_to_copy; + + if ((!unbuffered) && (dst_ofs > dict_size_mask)) + { + LZHAM_ASSERT(dst_ofs == dict_size); + + LZHAM_FLUSH_OUTPUT_BUFFER(dict_size); + + dst_ofs = 0; + } + } + + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec); + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE +#define LZHAM_RESTORE_LOCAL_STATE + } + else if (m_block_type == CLZDecompBase::cCompBlock) + { + LZHAM_SYMBOL_CODEC_DECODE_ARITH_START(codec) + + match_hist0 = 1; + match_hist1 = 1; + match_hist2 = 1; + match_hist3 = 1; + cur_state = 0; + prev_char = 0; + prev_prev_char = 0; + + m_start_block_dst_ofs = dst_ofs; + + { + uint block_flush_type; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, block_flush_type, CLZDecompBase::cBlockFlushTypeBits); + if (block_flush_type == 1) + reset_huffman_table_update_rates(); + else if (block_flush_type == 2) + reset_all_tables(); + } + +#ifdef LZHAM_LZDEBUG + m_initial_step = m_step; + m_block_step = 0; + for ( ; ; m_step++, m_block_step++) +#else + for ( ; ; ) +#endif + { +#ifdef LZHAM_LZDEBUG + uint sync_marker; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, x, CLZDecompBase::cLZHAMDebugSyncMarkerBits); + LZHAM_VERIFY(sync_marker == CLZDecompBase::cLZHAMDebugSyncMarkerValue); + + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_debug_is_match, 1); + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_debug_match_len, 17); + + uint debug_cur_state; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, debug_cur_state, 4); + LZHAM_VERIFY(cur_state == debug_cur_state); +#endif + +#ifdef _DEBUG +{ + uint total_block_bytes = ((dst_ofs - m_start_block_dst_ofs) & dict_size_mask); + if (total_block_bytes > 0) + { + LZHAM_ASSERT(prev_char == pDst[(dst_ofs - 1) & dict_size_mask]); + } + else + { + LZHAM_ASSERT(prev_char == 0); + } + + if (total_block_bytes > 1) + { + LZHAM_ASSERT(prev_prev_char == pDst[(dst_ofs - 2) & dict_size_mask]); + } + else + { + LZHAM_ASSERT(prev_prev_char == 0); + } +} +#endif + // Read "is match" bit. + uint match_model_index; + match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(prev_char, cur_state); + LZHAM_ASSERT(match_model_index < LZHAM_ARRAY_SIZE(m_is_match_model)); + + uint is_match_bit; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_match_bit, m_is_match_model[match_model_index]); + +#ifdef LZHAM_LZDEBUG + LZHAM_VERIFY(is_match_bit == m_debug_is_match); +#endif + + if (LZHAM_BUILTIN_EXPECT(!is_match_bit, 0)) + { + // Handle literal. + +#ifdef LZHAM_LZDEBUG + LZHAM_VERIFY(m_debug_match_len == 1); +#endif + +#ifdef LZHAM_LZDEBUG + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_debug_lit, 8); +#endif + + if ((unbuffered) && (LZHAM_BUILTIN_EXPECT(dst_ofs >= out_buf_size, 0))) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + *m_pIn_buf_size = static_cast(codec.decode_get_bytes_consumed()); + *m_pOut_buf_size = 0; + for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_DEST_BUF_TOO_SMALL); } + } + + if (LZHAM_BUILTIN_EXPECT(cur_state < CLZDecompBase::cNumLitStates, 1)) + { + // Regular literal + uint lit_pred; + lit_pred = (prev_char >> (8 - CLZDecompBase::cNumLitPredBits / 2)) | (prev_prev_char >> (8 - CLZDecompBase::cNumLitPredBits / 2)) << (CLZDecompBase::cNumLitPredBits / 2); + + uint r; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, r, m_lit_table[lit_pred]); + pDst[dst_ofs] = static_cast(r); + prev_prev_char = prev_char; + prev_char = r; + +#ifdef LZHAM_LZDEBUG + LZHAM_VERIFY(pDst[dst_ofs] == m_debug_lit); +#endif + } + else + { + // Delta literal + uint match_hist0_ofs, rep_lit0, rep_lit1; + + // Determine delta literal's partial context. + match_hist0_ofs = dst_ofs - match_hist0; + rep_lit0 = pDst[match_hist0_ofs & dict_size_mask]; + rep_lit1 = pDst[(match_hist0_ofs - 1) & dict_size_mask]; + + uint lit_pred; + lit_pred = (rep_lit0 >> (8 - CLZDecompBase::cNumDeltaLitPredBits / 2)) | + ((rep_lit1 >> (8 - CLZDecompBase::cNumDeltaLitPredBits / 2)) << CLZDecompBase::cNumDeltaLitPredBits / 2); + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE m_rep_lit0 = rep_lit0; +#define LZHAM_RESTORE_LOCAL_STATE rep_lit0 = m_rep_lit0; + +#ifdef LZHAM_LZDEBUG + uint debug_rep_lit0; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, debug_rep_lit0, 8); + LZHAM_VERIFY(debug_rep_lit0 == rep_lit0); +#endif + + uint r; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, r, m_delta_lit_table[lit_pred]); + r ^= rep_lit0; + pDst[dst_ofs] = static_cast(r); + prev_prev_char = prev_char; + prev_char = r; + +#ifdef LZHAM_LZDEBUG + LZHAM_VERIFY(pDst[dst_ofs] == m_debug_lit); +#endif + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE +#define LZHAM_RESTORE_LOCAL_STATE + } + + cur_state = s_literal_next_state[cur_state]; + + dst_ofs++; + if ((!unbuffered) && (LZHAM_BUILTIN_EXPECT(dst_ofs > dict_size_mask, 0))) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + LZHAM_FLUSH_OUTPUT_BUFFER(dict_size); + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec); + dst_ofs = 0; + } + } + else + { + // Handle match. + uint match_len; + match_len = 1; + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; +#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; + + // Determine if match is a rep_match, and if so what type. + uint is_rep; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep, m_is_rep_model[cur_state]); + if (LZHAM_BUILTIN_EXPECT(is_rep, 1)) + { + uint is_rep0; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep0, m_is_rep0_model[cur_state]); + if (LZHAM_BUILTIN_EXPECT(is_rep0, 1)) + { + uint is_rep0_len1; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep0_len1, m_is_rep0_single_byte_model[cur_state]); + if (LZHAM_BUILTIN_EXPECT(is_rep0_len1, 1)) + { + cur_state = (cur_state < CLZDecompBase::cNumLitStates) ? 9 : 11; + } + else + { + LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, match_len, m_rep_len_table[cur_state >= CLZDecompBase::cNumLitStates]); + match_len += CLZDecompBase::cMinMatchLen; + + if (match_len == (CLZDecompBase::cMaxMatchLen + 1)) + { + // Decode "huge" match length. + match_len = 0; + do + { + uint b; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, b, 1); + if (!b) + break; + match_len++; + } while (match_len < 3); + uint k; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, k, s_huge_match_code_len[match_len]); + match_len = s_huge_match_base_len[match_len] + k; + } + + cur_state = (cur_state < CLZDecompBase::cNumLitStates) ? 8 : 11; + } + } + else + { + LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, match_len, m_rep_len_table[cur_state >= CLZDecompBase::cNumLitStates]); + match_len += CLZDecompBase::cMinMatchLen; + + if (match_len == (CLZDecompBase::cMaxMatchLen + 1)) + { + // Decode "huge" match length. + match_len = 0; + do + { + uint b; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, b, 1); + if (!b) + break; + match_len++; + } while (match_len < 3); + uint k; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, k, s_huge_match_code_len[match_len]); + match_len = s_huge_match_base_len[match_len] + k; + } + + uint is_rep1; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep1, m_is_rep1_model[cur_state]); + if (LZHAM_BUILTIN_EXPECT(is_rep1, 1)) + { + uint temp = match_hist1; + match_hist1 = match_hist0; + match_hist0 = temp; + } + else + { + uint is_rep2; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep2, m_is_rep2_model[cur_state]); + + if (LZHAM_BUILTIN_EXPECT(is_rep2, 1)) + { + // rep2 + uint temp = match_hist2; + match_hist2 = match_hist1; + match_hist1 = match_hist0; + match_hist0 = temp; + } + else + { + // rep3 + uint temp = match_hist3; + match_hist3 = match_hist2; + match_hist2 = match_hist1; + match_hist1 = match_hist0; + match_hist0 = temp; + } + } + + cur_state = (cur_state < CLZDecompBase::cNumLitStates) ? 8 : 11; + } + } + else + { + // Handle normal/full match. + uint sym; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, sym, m_main_table); + sym -= CLZDecompBase::cLZXNumSpecialLengths; + + if (LZHAM_BUILTIN_EXPECT(static_cast(sym) < 0, 0)) + { + // Handle special symbols. + if (static_cast(sym) == (CLZDecompBase::cLZXSpecialCodeEndOfBlockCode - CLZDecompBase::cLZXNumSpecialLengths)) + break; + else + { + // Must be cLZXSpecialCodePartialStateReset. + match_hist0 = 1; + match_hist1 = 1; + match_hist2 = 1; + match_hist3 = 1; + cur_state = 0; + continue; + } + } + + // Low 3 bits of symbol = match length category, higher bits = distance category. + match_len = (sym & 7) + 2; + + uint match_slot; + match_slot = (sym >> 3) + CLZDecompBase::cLZXLowestUsableMatchSlot; + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; m_match_slot = match_slot; +#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; match_slot = m_match_slot; + + if (LZHAM_BUILTIN_EXPECT(match_len == 9, 0)) + { + // Match is >= 9 bytes, decode the actual length. + uint e; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, e, m_large_len_table[cur_state >= CLZDecompBase::cNumLitStates]); + match_len += e; + + if (match_len == (CLZDecompBase::cMaxMatchLen + 1)) + { + // Decode "huge" match length. + match_len = 0; + do + { + uint b; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, b, 1); + if (!b) + break; + match_len++; + } while (match_len < 3); + uint k; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, k, s_huge_match_code_len[match_len]); + match_len = s_huge_match_base_len[match_len] + k; + } + } + + uint num_extra_bits; + num_extra_bits = m_lzBase.m_lzx_position_extra_bits[match_slot]; + + uint extra_bits; + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; m_match_slot = match_slot; m_num_extra_bits = num_extra_bits; +#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; match_slot = m_match_slot; num_extra_bits = m_num_extra_bits; + + if (LZHAM_BUILTIN_EXPECT(num_extra_bits < 3, 0)) + { + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, extra_bits, num_extra_bits); + } + else + { + extra_bits = 0; + if (LZHAM_BUILTIN_EXPECT(num_extra_bits > 4, 1)) + { + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, extra_bits, num_extra_bits - 4); + extra_bits <<= 4; + } + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; m_match_slot = match_slot; m_extra_bits = extra_bits; +#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; match_slot = m_match_slot; extra_bits = m_extra_bits; + + uint j; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, j, m_dist_lsb_table); + extra_bits += j; + } + + match_hist3 = match_hist2; + match_hist2 = match_hist1; + match_hist1 = match_hist0; + match_hist0 = m_lzBase.m_lzx_position_base[match_slot] + extra_bits; + + cur_state = (cur_state < CLZDecompBase::cNumLitStates) ? CLZDecompBase::cNumLitStates : CLZDecompBase::cNumLitStates + 3; + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; +#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; + } + + // We have the match's length and distance, now do the copy. + +#ifdef LZHAM_LZDEBUG + LZHAM_VERIFY(match_len == m_debug_match_len); + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_debug_match_dist, 25); + uint d; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, d, 4); + m_debug_match_dist = (m_debug_match_dist << 4) | d; + LZHAM_VERIFY((uint)match_hist0 == m_debug_match_dist); +#endif + if ( (unbuffered) && LZHAM_BUILTIN_EXPECT((((size_t)match_hist0 > dst_ofs) || ((dst_ofs + match_len) > out_buf_size)), 0) ) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + *m_pIn_buf_size = static_cast(codec.decode_get_bytes_consumed()); + *m_pOut_buf_size = 0; + for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_BAD_CODE); } + } + + uint src_ofs; + const uint8* pCopy_src; + src_ofs = (dst_ofs - match_hist0) & dict_size_mask; + pCopy_src = pDst + src_ofs; + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; m_src_ofs = src_ofs; m_pCopy_src = pCopy_src; +#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; src_ofs = m_src_ofs; pCopy_src = m_pCopy_src; + + if ( (!unbuffered) && LZHAM_BUILTIN_EXPECT( ((LZHAM_MAX(src_ofs, dst_ofs) + match_len) > dict_size_mask), 0) ) + { + // Match source or destination wraps around the end of the dictionary to the beginning, so handle the copy one byte at a time. + do + { + uint8 c; + c = *pCopy_src++; + prev_prev_char = prev_char; + prev_char = c; + pDst[dst_ofs++] = c; + + if (LZHAM_BUILTIN_EXPECT(pCopy_src == pDst_end, 0)) + pCopy_src = pDst; + + if (LZHAM_BUILTIN_EXPECT(dst_ofs > dict_size_mask, 0)) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + LZHAM_FLUSH_OUTPUT_BUFFER(dict_size); + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec); + dst_ofs = 0; + } + + match_len--; + } while (LZHAM_BUILTIN_EXPECT(match_len > 0, 1)); + } + else + { + uint8* pCopy_dst = pDst + dst_ofs; + if (LZHAM_BUILTIN_EXPECT(match_hist0 == 1, 0)) + { + // Handle byte runs. + uint8 c = *pCopy_src; + if (LZHAM_BUILTIN_EXPECT(match_len < 8, 1)) + { + for (int i = match_len; i > 0; i--) + *pCopy_dst++ = c; + if (LZHAM_BUILTIN_EXPECT(match_len == 1, 1)) + prev_prev_char = prev_char; + else + prev_prev_char = c; + } + else + { + memset(pCopy_dst, c, match_len); + prev_prev_char = c; + } + prev_char = c; + } + else if (LZHAM_BUILTIN_EXPECT(match_len == 1, 1)) + { + // Handle single byte matches. + prev_prev_char = prev_char; + prev_char = *pCopy_src; + *pCopy_dst = static_cast(prev_char); + } + else + { + // Handle matches of length 2 or higher. + uint bytes_to_copy = match_len - 2; + if (LZHAM_BUILTIN_EXPECT(((bytes_to_copy < 8) || ((int)bytes_to_copy > match_hist0)), 1)) + { + for (int i = bytes_to_copy; i > 0; i--) + *pCopy_dst++ = *pCopy_src++; + } + else + { + LZHAM_MEMCPY(pCopy_dst, pCopy_src, bytes_to_copy); + pCopy_dst += bytes_to_copy; + pCopy_src += bytes_to_copy; + } + // Handle final 2 bytes of match specially, because we always track the last 2 bytes output in + // local variables (needed for computing context) to avoid load hit stores on some CPU's. + prev_prev_char = *pCopy_src++; + *pCopy_dst++ = static_cast(prev_prev_char); + + prev_char = *pCopy_src++; + *pCopy_dst++ = static_cast(prev_char); + } + dst_ofs += match_len; + } + } // lit or match + +#undef LZHAM_SAVE_LOCAL_STATE +#undef LZHAM_RESTORE_LOCAL_STATE +#define LZHAM_SAVE_LOCAL_STATE +#define LZHAM_RESTORE_LOCAL_STATE + } // for ( ; ; ) + +#ifdef LZHAM_LZDEBUG + uint end_sync_marker; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, end_sync_marker, 12); + LZHAM_VERIFY(end_sync_marker == 366); +#endif + LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec); + } + else if (m_block_type == CLZDecompBase::cEOFBlock) + { + // Received EOF. + m_status = LZHAM_DECOMP_STATUS_SUCCESS; + } + else + { + // This block type is currently undefined. + m_status = LZHAM_DECOMP_STATUS_FAILED_BAD_CODE; + } + + m_block_index++; + + } while (m_status == LZHAM_DECOMP_STATUS_NOT_FINISHED); + + if ((!unbuffered) && (dst_ofs)) + { + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + LZHAM_FLUSH_OUTPUT_BUFFER(dst_ofs); + LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec); + } + + if (m_status == LZHAM_DECOMP_STATUS_SUCCESS) + { + LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec); + LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_file_src_file_adler32, 16); + uint l; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, l, 16); + m_file_src_file_adler32 = (m_file_src_file_adler32 << 16) | l; + + if (m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_COMPUTE_ADLER32) + { + if (unbuffered) + { + m_decomp_adler32 = adler32(pDst, dst_ofs, cInitAdler32); + } + + if (m_file_src_file_adler32 != m_decomp_adler32) + { + m_status = LZHAM_DECOMP_STATUS_FAILED_ADLER32; + } + } + else + { + m_decomp_adler32 = m_file_src_file_adler32; + } + if (m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_COMPUTE_CRC32) + { + if (unbuffered) + { + m_decomp_crc32 = crc32(cInitCRC32, pDst, dst_ofs); + } + + //if (m_file_src_file_crc32 != m_decomp_crc32) + //{ + // printf("m_file_src_file_crc32 %zX\n", m_file_src_file_crc32); + // m_status = LZHAM_DECOMP_STATUS_FAILED_CRC32; + //} + } + else + { + m_decomp_crc32 = m_file_src_file_crc32; + } + } + + LZHAM_SYMBOL_CODEC_DECODE_END(codec); + + *m_pIn_buf_size = static_cast(codec.stop_decoding()); + *m_pOut_buf_size = unbuffered ? dst_ofs : 0; + LZHAM_CR_RETURN(m_state, m_status); + + for ( ; ; ) + { + *m_pIn_buf_size = 0; + *m_pOut_buf_size = 0; + LZHAM_CR_RETURN(m_state, m_status); + } + + LZHAM_CR_FINISH + + return m_status; + } + + static bool check_params(const lzham_decompress_params *pParams) + { + if ((!pParams) || (pParams->m_struct_size != sizeof(lzham_decompress_params))) + return false; + + if ((pParams->m_dict_size_log2 < CLZDecompBase::cMinDictSizeLog2) || (pParams->m_dict_size_log2 > CLZDecompBase::cMaxDictSizeLog2)) + return false; + + if (pParams->m_num_seed_bytes) + { + if (((pParams->m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED) != 0) || (!pParams->m_pSeed_bytes)) + return false; + if (pParams->m_num_seed_bytes > (1U << pParams->m_dict_size_log2)) + return false; + } + return true; + } + + lzham_decompress_state_ptr LZHAM_CDECL lzham_lib_decompress_init(const lzham_decompress_params *pParams) + { + LZHAM_ASSUME(CLZDecompBase::cMinDictSizeLog2 == LZHAM_MIN_DICT_SIZE_LOG2); + LZHAM_ASSUME(CLZDecompBase::cMaxDictSizeLog2 == LZHAM_MAX_DICT_SIZE_LOG2_X64); + + if (!check_params(pParams)) + return NULL; + + lzham_decompressor *pState = lzham_new(); + if (!pState) + return NULL; + + pState->m_params = *pParams; + + if (pState->m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED) + { + pState->m_pRaw_decomp_buf = NULL; + pState->m_raw_decomp_buf_size = 0; + pState->m_pDecomp_buf = NULL; + } + else + { + uint32 decomp_buf_size = 1U << pState->m_params.m_dict_size_log2; + pState->m_pRaw_decomp_buf = static_cast(lzham_malloc(decomp_buf_size + 15)); + if (!pState->m_pRaw_decomp_buf) + { + lzham_delete(pState); + return NULL; + } + pState->m_raw_decomp_buf_size = decomp_buf_size; + pState->m_pDecomp_buf = math::align_up_pointer(pState->m_pRaw_decomp_buf, 16); + } + + pState->init(); + + return pState; + } + + lzham_decompress_state_ptr LZHAM_CDECL lzham_lib_decompress_reinit(lzham_decompress_state_ptr p, const lzham_decompress_params *pParams) + { + if (!p) + return lzham_lib_decompress_init(pParams); + + lzham_decompressor *pState = static_cast(p); + + if (!check_params(pParams)) + return NULL; + + if (pState->m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED) + { + lzham_free(pState->m_pRaw_decomp_buf); + pState->m_pRaw_decomp_buf = NULL; + pState->m_raw_decomp_buf_size = 0; + pState->m_pDecomp_buf = NULL; + } + else + { + uint32 new_dict_size = 1U << pState->m_params.m_dict_size_log2; + if ((!pState->m_pRaw_decomp_buf) || (pState->m_raw_decomp_buf_size < new_dict_size)) + { + uint8 *pNew_dict = static_cast(lzham_realloc(pState->m_pRaw_decomp_buf, new_dict_size + 15)); + if (!pNew_dict) + return NULL; + pState->m_pRaw_decomp_buf = pNew_dict; + pState->m_raw_decomp_buf_size = new_dict_size; + pState->m_pDecomp_buf = math::align_up_pointer(pState->m_pRaw_decomp_buf, 16); + } + } + + pState->m_params = *pParams; + + pState->init(); + + return pState; + } + + lzham_decompress_checksums* LZHAM_CDECL lzham_lib_decompress_deinit(lzham_decompress_state_ptr p) + { + lzham_decompressor *pState = static_cast(p); + if (!pState) + return NULL; + + lzham_decompress_checksums* checksums = new lzham_decompress_checksums(); + + checksums->adler32 = pState->m_decomp_adler32; + checksums->crc32 = pState->m_decomp_crc32; + + lzham_free(pState->m_pRaw_decomp_buf); + lzham_delete(pState); + + return checksums; + } + + lzham_decompress_status_t LZHAM_CDECL lzham_lib_decompress( + lzham_decompress_state_ptr p, + const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, + lzham_uint8 *pOut_buf, size_t *pOut_buf_size, + lzham_bool no_more_input_bytes_flag) + { + lzham_decompressor *pState = static_cast(p); + + if ((!pState) || (!pState->m_params.m_dict_size_log2) || (!pIn_buf_size) || (!pOut_buf_size)) + { + return LZHAM_DECOMP_STATUS_INVALID_PARAMETER; + } + + if ((*pIn_buf_size) && (!pIn_buf)) + { + return LZHAM_DECOMP_STATUS_INVALID_PARAMETER; + } + + if ((*pOut_buf_size) && (!pOut_buf)) + { + return LZHAM_DECOMP_STATUS_INVALID_PARAMETER; + } + + pState->m_pIn_buf = pIn_buf; + pState->m_pIn_buf_size = pIn_buf_size; + pState->m_pOut_buf = pOut_buf; + pState->m_pOut_buf_size = pOut_buf_size; + pState->m_no_more_input_bytes_flag = (no_more_input_bytes_flag != 0); + + if (pState->m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED) + { + if (!pState->m_pOrig_out_buf) + { + pState->m_pOrig_out_buf = pOut_buf; + pState->m_orig_out_buf_size = *pOut_buf_size; + } + else + { + if ((pState->m_pOrig_out_buf != pOut_buf) || (pState->m_orig_out_buf_size != *pOut_buf_size)) + { + return LZHAM_DECOMP_STATUS_INVALID_PARAMETER; + } + } + } + + lzham_decompress_status_t status; + if (pState->m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED) + status = pState->decompress(); + else + status = pState->decompress(); + + return status; + } + + lzham_decompress_status_t LZHAM_CDECL lzham_lib_decompress_memory(const lzham_decompress_params *pParams, lzham_uint8* pDst_buf, size_t *pDst_len, const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32, lzham_uint32 *pCrc32) + { + if (!pParams) + return LZHAM_DECOMP_STATUS_INVALID_PARAMETER; + + lzham_decompress_params params(*pParams); + params.m_decompress_flags |= LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED; + + lzham_decompress_state_ptr pState = lzham_lib_decompress_init(¶ms); + if (!pState) + return LZHAM_DECOMP_STATUS_FAILED_INITIALIZING; + + lzham_decompress_status_t status = lzham_lib_decompress(pState, pSrc_buf, &src_len, pDst_buf, pDst_len, true); + lzham_decompress_checksums* checksums = lzham_lib_decompress_deinit(pState); + + if (pAdler32) + *pAdler32 = checksums->adler32; + if (pCrc32) + *pCrc32 = checksums->crc32; + + + return status; + } + + // ----------------- zlib-style API's + + int LZHAM_CDECL lzham_lib_z_inflateInit(lzham_z_streamp pStream) + { + return lzham_lib_z_inflateInit2(pStream, LZHAM_Z_DEFAULT_WINDOW_BITS); + } + + int LZHAM_CDECL lzham_lib_z_inflateInit2(lzham_z_streamp pStream, int window_bits) + { + if (!pStream) + return LZHAM_Z_STREAM_ERROR; + +#ifdef LZHAM_Z_API_FORCE_WINDOW_BITS + window_bits = LZHAM_Z_API_FORCE_WINDOW_BITS; +#endif + + int max_window_bits = LZHAM_64BIT_POINTERS ? LZHAM_MAX_DICT_SIZE_LOG2_X64 : LZHAM_MAX_DICT_SIZE_LOG2_X86; + if (labs(window_bits) > max_window_bits) + return LZHAM_Z_PARAM_ERROR; + + if (labs(window_bits) < LZHAM_MIN_DICT_SIZE_LOG2) + window_bits = (window_bits < 0) ? -LZHAM_MIN_DICT_SIZE_LOG2 : LZHAM_MIN_DICT_SIZE_LOG2; + + lzham_decompress_params params; + utils::zero_object(params); + params.m_struct_size = sizeof(lzham_decompress_params); + params.m_dict_size_log2 = labs(window_bits); + + params.m_decompress_flags = LZHAM_DECOMP_FLAG_COMPUTE_ADLER32; + if (window_bits > 0) + params.m_decompress_flags |= LZHAM_DECOMP_FLAG_READ_ZLIB_STREAM; + + lzham_decompress_state_ptr pState = lzham_lib_decompress_init(¶ms); + if (!pState) + return LZHAM_Z_MEM_ERROR; + pStream->state = static_cast(pState); + + pStream->data_type = 0; + pStream->adler32 = LZHAM_Z_ADLER32_INIT; + pStream->msg = NULL; + pStream->total_in = 0; + pStream->total_out = 0; + pStream->reserved = 0; + + return LZHAM_Z_OK; + } + + int LZHAM_CDECL lzham_lib_z_inflateReset(lzham_z_streamp pStream) + { + if ((!pStream) || (!pStream->state)) + return LZHAM_Z_STREAM_ERROR; + + lzham_decompress_state_ptr pState = static_cast(pStream->state); + lzham_decompressor *pDecomp = static_cast(pState); + + lzham_decompress_params params(pDecomp->m_params); + + if (!lzham_lib_decompress_reinit(pState, ¶ms)) + return LZHAM_Z_STREAM_ERROR; + + return LZHAM_Z_OK; + } + + int LZHAM_CDECL lzham_lib_z_inflate(lzham_z_streamp pStream, int flush) + { + if ((!pStream) || (!pStream->state)) + return LZHAM_Z_STREAM_ERROR; + + if ((flush == LZHAM_Z_PARTIAL_FLUSH) || (flush == LZHAM_Z_FULL_FLUSH)) + flush = LZHAM_Z_SYNC_FLUSH; + if (flush) + { + if ((flush != LZHAM_Z_SYNC_FLUSH) && (flush != LZHAM_Z_FINISH)) + return LZHAM_Z_STREAM_ERROR; + } + + size_t orig_avail_in = pStream->avail_in; + + lzham_decompress_state_ptr pState = static_cast(pStream->state); + lzham_decompressor *pDecomp = static_cast(pState); + if (pDecomp->m_z_last_status >= LZHAM_DECOMP_STATUS_FIRST_SUCCESS_OR_FAILURE_CODE) + return LZHAM_Z_DATA_ERROR; + + if (pDecomp->m_z_has_flushed && (flush != LZHAM_Z_FINISH)) + return LZHAM_Z_STREAM_ERROR; + pDecomp->m_z_has_flushed |= (flush == LZHAM_Z_FINISH); + + lzham_decompress_status_t status; + for ( ; ; ) + { + size_t in_bytes = pStream->avail_in; + size_t out_bytes = pStream->avail_out; + lzham_bool no_more_input_bytes_flag = (flush == LZHAM_Z_FINISH); + status = lzham_lib_decompress(pState, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, no_more_input_bytes_flag); + + pDecomp->m_z_last_status = status; + + pStream->next_in += (uint)in_bytes; + pStream->avail_in -= (uint)in_bytes; + pStream->total_in += (uint)in_bytes; + pStream->adler32 = pDecomp->m_decomp_adler32; + pStream->crc32 = pDecomp->m_decomp_crc32; + + pStream->next_out += (uint)out_bytes; + pStream->avail_out -= (uint)out_bytes; + pStream->total_out += (uint)out_bytes; + + if (status >= LZHAM_DECOMP_STATUS_FIRST_FAILURE_CODE) + { + if (status == LZHAM_DECOMP_STATUS_FAILED_NEED_SEED_BYTES) + return LZHAM_Z_NEED_DICT; + else + return LZHAM_Z_DATA_ERROR; // Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). + } + + if ((status == LZHAM_DECOMP_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) + return LZHAM_Z_BUF_ERROR; // Signal caller that we can't make forward progress without supplying more input, or by setting flush to LZHAM_Z_FINISH. + else if (flush == LZHAM_Z_FINISH) + { + // Caller has indicated that all remaining input was at next_in, and all remaining output will fit entirely in next_out. + // (The output buffer at next_out MUST be large to hold the remaining uncompressed data when flush==LZHAM_Z_FINISH). + if (status == LZHAM_DECOMP_STATUS_SUCCESS) + return LZHAM_Z_STREAM_END; + // If status is LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT, there must be at least 1 more byte on the way but the caller to lzham_decompress() supplied an empty output buffer. + // Something is wrong because the caller's output buffer should be large enough to hold the entire decompressed stream when flush==LZHAM_Z_FINISH. + else if (status == LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT) + return LZHAM_Z_BUF_ERROR; + } + else if ((status == LZHAM_DECOMP_STATUS_SUCCESS) || (!pStream->avail_in) || (!pStream->avail_out)) + break; + } + + return (status == LZHAM_DECOMP_STATUS_SUCCESS) ? LZHAM_Z_STREAM_END : LZHAM_Z_OK; + } + + int LZHAM_CDECL lzham_lib_z_inflateEnd(lzham_z_streamp pStream) + { + if (!pStream) + return LZHAM_Z_STREAM_ERROR; + + lzham_decompress_state_ptr pState = static_cast(pStream->state); + if (pState) + { + lzham_decompress_checksums* checksums = lzham_lib_decompress_deinit(pState); + + pStream->adler32 = checksums->adler32; + pStream->crc32 = checksums->crc32; + pStream->state = NULL; + } + + return LZHAM_Z_OK; + } + + int LZHAM_CDECL lzham_lib_z_uncompress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len) + { + lzham_z_stream stream; + int status; + memset(&stream, 0, sizeof(stream)); + + // In case lzham_z_ulong is 64-bits (argh I hate longs). + if ((source_len | *pDest_len) > 0xFFFFFFFFU) + return LZHAM_Z_PARAM_ERROR; + + stream.next_in = pSource; + stream.avail_in = (uint)source_len; + stream.next_out = pDest; + stream.avail_out = (uint)*pDest_len; + + status = lzham_lib_z_inflateInit(&stream); + if (status != LZHAM_Z_OK) + return status; + + status = lzham_lib_z_inflate(&stream, LZHAM_Z_FINISH); + if (status != LZHAM_Z_STREAM_END) + { + lzham_lib_z_inflateEnd(&stream); + return ((status == LZHAM_Z_BUF_ERROR) && (!stream.avail_in)) ? LZHAM_Z_DATA_ERROR : status; + } + *pDest_len = stream.total_out; + + return lzham_lib_z_inflateEnd(&stream); + } + + const char * LZHAM_CDECL lzham_lib_z_error(int err) + { + static struct + { + int m_err; + const char *m_pDesc; + } + s_error_descs[] = + { + { LZHAM_Z_OK, "" }, + { LZHAM_Z_STREAM_END, "stream end" }, + { LZHAM_Z_NEED_DICT, "need dictionary" }, + { LZHAM_Z_ERRNO, "file error" }, + { LZHAM_Z_STREAM_ERROR, "stream error" }, + { LZHAM_Z_DATA_ERROR, "data error" }, + { LZHAM_Z_MEM_ERROR, "out of memory" }, + { LZHAM_Z_BUF_ERROR, "buf error" }, + { LZHAM_Z_VERSION_ERROR, "version error" }, + { LZHAM_Z_PARAM_ERROR, "parameter error" } + }; + for (uint i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i) + if (s_error_descs[i].m_err == err) + return s_error_descs[i].m_pDesc; + return NULL; + } + + lzham_z_ulong lzham_lib_z_adler32(lzham_z_ulong adler, const unsigned char *ptr, size_t buf_len) + { + return adler32(ptr, buf_len, adler); + } + + lzham_z_ulong LZHAM_CDECL lzham_lib_z_crc32(lzham_z_ulong crc, const lzham_uint8 *ptr, size_t buf_len) + { + return crc32(crc, ptr, buf_len); + } + +} // namespace lzham diff --git a/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.cpp b/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.cpp new file mode 100644 index 00000000..2bd03266 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.cpp @@ -0,0 +1,46 @@ +// File: lzham_lzdecompbase.cpp +// See Copyright Notice and license at the end of include/lzham.h +#include "../include/lzham_core.h" +#include "lzham_lzdecompbase.h" + +namespace lzham +{ + void CLZDecompBase::init_position_slots(uint dict_size_log2) + { + m_dict_size_log2 = dict_size_log2; + m_dict_size = 1U << dict_size_log2; + + int i, j; + for (i = 0, j = 0; i < cLZXMaxPositionSlots; i += 2) + { + m_lzx_position_extra_bits[i] = (uint8)j; + m_lzx_position_extra_bits[i + 1] = (uint8)j; + + if ((i != 0) && (j < 25)) + j++; + } + + for (i = 0, j = 0; i < cLZXMaxPositionSlots; i++) + { + m_lzx_position_base[i] = j; + m_lzx_position_extra_mask[i] = (1 << m_lzx_position_extra_bits[i]) - 1; + j += (1 << m_lzx_position_extra_bits[i]); + } + + m_num_lzx_slots = 0; + + const uint largest_dist = m_dict_size - 1; + for (i = 0; i < cLZXMaxPositionSlots; i++) + { + if ( (largest_dist >= m_lzx_position_base[i]) && + (largest_dist < (m_lzx_position_base[i] + (1 << m_lzx_position_extra_bits[i])) ) ) + { + m_num_lzx_slots = i + 1; + break; + } + } + + LZHAM_VERIFY(m_num_lzx_slots); + } + +} //namespace lzham diff --git a/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.h b/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.h new file mode 100644 index 00000000..337f7d13 --- /dev/null +++ b/r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.h @@ -0,0 +1,90 @@ +// File: lzham_lzdecompbase.h +// See Copyright Notice and license at the end of include/lzham.h +#pragma once + +//#define LZHAM_LZDEBUG + +#define LZHAM_IS_MATCH_MODEL_INDEX(prev_char, cur_state) ((prev_char) >> (8 - CLZDecompBase::cNumIsMatchContextBits)) + ((cur_state) << CLZDecompBase::cNumIsMatchContextBits) + +#define LZHAM_USE_ALL_ARITHMETIC_CODING 0 + +#define LZHAM_RND_CONG(jcong) (69069U * jcong + 1234567U) + +namespace lzham +{ + struct CLZDecompBase + { + enum + { + cMinMatchLen = 2U, + cMaxMatchLen = 257U, + + cMaxHugeMatchLen = 65536, + + cMinDictSizeLog2 = 15, + cMaxDictSizeLog2 = 29, + + cMatchHistSize = 4, + cMaxLen2MatchDist = 2047 + }; + + enum + { + cLZXNumSecondaryLengths = 249, + + cNumHugeMatchCodes = 1, + cMaxHugeMatchCodeBits = 16, + + cLZXNumSpecialLengths = 2, + + cLZXLowestUsableMatchSlot = 1, + cLZXMaxPositionSlots = 128 + }; + + enum + { + cLZXSpecialCodeEndOfBlockCode = 0, + cLZXSpecialCodePartialStateReset = 1 + }; + + enum + { + cLZHAMDebugSyncMarkerValue = 666, + cLZHAMDebugSyncMarkerBits = 12 + }; + + enum + { + cBlockHeaderBits = 2, + cBlockCheckBits = 4, + cBlockFlushTypeBits = 2, + + cSyncBlock = 0, + cCompBlock = 1, + cRawBlock = 2, + cEOFBlock = 3 + }; + + enum + { + cNumStates = 12, + cNumLitStates = 7, + + cNumLitPredBits = 6, // must be even + cNumDeltaLitPredBits = 6, // must be even + + cNumIsMatchContextBits = 6 + }; + + uint m_dict_size_log2; + uint m_dict_size; + + uint m_num_lzx_slots; + uint m_lzx_position_base[cLZXMaxPositionSlots]; + uint m_lzx_position_extra_mask[cLZXMaxPositionSlots]; + uint8 m_lzx_position_extra_bits[cLZXMaxPositionSlots]; + + void init_position_slots(uint dict_size_log2); + }; + +} // namespace lzham