R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Compile LZHAM with the solution. Fix missing detours files for sdklauncher

Browse Source
This commit is contained in:
Amos 2022-01-06 15:08:39 +01:00
parent a0b7bbf366
commit b80be10c4d
62 changed files with 17238 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
r5dev/core/stdafx.h
View File

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

115
r5dev/dedicated.vcxproj
View File

@ -135,7 +135,7 @@
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>lzhamlib_x64D.lib;lzhamcomp_x64D.lib;lzhamdecomp_x64D.lib;d3d11.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>d3d11.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
<PostBuildEvent>
<Command>del "..\..\..\$(ProjectName)" &amp;&amp; copy /Y "$(TargetPath)" "..\..\..\</Command>
@ -162,7 +162,7 @@
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>lzhamlib_x64.lib;lzhamcomp_x64.lib;lzhamdecomp_x64.lib;d3d11.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>d3d11.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
<PostBuildEvent>
<Command>del "..\..\..\$(ProjectName)" &amp;&amp; copy /Y "$(TargetPath)" "..\..\..\</Command>
@ -215,7 +215,34 @@
<ClInclude Include="thirdparty\detours\include\idetour.h" />
<ClInclude Include="thirdparty\detours\include\syelog.h" />
<ClInclude Include="thirdparty\lzham\include\lzham.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_assert.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_checksum.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_config.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_core.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_helpers.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_huffman_codes.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_lzbase.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_match_accel.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_math.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_mem.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_null_threading.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_platform.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_polar_codes.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_prefix_coding.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_pthreads_threading.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_static_lib.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_symbol_codec.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_threading.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_timer.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_traits.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_types.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_utils.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_vector.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_win32_threading.h" />
<ClInclude Include="thirdparty\lzham\lzhamcomp\lzham_comp.h" />
<ClInclude Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_internal.h" />
<ClInclude Include="thirdparty\lzham\lzhamdecomp\lzham_decomp.h" />
<ClInclude Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecompbase.h" />
<ClInclude Include="thirdparty\spdlog\include\async.h" />
<ClInclude Include="thirdparty\spdlog\include\async_logger-inl.h" />
<ClInclude Include="thirdparty\spdlog\include\async_logger.h" />
@ -360,6 +387,10 @@
<ClCompile Include="squirrel\sqapi.cpp" />
<ClCompile Include="squirrel\sqinit.cpp" />
<ClCompile Include="squirrel\sqvm.cpp" />
<ClCompile Include="thirdparty\detours\src\creatwth.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\detours.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
@ -372,6 +403,86 @@
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_internal.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_state.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecomp.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecompbase.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_api.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_assert.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_checksum.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_huffman_codes.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_lzbase.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_match_accel.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_mem.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_platform.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_polar_codes.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_prefix_coding.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_pthreads_threading.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_symbol_codec.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_timer.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_vector.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_win32_threading.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="tier0\ConCommand.cpp" />
<ClCompile Include="tier0\completion.cpp" />
<ClCompile Include="tier0\cvar.cpp" />

168
r5dev/dedicated.vcxproj.filters
View File

@ -97,6 +97,18 @@
<Filter Include="sdk\bsplib">
<UniqueIdentifier>{8288ba1a-7609-42ef-af3b-850727635a99}</UniqueIdentifier>
</Filter>
<Filter Include="thirdparty\lzham\lzhamcomp">
<UniqueIdentifier>{8736d047-b4af-4c17-99ee-454cc96ec1ba}</UniqueIdentifier>
</Filter>
<Filter Include="thirdparty\lzham\lzhamcomp\include">
<UniqueIdentifier>{e84ad150-2358-4146-971a-02c5f045437c}</UniqueIdentifier>
</Filter>
<Filter Include="thirdparty\lzham\lzhamdecomp">
<UniqueIdentifier>{eb98cd2b-4508-43a0-95e1-feacc7c83a8d}</UniqueIdentifier>
</Filter>
<Filter Include="thirdparty\lzham\lzhamdecomp\include">
<UniqueIdentifier>{463e0739-1e5f-47a0-94d1-6cf5b6bf3ea6}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="client\client.h">
@ -540,12 +552,6 @@
<ClInclude Include="public\include\binstream.h">
<Filter>sdk\public\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_static_lib.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="mathlib\adler32.h">
<Filter>sdk\mathlib</Filter>
</ClInclude>
@ -564,6 +570,93 @@
<ClInclude Include="windows\system.h">
<Filter>windows</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_config.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_core.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_helpers.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_huffman_codes.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_lzbase.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_match_accel.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_math.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_mem.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_null_threading.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_platform.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_polar_codes.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_prefix_coding.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_pthreads_threading.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_static_lib.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_symbol_codec.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_threading.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_timer.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_traits.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_types.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_utils.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_vector.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_win32_threading.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_assert.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_checksum.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\lzhamcomp\lzham_comp.h">
<Filter>thirdparty\lzham\lzhamcomp\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_internal.h">
<Filter>thirdparty\lzham\lzhamcomp\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\lzhamdecomp\lzham_decomp.h">
<Filter>thirdparty\lzham\lzhamdecomp\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecompbase.h">
<Filter>thirdparty\lzham\lzhamdecomp\include</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="client\IVEngineClient.cpp">
@ -701,6 +794,69 @@
<ClCompile Include="thirdparty\detours\src\modules.cpp">
<Filter>thirdparty\detours</Filter>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\creatwth.cpp">
<Filter>thirdparty\detours</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_assert.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_checksum.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_huffman_codes.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_lzbase.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_match_accel.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_mem.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_platform.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_polar_codes.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_prefix_coding.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_pthreads_threading.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_symbol_codec.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_timer.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_vector.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_win32_threading.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_api.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp.cpp">
<Filter>thirdparty\lzham\lzhamcomp</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_internal.cpp">
<Filter>thirdparty\lzham\lzhamcomp</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_state.cpp">
<Filter>thirdparty\lzham\lzhamcomp</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecomp.cpp">
<Filter>thirdparty\lzham\lzhamdecomp</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecompbase.cpp">
<Filter>thirdparty\lzham\lzhamdecomp</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="r5dev.def" />

115
r5dev/r5dev.vcxproj
View File

@ -58,6 +58,10 @@
<ClCompile Include="squirrel\sqapi.cpp" />
<ClCompile Include="squirrel\sqinit.cpp" />
<ClCompile Include="squirrel\sqvm.cpp" />
<ClCompile Include="thirdparty\detours\src\creatwth.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\detours.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
@ -106,6 +110,86 @@
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_internal.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_state.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecomp.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecompbase.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_api.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_assert.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_checksum.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_huffman_codes.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_lzbase.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_match_accel.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_mem.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_platform.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_polar_codes.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_prefix_coding.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_pthreads_threading.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_symbol_codec.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_timer.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_vector.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_win32_threading.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="tier0\ConCommand.cpp" />
<ClCompile Include="tier0\completion.cpp" />
<ClCompile Include="tier0\cvar.cpp" />
@ -192,7 +276,34 @@
<ClInclude Include="thirdparty\imgui\include\imstb_textedit.h" />
<ClInclude Include="thirdparty\imgui\include\imstb_truetype.h" />
<ClInclude Include="thirdparty\lzham\include\lzham.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_assert.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_checksum.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_config.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_core.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_helpers.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_huffman_codes.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_lzbase.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_match_accel.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_math.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_mem.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_null_threading.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_platform.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_polar_codes.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_prefix_coding.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_pthreads_threading.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_static_lib.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_symbol_codec.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_threading.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_timer.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_traits.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_types.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_utils.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_vector.h" />
<ClInclude Include="thirdparty\lzham\include\lzham_win32_threading.h" />
<ClInclude Include="thirdparty\lzham\lzhamcomp\lzham_comp.h" />
<ClInclude Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_internal.h" />
<ClInclude Include="thirdparty\lzham\lzhamdecomp\lzham_decomp.h" />
<ClInclude Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecompbase.h" />
<ClInclude Include="thirdparty\spdlog\include\async.h" />
<ClInclude Include="thirdparty\spdlog\include\async_logger-inl.h" />
<ClInclude Include="thirdparty\spdlog\include\async_logger.h" />
@ -452,7 +563,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<ModuleDefinitionFile>r5dev.def</ModuleDefinitionFile>
<AdditionalDependencies>lzhamlib_x64D.lib;lzhamcomp_x64D.lib;lzhamdecomp_x64D.lib;d3d11.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>d3d11.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
<PostBuildEvent>
<Command>copy /Y "$(TargetPath)" "..\..\..\bin\$(TargetFileName)"</Command>
@ -488,7 +599,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<ModuleDefinitionFile>r5dev.def</ModuleDefinitionFile>
<AdditionalDependencies>lzhamlib_x64.lib;lzhamcomp_x64.lib;lzhamdecomp_x64.lib;d3d11.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>d3d11.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
<PostBuildEvent>
<Command>copy /Y "$(TargetPath)" "..\..\..\$(TargetFileName)" &amp;&amp; del "..\..\..\r5apexsdkd64.dll" &amp;&amp; rename "..\..\..\$(TargetFileName)" "r5apexsdkd64.dll"</Command>

168
r5dev/r5dev.vcxproj.filters
View File

@ -127,6 +127,18 @@
<Filter Include="sdk\milessdk">
<UniqueIdentifier>{f52dfb17-f5bd-4258-91a2-500587bee708}</UniqueIdentifier>
</Filter>
<Filter Include="thirdparty\lzham\lzhamcomp">
<UniqueIdentifier>{f450ee50-7010-49e2-9f91-05a74fcb6a8b}</UniqueIdentifier>
</Filter>
<Filter Include="thirdparty\lzham\lzhamcomp\include">
<UniqueIdentifier>{11645361-fd70-462f-ab8b-8a78283a5fc7}</UniqueIdentifier>
</Filter>
<Filter Include="thirdparty\lzham\lzhamdecomp">
<UniqueIdentifier>{785353c2-6417-4213-b55f-3007a0b79801}</UniqueIdentifier>
</Filter>
<Filter Include="thirdparty\lzham\lzhamdecomp\include">
<UniqueIdentifier>{5beb12b5-0422-4337-9be6-2e6c0a05a69b}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="client\client.cpp">
@ -321,6 +333,69 @@
<ClCompile Include="thirdparty\detours\src\detours.cpp">
<Filter>thirdparty\detours</Filter>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\creatwth.cpp">
<Filter>thirdparty\detours</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_assert.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_checksum.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_huffman_codes.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_lzbase.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_match_accel.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_mem.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_platform.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_polar_codes.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_prefix_coding.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_pthreads_threading.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_symbol_codec.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_timer.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_vector.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_win32_threading.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzham_api.cpp">
<Filter>thirdparty\lzham</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_internal.cpp">
<Filter>thirdparty\lzham\lzhamcomp</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_state.cpp">
<Filter>thirdparty\lzham\lzhamcomp</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp.cpp">
<Filter>thirdparty\lzham\lzhamcomp</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecomp.cpp">
<Filter>thirdparty\lzham\lzhamdecomp</Filter>
</ClCompile>
<ClCompile Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecompbase.cpp">
<Filter>thirdparty\lzham\lzhamdecomp</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="client\cdll_engine_int.h">
@ -836,12 +911,6 @@
<ClInclude Include="public\include\binstream.h">
<Filter>sdk\public\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_static_lib.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="mathlib\adler32.h">
<Filter>sdk\mathlib</Filter>
</ClInclude>
@ -872,6 +941,93 @@
<ClInclude Include="milessdk\win64_rrthreads.h">
<Filter>sdk\milessdk</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_config.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_core.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_helpers.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_huffman_codes.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_lzbase.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_match_accel.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_math.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_mem.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_null_threading.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_platform.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_polar_codes.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_prefix_coding.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_pthreads_threading.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_static_lib.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_symbol_codec.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_threading.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_timer.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_traits.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_types.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_utils.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_vector.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_win32_threading.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_assert.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\include\lzham_checksum.h">
<Filter>thirdparty\lzham\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\lzhamcomp\lzham_comp.h">
<Filter>thirdparty\lzham\lzhamcomp\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\lzhamcomp\lzham_lzcomp_internal.h">
<Filter>thirdparty\lzham\lzhamcomp\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\lzhamdecomp\lzham_decomp.h">
<Filter>thirdparty\lzham\lzhamdecomp\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\lzham\lzhamdecomp\lzham_lzdecompbase.h">
<Filter>thirdparty\lzham\lzhamdecomp\include</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="r5dev.def" />

23
r5dev/sdklauncher.vcxproj
View File

@ -140,7 +140,7 @@
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>detours.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
</Link>
<PostBuildEvent>
<Command>del "..\..\..\r5reloaded.exe" &amp;&amp; copy /Y "$(TargetPath)" "..\..\..\$(TargetFileName)"</Command>
@ -174,7 +174,7 @@
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>detours.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
</Link>
<PostBuildEvent>
<Command>del "..\..\..\r5reloaded.exe" &amp;&amp; copy /Y "$(TargetPath)" "..\..\..\$(TargetFileName)"</Command>
@ -186,6 +186,22 @@
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="sdklauncher\sdklauncher.cpp" />
<ClCompile Include="thirdparty\detours\src\creatwth.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\detours.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\disasm.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\modules.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="resource\sdklauncher.rc" />
@ -198,6 +214,9 @@
<ClInclude Include="core\stdafx.h" />
<ClInclude Include="sdklauncher\sdklauncher.h" />
<ClInclude Include="sdklauncher\sdklauncher_res.h" />
<ClInclude Include="thirdparty\detours\include\detours.h" />
<ClInclude Include="thirdparty\detours\include\detver.h" />
<ClInclude Include="thirdparty\detours\include\syelog.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">

27
r5dev/sdklauncher.vcxproj.filters
View File

@ -13,6 +13,12 @@
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="Detours Files">
<UniqueIdentifier>{82b18787-373d-42ce-8d8d-1e3adba8d3a0}</UniqueIdentifier>
</Filter>
<Filter Include="Detours Files\include">
<UniqueIdentifier>{dc968871-7ca2-452b-a5b1-350a12dd54aa}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="sdklauncher\sdklauncher.cpp">
@ -21,6 +27,18 @@
<ClCompile Include="core\stdafx.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\detours.cpp">
<Filter>Detours Files</Filter>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\disasm.cpp">
<Filter>Detours Files</Filter>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\modules.cpp">
<Filter>Detours Files</Filter>
</ClCompile>
<ClCompile Include="thirdparty\detours\src\creatwth.cpp">
<Filter>Detours Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="resource\sdklauncher.rc">
@ -37,6 +55,15 @@
<ClInclude Include="sdklauncher\sdklauncher_res.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="thirdparty\detours\include\detver.h">
<Filter>Detours Files\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\detours\include\syelog.h">
<Filter>Detours Files\include</Filter>
</ClInclude>
<ClInclude Include="thirdparty\detours\include\detours.h">
<Filter>Detours Files\include</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<Image Include="resource\ico\sdklauncher_rel.ico">

1783
r5dev/thirdparty/detours/src/creatwth.cpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

335
r5dev/thirdparty/detours/src/uimports.cpp vendored Normal file
View File

@ -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;
}

40
r5dev/thirdparty/lzham/include/lzham_assert.h vendored Normal file
View File

@ -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 <bool x> struct assume_failure;
template <> struct assume_failure<true> { enum { blah = 1 }; };
template<int x> 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

13
r5dev/thirdparty/lzham/include/lzham_checksum.h vendored Normal file
View File

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

23
r5dev/thirdparty/lzham/include/lzham_config.h vendored Normal file
View File

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

170
r5dev/thirdparty/lzham/include/lzham_core.h vendored Normal file
View File

@ -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 <xtl.h>
#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 <windows.h>
#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 <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <malloc.h>
#include <stdarg.h>
#include <memory.h>
#include <limits.h>
#include <algorithm>
#include <errno.h>
#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"

54
r5dev/thirdparty/lzham/include/lzham_helpers.h vendored Normal file
View File

@ -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<typename T> 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 <typename T>
inline T* construct(T* p)
{
return new (static_cast<void*>(p)) T;
}
template <typename T, typename U>
inline T* construct(T* p, const U& init)
{
return new (static_cast<void*>(p)) T(init);
}
template <typename T>
inline void construct_array(T* p, uint n);
template <typename T, typename U>
inline void construct_array(T* p, uint n, const U& init)
{
T* q = p + n;
for ( ; p != q; ++p)
new (static_cast<void*>(p)) T(init);
}
template <typename T>
inline void destruct(T* p)
{
LZHAM_NOTE_UNUSED(p);
p->~T();
}
template <typename T>
inline void destruct_array(T* p, uint n);
} // namespace helpers
} // namespace lzham

14
r5dev/thirdparty/lzham/include/lzham_huffman_codes.h vendored Normal file
View File

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

45
r5dev/thirdparty/lzham/include/lzham_lzbase.h vendored Normal file
View File

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

146
r5dev/thirdparty/lzham/include/lzham_match_accel.h vendored Normal file
View File

@ -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<uint>((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<uint8> m_dict;
enum { cHashSize = 65536 };
lzham::vector<uint> m_hash;
lzham::vector<node> m_nodes;
lzham::vector<dict_match> m_matches;
lzham::vector<atomic32_t> m_match_refs;
lzham::vector<uint8> m_hash_thread_index;
enum { cDigramHashSize = 4096 };
lzham::vector<uint> m_digram_hash;
lzham::vector<uint> 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

113
r5dev/thirdparty/lzham/include/lzham_math.h vendored Normal file
View File

@ -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 <intrin.h>
#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<typename T> inline T minimum(T a, T b) { return (a < b) ? a : b; }
template<typename T> inline T minimum(T a, T b, T c) { return minimum(minimum(a, b), c); }
template<typename T> inline T maximum(T a, T b) { return (a > b) ? a : b; }
template<typename T> inline T maximum(T a, T b, T c) { return maximum(maximum(a, b), c); }
template<typename T> 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<typename T> inline T align_up_pointer(T p, uint alignment)
{
LZHAM_ASSERT(is_power_of_2(alignment));
ptr_bits_t q = reinterpret_cast<ptr_bits_t>(p);
q = (q + alignment - 1) & (~((uint_ptr)alignment - 1));
return reinterpret_cast<T>(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

112
r5dev/thirdparty/lzham/include/lzham_mem.h vendored Normal file
View File

@ -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<typename T>
inline T* lzham_new()
{
T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
if (!p) return NULL;
if (LZHAM_IS_SCALAR_TYPE(T))
return p;
return helpers::construct(p);
}
template<typename T, typename A>
inline T* lzham_new(const A& init0)
{
T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
if (!p) return NULL;
return new (static_cast<void*>(p)) T(init0);
}
template<typename T, typename A, typename B>
inline T* lzham_new(const A& init0, const B& init1)
{
T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
if (!p) return NULL;
return new (static_cast<void*>(p)) T(init0, init1);
}
template<typename T, typename A, typename B, typename C>
inline T* lzham_new(const A& init0, const B& init1, const C& init2)
{
T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
if (!p) return NULL;
return new (static_cast<void*>(p)) T(init0, init1, init2);
}
template<typename T, typename A, typename B, typename C, typename D>
inline T* lzham_new(const A& init0, const B& init1, const C& init2, const D& init3)
{
T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
if (!p) return NULL;
return new (static_cast<void*>(p)) T(init0, init1, init2, init3);
}
template<typename T>
inline T* lzham_new_array(uint32 num)
{
if (!num) num = 1;
uint8* q = static_cast<uint8*>(lzham_malloc(LZHAM_MIN_ALLOC_ALIGNMENT + sizeof(T) * num));
if (!q)
return NULL;
T* p = reinterpret_cast<T*>(q + LZHAM_MIN_ALLOC_ALIGNMENT);
reinterpret_cast<uint32*>(p)[-1] = num;
reinterpret_cast<uint32*>(p)[-2] = ~num;
if (!LZHAM_IS_SCALAR_TYPE(T))
{
helpers::construct_array(p, num);
}
return p;
}
template<typename T>
inline void lzham_delete(T* p)
{
if (p)
{
if (!LZHAM_IS_SCALAR_TYPE(T))
{
helpers::destruct(p);
}
lzham_free(p);
}
}
template<typename T>
inline void lzham_delete_array(T* p)
{
if (p)
{
const uint32 num = reinterpret_cast<uint32*>(p)[-1];
const uint32 num_check = reinterpret_cast<uint32*>(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<uint8*>(p) - LZHAM_MIN_ALLOC_ALIGNMENT);
}
}
}
void lzham_print_mem_stats();
} // namespace lzham

97
r5dev/thirdparty/lzham/include/lzham_null_threading.h vendored Normal file
View File

@ -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<typename S, typename T>
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<typename S, typename T>
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

284
r5dev/thirdparty/lzham/include/lzham_platform.h vendored Normal file
View File

@ -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<const uint32*>(p)
#else
#if defined(LZHAM_USE_MSVC_INTRINSICS)
#define LZHAM_READ_BIG_ENDIAN_UINT32(p) _byteswap_ulong(*reinterpret_cast<const uint32*>(p))
#elif defined(__GNUC__)
#define LZHAM_READ_BIG_ENDIAN_UINT32(p) __builtin_bswap32(*reinterpret_cast<const uint32*>(p))
#else
#define LZHAM_READ_BIG_ENDIAN_UINT32(p) utils::swap32(*reinterpret_cast<const uint32*>(p))
#endif
#endif
#else
#define LZHAM_READ_BIG_ENDIAN_UINT32(p) ((reinterpret_cast<const uint8*>(p)[0] << 24) | (reinterpret_cast<const uint8*>(p)[1] << 16) | (reinterpret_cast<const uint8*>(p)[2] << 8) | (reinterpret_cast<const uint8*>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(pDest) & 3) == 0);
return InterlockedIncrement(pDest);
}
// Returns the resulting decremented value.
inline atomic32_t atomic_decrement32(atomic32_t volatile *pDest)
{
LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(pDest) & 3) == 0);
return (*pDest += 1);
}
inline atomic32_t atomic_decrement32(atomic32_t volatile *pDest)
{
LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
return (*pDest -= 1);
}
inline atomic32_t atomic_exchange32(atomic32_t volatile *pDest, atomic32_t val)
{
LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(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<ptr_bits_t>(pDest) & 3) == 0);
return (*pDest += val);
}
inline atomic32_t atomic_exchange_add(atomic32_t volatile *pDest, atomic32_t val)
{
LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(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

14
r5dev/thirdparty/lzham/include/lzham_polar_codes.h vendored Normal file
View File

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

144
r5dev/thirdparty/lzham/include/lzham_prefix_coding.h vendored Normal file
View File

@ -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<uint32>(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<uint16>(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

383
r5dev/thirdparty/lzham/include/lzham_pthreads_threading.h vendored Normal file
View File

@ -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 <pthread.h>
#include <semaphore.h>
#include <unistd.h>
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<typename T, uint cMaxSize>
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<typename S, typename T>
inline bool queue_object_task(S* pObject, T pObject_method, uint64 data = 0, void* pData_ptr = NULL);
template<typename S, typename T>
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<task, cMaxThreads> 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<typename T>
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<typename S, typename T>
inline bool task_pool::queue_object_task(S* pObject, T pObject_method, uint64 data, void* pData_ptr)
{
object_task<S> *pTask = lzham_new< object_task<S> >(pObject, pObject_method, cObjectTaskFlagDeleteAfterExecution);
if (!pTask)
return false;
return queue_task(pTask, data, pData_ptr);
}
template<typename S, typename T>
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<S> >(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

556
r5dev/thirdparty/lzham/include/lzham_symbol_codec.h vendored Normal file
View File

@ -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<bit_cost_t>(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<uint16> m_initial_sym_freq;
lzham::vector<uint16> m_sym_freq;
lzham::vector<uint16> m_codes;
lzham::vector<uint8> 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> 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<uint8>& get_encoding_buf() const { return m_output_buf; }
lzham::vector<uint8>& 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<uint8> m_output_buf;
lzham::vector<uint8> 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<output_symbol> 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<symbol_codec::bit_buf_t>(r) << (symbol_codec::cBitBufSize - bit_count)); \
} \
result = (num_bits) ? static_cast<uint>(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<adaptive_bit_model*>(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<adaptive_arith_data_model *>(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<symbol_codec::bit_buf_t>(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<symbol_codec::bit_buf_t>(c) << (symbol_codec::cBitBufSize - bit_count)); \
} \
} \
uint k = static_cast<uint>((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<int>(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<uint16>(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<symbol_codec::bit_buf_t>(c) << (symbol_codec::cBitBufSize - bit_count)); \
} \
uint k = static_cast<uint>((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<int>(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<uint16>(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<int>(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

12
r5dev/thirdparty/lzham/include/lzham_threading.h vendored Normal file
View File

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

99
r5dev/thirdparty/lzham/include/lzham_timer.h vendored Normal file
View File

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

137
r5dev/thirdparty/lzham/include/lzham_traits.h vendored Normal file
View File

@ -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<typename T>
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<typename T> struct scalar_type<T*>
{
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<X> { \
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<typename T>
struct bitwise_movable { enum { cFlag = false }; };
// Defines type Q as bitwise movable.
#define LZHAM_DEFINE_BITWISE_MOVABLE(Q) template<> struct bitwise_movable<Q> { enum { cFlag = true }; };
template<typename T>
struct bitwise_copyable { enum { cFlag = false }; };
// Defines type Q as bitwise copyable.
#define LZHAM_DEFINE_BITWISE_COPYABLE(Q) template<> struct bitwise_copyable<Q> { enum { cFlag = true }; };
#define LZHAM_IS_POD(T) __is_pod(T)
#define LZHAM_IS_SCALAR_TYPE(T) (scalar_type<T>::cFlag)
#define LZHAM_IS_BITWISE_COPYABLE(T) ((scalar_type<T>::cFlag) || (bitwise_copyable<T>::cFlag) || LZHAM_IS_POD(T))
#define LZHAM_IS_BITWISE_MOVABLE(T) (LZHAM_IS_BITWISE_COPYABLE(T) || (bitwise_movable<T>::cFlag))
#define LZHAM_HAS_DESTRUCTOR(T) ((!scalar_type<T>::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 <class U> yes_t class_test(int U::*);
template <class U> no_t class_test(...);
template <class T> struct is_class
{
enum { value = (sizeof(class_test<T>(0)) == sizeof(yes_t)) };
};
template <typename T> struct is_pointer
{
enum { value = false };
};
template <typename T> struct is_pointer<T*>
{
enum { value = true };
};
LZHAM_DEFINE_BITWISE_COPYABLE(empty_type);
LZHAM_DEFINE_BITWISE_MOVABLE(empty_type);
namespace helpers
{
template <typename T>
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<void*>(p)) T;
}
}
template <typename T>
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

74
r5dev/thirdparty/lzham/include/lzham_types.h vendored Normal file
View File

@ -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<typename T> struct int_traits { enum { cMin = INT_MIN, cMax = INT_MAX, cSigned = true }; };
template<> struct int_traits<int8> { enum { cMin = INT8_MIN, cMax = INT8_MAX, cSigned = true }; };
template<> struct int_traits<int16> { enum { cMin = INT16_MIN, cMax = INT16_MAX, cSigned = true }; };
template<> struct int_traits<int32> { enum { cMin = INT32_MIN, cMax = INT32_MAX, cSigned = true }; };
template<> struct int_traits<uint> { enum { cMin = 0, cMax = UINT_MAX, cSigned = false }; };
template<> struct int_traits<uint8> { enum { cMin = 0, cMax = UINT8_MAX, cSigned = false }; };
template<> struct int_traits<uint16> { enum { cMin = 0, cMax = UINT16_MAX, cSigned = false }; };
struct empty_type { };
} // namespace lzham

58
r5dev/thirdparty/lzham/include/lzham_utils.h vendored Normal file
View File

@ -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<class T, size_t N> 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<typename T> inline void swap(T& l, T& r)
{
T temp(l);
l = r;
r = temp;
}
template<typename T> 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

588
r5dev/thirdparty/lzham/include/lzham_vector.h vendored Normal file
View File

@ -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<typename T>
class vector : public helpers::rel_ops< vector<T> >
{
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<T>::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<T>::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<T>::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<T>::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<T>::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<T>::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<T*>(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<T>::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<uint>(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<T>::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<typename Q>
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<T>::cFlag))
memset(m_p, *reinterpret_cast<const uint8*>(&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<typename Q> struct is_vector { enum { cFlag = false }; };
template<typename Q> struct is_vector< vector<Q> > { enum { cFlag = true }; };
static void object_mover(void* pDst_void, void* pSrc_void, uint num)
{
T* pSrc = static_cast<T*>(pSrc_void);
T* const pSrc_end = pSrc + num;
T* pDst = static_cast<T*>(pDst_void);
while (pSrc != pSrc_end)
{
new (static_cast<void*>(pDst)) T(*pSrc);
pSrc->~T();
pSrc++;
pDst++;
}
}
inline bool increase_capacity(uint min_new_capacity, bool grow_hint, bool nofail = false)
{
return reinterpret_cast<elemental_vector*>(this)->increase_capacity(
min_new_capacity, grow_hint, sizeof(T),
(LZHAM_IS_BITWISE_MOVABLE(T) || (is_vector<T>::cFlag)) ? NULL : object_mover, nofail);
}
};
template<typename T> struct bitwise_movable< vector<T> > { enum { cFlag = true }; };
extern void vector_test();
template<typename T>
inline void swap(vector<T>& a, vector<T>& b)
{
a.swap(b);
}
} // namespace lzham

368
r5dev/thirdparty/lzham/include/lzham_win32_threading.h vendored Normal file
View File

@ -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<typename T>
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<typename S, typename T>
inline bool queue_object_task(S* pObject, T pObject_method, uint64 data = 0, void* pData_ptr = NULL);
template<typename S, typename T>
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<task> 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<typename T>
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<typename S, typename T>
inline bool task_pool::queue_object_task(S* pObject, T pObject_method, uint64 data, void* pData_ptr)
{
object_task<S> *pTask = lzham_new< object_task<S> >(pObject, pObject_method, cObjectTaskFlagDeleteAfterExecution);
if (!pTask)
return false;
return queue_task(pTask, data, pData_ptr);
}
template<typename S, typename T>
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<S> >(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

BIN
r5dev/thirdparty/lzham/libs/lzhamcomp_x64.lib vendored
View File

Binary file not shown.

BIN
r5dev/thirdparty/lzham/libs/lzhamcomp_x64D.lib vendored
View File

Binary file not shown.

BIN
r5dev/thirdparty/lzham/libs/lzhamdecomp_x64.lib vendored
View File

Binary file not shown.

BIN
r5dev/thirdparty/lzham/libs/lzhamdecomp_x64D.lib vendored
View File

Binary file not shown.

BIN
r5dev/thirdparty/lzham/libs/lzhamlib_x64.lib vendored
View File

Binary file not shown.

BIN
r5dev/thirdparty/lzham/libs/lzhamlib_x64D.lib vendored
View File

Binary file not shown.

179
r5dev/thirdparty/lzham/lzham_api.cpp vendored Normal file
View File

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

66
r5dev/thirdparty/lzham/lzham_assert.cpp vendored Normal file
View File

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

73
r5dev/thirdparty/lzham/lzham_checksum.cpp vendored Normal file
View File

@ -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<const uint8*>(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

390
r5dev/thirdparty/lzham/lzham_huffman_codes.cpp vendored Normal file
View File

@ -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]<A[leaf]) {
A[next] = A[root]; A[root++] = next;
} else
A[next] = A[leaf++];
/* add on the second item */
if (leaf>=n || (root<next && A[root]<A[leaf])) {
A[next] += A[root]; A[root++] = next;
} else
A[next] += A[leaf++];
}
/* second pass, right to left, setting internal depths */
A[n-2] = 0;
for (next=n-3; next>=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<huffman_work_tables*>(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<uint8>(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<uint16>(left_child);
syms[internal_node_index].m_right = static_cast<uint16>(right_child);
LZHAM_ASSERT(queue_end < huffman_work_tables::cMaxInternalNodes);
state.queue[queue_end] = static_cast<uint16>(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<uint8>(level + 1);
if (right_child < num_used_syms)
{
pCodesizes[syms[right_child].m_left] = static_cast<uint8>(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<uint8>(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

71
r5dev/thirdparty/lzham/lzham_lzbase.cpp vendored Normal file
View File

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

562
r5dev/thirdparty/lzham/lzham_match_accel.cpp vendored Normal file
View File

@ -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<uint>(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<uint>(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<uint>(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<uint>(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<const uint64*>(pComp + max_match_len - 7);
const uint64* pComp_cur = reinterpret_cast<const uint64*>(pComp);
const uint64* pIns_cur = reinterpret_cast<const uint64*>(pIns);
while (pComp_cur < pComp_end)
{
if (*pComp_cur != *pIns_cur)
break;
pComp_cur++;
pIns_cur++;
}
uint alt_match_len = static_cast<uint>(reinterpret_cast<const uint8*>(pComp_cur) - reinterpret_cast<const uint8*>(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<uint16>(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<uint16>(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<uint>(fill_lookahead_pos - m_fill_lookahead_pos)], match_ref_ofs);
}
else
{
atomic_exchange32((atomic32_t*)&m_match_refs[static_cast<uint>(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<uint>(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<uint8>(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<uint>(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<uint>(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);
}
}

272
r5dev/thirdparty/lzham/lzham_mem.cpp vendored Normal file
View File

@ -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 <stdio.h>
#include <stdint.h>
#include <malloc.h>
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<atomic32_t>(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<mem_stat_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<ptr_bits_t>(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<uint8*>((*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<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0);
#if LZHAM_MEM_STATS
update_total_allocated(1, static_cast<mem_stat_t>(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<ptr_bits_t>(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<mem_stat_t>(actual_size) - static_cast<mem_stat_t>(cur_size));
#endif
return p_new;
}
void lzham_free(void* p)
{
if (!p)
return;
if (reinterpret_cast<ptr_bits_t>(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<mem_stat_t>(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<ptr_bits_t>(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

146
r5dev/thirdparty/lzham/lzham_platform.cpp vendored Normal file
View File

@ -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 <xbdm.h>
#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<buffered_str> 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

414
r5dev/thirdparty/lzham/lzham_polar_codes.cpp vendored Normal file
View File

@ -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<uint8>(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<uint8>(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<uint8>(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<uint8>(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<polar_work_tables*>(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<uint16>(i);
sf.m_freq = static_cast<uint16>(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

350
r5dev/thirdparty/lzham/lzham_prefix_coding.cpp vendored Normal file
View File

@ -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<uint8>(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<uint16>(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<uint>(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<uint16>(pTables->m_cur_sorted_symbol_order_size);
if (!pTables->m_sorted_symbol_order)
return false;
}
pTables->m_min_code_size = static_cast<uint8>(min_code_size);
pTables->m_max_code_size = static_cast<uint8>(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<uint16>(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<uint32>(table_size);
if (!pTables->m_lookup)
return false;
}
memset(pTables->m_lookup, 0xFF, static_cast<uint>(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

227
r5dev/thirdparty/lzham/lzham_pthreads_threading.cpp vendored Normal file
View File

@ -0,0 +1,227 @@
// File: lzham_task_pool_pthreads.cpp
//
// Copyright (c) 2009-2010 Richard Geldreich, Jr. <richgel99@gmail.com>
//
// 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 <process.h>
#endif
#if defined(__GNUC__)
#include <sys/sysinfo.h>
#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<uint>(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<task_pool*>(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

1453
r5dev/thirdparty/lzham/lzham_symbol_codec.cpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

147
r5dev/thirdparty/lzham/lzham_timer.cpp vendored Normal file
View File

@ -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 <time.h>
#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<LARGE_INTEGER*>(pTicks));
}
inline void query_counter_frequency(timer_ticks *pTicks)
{
QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(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

74
r5dev/thirdparty/lzham/lzham_vector.cpp vendored Normal file
View File

@ -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<uint64>(new_capacity))))
new_capacity = math::next_pow2(static_cast<uint64>(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<uint>(actual_size / element_size);
else
m_capacity = static_cast<uint>(new_capacity);
return true;
}
} // namespace lzham

220
r5dev/thirdparty/lzham/lzham_win32_threading.cpp vendored Normal file
View File

@ -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 <process.h>
#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<uint>(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<task_pool*>(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

38
r5dev/thirdparty/lzham/lzhamcomp/lzham_comp.h vendored Normal file
View File

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

611
r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp.cpp vendored Normal file
View File

@ -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<lzham_compress_state>();
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<lzham_compress_state*>(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<lzham_compress_state *>(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<lzham_compress_state*>(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<task_pool>();
if (!pTP->init(internal_params.m_max_helper_threads))
return LZHAM_COMP_STATUS_FAILED;
internal_params.m_pTask_pool = pTP;
}
lzcompressor *pCompressor = lzham_new<lzcompressor>();
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<uint32>(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<lzham_compress_state*>(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

1972
r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.cpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

481
r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_internal.h vendored Normal file
View File

@ -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<uint8> 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<uint>(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<uint32>(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<lzdecision> m_best_decisions;
bool m_emit_decisions_backwards;
lzham::vector<lzpriced_decision> 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<lzpriced_decision>& 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

1463
r5dev/thirdparty/lzham/lzhamcomp/lzham_lzcomp_state.cpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

37
r5dev/thirdparty/lzham/lzhamdecomp/lzham_decomp.h vendored Normal file
View File

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

1590
r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecomp.cpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

46
r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.cpp vendored Normal file
View File

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

90
r5dev/thirdparty/lzham/lzhamdecomp/lzham_lzdecompbase.h vendored Normal file
View File

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