diff --git a/packages/l/lzham_codec/patches/2023.01.03/add_mimalloc.patch b/packages/l/lzham_codec/patches/2023.01.03/add_mimalloc.patch new file mode 100644 index 000000000..364b6b7f9 --- /dev/null +++ b/packages/l/lzham_codec/patches/2023.01.03/add_mimalloc.patch @@ -0,0 +1,30 @@ +diff --git a/lzhamdecomp/lzham_core.h b/lzhamdecomp/lzham_core.h +index 2e55362..abb8f71 100644 +--- a/lzhamdecomp/lzham_core.h ++++ b/lzhamdecomp/lzham_core.h +@@ -241,7 +241,9 @@ const bool c_lzham_big_endian_platform = !c_lzham_little_endian_platform; + #include + #include + #include +-#if !defined(__APPLE__) && !defined(__FreeBSD__) ++#ifdef ASSERT_USE_MIMALLOC ++ #include "mimalloc-override.h" ++#elif !defined(__APPLE__) && !defined(__FreeBSD__) + #include + #endif + #include +diff --git a/lzhamdecomp/lzham_mem.cpp b/lzhamdecomp/lzham_mem.cpp +index e8163fa..e82a5d2 100644 +--- a/lzhamdecomp/lzham_mem.cpp ++++ b/lzhamdecomp/lzham_mem.cpp +@@ -2,7 +2,9 @@ + // LZHAM is in the Public Domain. Please see the Public Domain declaration at the end of include/lzham.h + #include "lzham_core.h" + +-#ifdef __APPLE__ ++#ifdef ASSERT_USE_MIMALLOC ++ #include "mimalloc-override.h" ++#elif defined(__APPLE__) + #include + #elif defined(__FreeBSD__) || defined(__NetBSD__) + #include diff --git a/packages/l/lzham_codec/patches/2023.01.03/fix_arm64.patch b/packages/l/lzham_codec/patches/2023.01.03/fix_arm64.patch new file mode 100644 index 000000000..cd16407bb --- /dev/null +++ b/packages/l/lzham_codec/patches/2023.01.03/fix_arm64.patch @@ -0,0 +1,28 @@ +diff --git a/lzhamdecomp/lzham_platform.h b/lzhamdecomp/lzham_platform.h +index 01704be..04b29fb 100644 +--- a/lzhamdecomp/lzham_platform.h ++++ b/lzhamdecomp/lzham_platform.h +@@ -24,7 +24,11 @@ void lzham_fail(const char* pExp, const char* pFile, unsigned line); + #if defined(__GNUC__) && LZHAM_PLATFORM_PC + extern __inline__ __attribute__((__always_inline__,__gnu_inline__)) void lzham_yield_processor() + { +- __asm__ __volatile__("pause"); ++ #if defined(__AARCH64__) ++ __asm__ __volatile__("yield"); ++ #else ++ __asm__ __volatile__("pause"); ++ #endif + } + #elif LZHAM_PLATFORM_X360 + #define lzham_yield_processor() \ +@@ -48,7 +52,9 @@ extern __inline__ __attribute__((__always_inline__,__gnu_inline__)) void lzham_y + LZHAM_FORCE_INLINE void lzham_yield_processor() + { + #if LZHAM_USE_MSVC_INTRINSICS +- #if LZHAM_PLATFORM_PC_X64 ++ #if defined(__AARCH64__) ++ __yield(); ++ #elif LZHAM_PLATFORM_PC_X64 + _mm_pause(); + #else + YieldProcessor(); diff --git a/packages/l/lzham_codec/patches/2023.01.03/fix_linux.patch b/packages/l/lzham_codec/patches/2023.01.03/fix_linux.patch new file mode 100644 index 000000000..04747e62e --- /dev/null +++ b/packages/l/lzham_codec/patches/2023.01.03/fix_linux.patch @@ -0,0 +1,24 @@ +diff --git a/lzhamdecomp/lzham_huffman_codes.cpp b/lzhamdecomp/lzham_huffman_codes.cpp +index 11bdbd4..75884cc 100644 +--- a/lzhamdecomp/lzham_huffman_codes.cpp ++++ b/lzhamdecomp/lzham_huffman_codes.cpp +@@ -2,6 +2,7 @@ + // LZHAM is in the Public Domain. Please see the Public Domain declaration at the end of include/lzham.h + #include "lzham_core.h" + #include "lzham_huffman_codes.h" ++#include + + namespace lzham + { +diff --git a/lzhamdecomp/lzham_symbol_codec.h b/lzhamdecomp/lzham_symbol_codec.h +index 306d59b..af773d5 100644 +--- a/lzhamdecomp/lzham_symbol_codec.h ++++ b/lzhamdecomp/lzham_symbol_codec.h +@@ -2,6 +2,7 @@ + // LZHAM is in the Public Domain. Please see the Public Domain declaration at the end of include/lzham.h + #pragma once + #include "lzham_prefix_coding.h" ++#include + + namespace lzham + { diff --git a/packages/l/lzham_codec/patches/2023.01.03/fix_macosx.patch b/packages/l/lzham_codec/patches/2023.01.03/fix_macosx.patch new file mode 100644 index 000000000..5b275d8b8 --- /dev/null +++ b/packages/l/lzham_codec/patches/2023.01.03/fix_macosx.patch @@ -0,0 +1,26 @@ +diff --git a/lzhamdecomp/lzham_platform.cpp b/lzhamdecomp/lzham_platform.cpp +index cfc85c1..2cf493c 100644 +--- a/lzhamdecomp/lzham_platform.cpp ++++ b/lzhamdecomp/lzham_platform.cpp +@@ -62,7 +62,7 @@ void lzham_debug_break(void) + #if LZHAM_USE_WIN32_API + DebugBreak(); + #elif (TARGET_OS_MAC == 1) && (TARGET_IPHONE_SIMULATOR == 0) && (TARGET_OS_IPHONE == 0) +- __asm {int 3} ++ __asm__("int $3"); + #else + assert(0); + #endif +diff --git a/lzhamdecomp/lzham_traits.h b/lzhamdecomp/lzham_traits.h +index ea7214f..1ec89ae 100644 +--- a/lzhamdecomp/lzham_traits.h ++++ b/lzhamdecomp/lzham_traits.h +@@ -68,7 +68,7 @@ namespace lzham + #define LZHAM_DEFINE_BITWISE_COPYABLE(Q) template<> struct bitwise_copyable { enum { cFlag = true }; }; + + #if defined(__APPLE__) || defined(__NetBSD__) +- #define LZHAM_IS_POD(T) std::__is_pod::__value ++ #define LZHAM_IS_POD(T) std::is_pod::value + #else + #define LZHAM_IS_POD(T) __is_pod(T) + #endif diff --git a/packages/l/lzham_codec/patches/2023.01.03/fix_mingw.patch b/packages/l/lzham_codec/patches/2023.01.03/fix_mingw.patch new file mode 100644 index 000000000..7295bf7ed --- /dev/null +++ b/packages/l/lzham_codec/patches/2023.01.03/fix_mingw.patch @@ -0,0 +1,12 @@ +diff --git a/lzhamdecomp/lzham_vector.h b/lzhamdecomp/lzham_vector.h +index badc540..1c5331e 100644 +--- a/lzhamdecomp/lzham_vector.h ++++ b/lzhamdecomp/lzham_vector.h +@@ -1,6 +1,7 @@ + // File: lzham_vector.h + // LZHAM is in the Public Domain. Please see the Public Domain declaration at the end of include/lzham.h + #pragma once ++#include + + namespace lzham + { diff --git a/packages/l/lzham_codec/patches/2023.01.03/use_lzham_prefixed_max_int_values.patch b/packages/l/lzham_codec/patches/2023.01.03/use_lzham_prefixed_max_int_values.patch new file mode 100644 index 000000000..e03f01cc5 --- /dev/null +++ b/packages/l/lzham_codec/patches/2023.01.03/use_lzham_prefixed_max_int_values.patch @@ -0,0 +1,142 @@ +diff --git a/lzhamcomp/lzham_win32_threading.h b/lzhamcomp/lzham_win32_threading.h +index 0e1d16b..4aaff8c 100644 +--- a/lzhamcomp/lzham_win32_threading.h ++++ b/lzhamcomp/lzham_win32_threading.h +@@ -43,9 +43,9 @@ namespace lzham + } + } + +- bool wait(uint32 milliseconds = UINT32_MAX) ++ bool wait(uint32 milliseconds = LZHAM_UINT32_MAX) + { +- LZHAM_ASSUME(INFINITE == UINT32_MAX); ++ LZHAM_ASSUME(INFINITE == LZHAM_UINT32_MAX); + + DWORD result = WaitForSingleObject(m_handle, milliseconds); + +diff --git a/lzhamdecomp/lzham_huffman_codes.cpp b/lzhamdecomp/lzham_huffman_codes.cpp +index 11bdbd4..788414a 100644 +--- a/lzhamdecomp/lzham_huffman_codes.cpp ++++ b/lzhamdecomp/lzham_huffman_codes.cpp +@@ -224,7 +224,7 @@ namespace lzham + + sym_freq& sf = state.syms0[num_used_syms]; + sf.m_left = (uint16)i; +- sf.m_right = UINT16_MAX; ++ sf.m_right = LZHAM_UINT16_MAX; + sf.m_freq = freq; + num_used_syms++; + } +diff --git a/lzhamdecomp/lzham_prefix_coding.cpp b/lzhamdecomp/lzham_prefix_coding.cpp +index e9ada15..52377c9 100644 +--- a/lzhamdecomp/lzham_prefix_coding.cpp ++++ b/lzhamdecomp/lzham_prefix_coding.cpp +@@ -149,7 +149,7 @@ namespace lzham + { + uint c = pCodesizes[i]; + +- LZHAM_ASSERT(!c || (next_code[c] <= UINT16_MAX)); ++ LZHAM_ASSERT(!c || (next_code[c] <= LZHAM_UINT16_MAX)); + + pCodes[i] = static_cast(next_code[c]++); + +@@ -296,7 +296,7 @@ namespace lzham + + LZHAM_ASSERT(t < (1U << table_bits)); + +- LZHAM_ASSERT(pTables->m_lookup[t] == UINT32_MAX); ++ LZHAM_ASSERT(pTables->m_lookup[t] == LZHAM_UINT32_MAX); + + pTables->m_lookup[t] = sym_index | (codesize << 16U); + } +diff --git a/lzhamdecomp/lzham_symbol_codec.cpp b/lzhamdecomp/lzham_symbol_codec.cpp +index 5623584..b2ea7ee 100644 +--- a/lzhamdecomp/lzham_symbol_codec.cpp ++++ b/lzhamdecomp/lzham_symbol_codec.cpp +@@ -581,7 +581,7 @@ namespace lzham + freq++; + m_sym_freq[sym] = static_cast(freq); + +- LZHAM_ASSERT(freq <= UINT16_MAX); ++ LZHAM_ASSERT(freq <= LZHAM_UINT16_MAX); + + if (--m_symbols_until_update == 0) + { +@@ -828,7 +828,7 @@ namespace lzham + freq++; + model.m_sym_freq[sym] = static_cast(freq); + +- LZHAM_ASSERT(freq <= UINT16_MAX); ++ LZHAM_ASSERT(freq <= LZHAM_UINT16_MAX); + + if (--model.m_symbols_until_update == 0) + { +@@ -1265,8 +1265,8 @@ namespace lzham + { + uint32 t = pTables->m_lookup[m_bit_buf >> (cBitBufSize - pTables->m_table_bits)]; + +- LZHAM_ASSERT(t != UINT32_MAX); +- sym = t & UINT16_MAX; ++ LZHAM_ASSERT(t != LZHAM_UINT32_MAX); ++ sym = t & LZHAM_UINT16_MAX; + len = t >> 16; + + LZHAM_ASSERT(model.m_code_sizes[sym] == len); +@@ -1301,7 +1301,7 @@ namespace lzham + freq++; + model.m_sym_freq[sym] = static_cast(freq); + +- LZHAM_ASSERT(freq <= UINT16_MAX); ++ LZHAM_ASSERT(freq <= LZHAM_UINT16_MAX); + + if (--model.m_symbols_until_update == 0) + { +diff --git a/lzhamdecomp/lzham_symbol_codec.h b/lzhamdecomp/lzham_symbol_codec.h +index 306d59b..b231530 100644 +--- a/lzhamdecomp/lzham_symbol_codec.h ++++ b/lzhamdecomp/lzham_symbol_codec.h +@@ -19,7 +19,7 @@ namespace lzham + typedef uint64 bit_cost_t; + const uint32 cBitCostScaleShift = 24; + const uint32 cBitCostScale = (1U << cBitCostScaleShift); +- const bit_cost_t cBitCostMax = UINT64_MAX; ++ const bit_cost_t cBitCostMax = LZHAM_UINT64_MAX; + + inline bit_cost_t convert_to_scaled_bitcost(uint bits) { LZHAM_ASSERT(bits <= 255); uint32 scaled_bits = bits << cBitCostScaleShift; return static_cast(scaled_bits); } + +@@ -444,7 +444,7 @@ namespace lzham + 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; \ ++ result = t & LZHAM_UINT16_MAX; \ + len = t >> 16; \ + } \ + else \ +@@ -465,7 +465,7 @@ namespace lzham + uint freq = pModel->m_sym_freq[result]; \ + freq++; \ + pModel->m_sym_freq[result] = static_cast(freq); \ +- LZHAM_ASSERT(freq <= UINT16_MAX); \ ++ LZHAM_ASSERT(freq <= LZHAM_UINT16_MAX); \ + if (LZHAM_BUILTIN_EXPECT(--pModel->m_symbols_until_update == 0, 0)) \ + { \ + pModel->update_tables(); \ +@@ -501,7 +501,7 @@ namespace lzham + 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; \ ++ result = t & LZHAM_UINT16_MAX; \ + len = t >> 16; \ + } \ + else \ +@@ -522,7 +522,7 @@ namespace lzham + uint freq = pModel->m_sym_freq[result]; \ + freq++; \ + pModel->m_sym_freq[result] = static_cast(freq); \ +- LZHAM_ASSERT(freq <= UINT16_MAX); \ ++ LZHAM_ASSERT(freq <= LZHAM_UINT16_MAX); \ + if (LZHAM_BUILTIN_EXPECT(--pModel->m_symbols_until_update == 0, 0)) \ + { \ + pModel->update_tables(); \ diff --git a/packages/l/lzham_codec/port/xmake.lua b/packages/l/lzham_codec/port/xmake.lua new file mode 100644 index 000000000..832ec34ea --- /dev/null +++ b/packages/l/lzham_codec/port/xmake.lua @@ -0,0 +1,114 @@ +add_rules("mode.debug", "mode.release") + +option("mimalloc", {default = false, showmenu = true, description = "Use mimalloc"}) + +if has_config("mimalloc") then + add_requires("mimalloc") +end + +target("lzham_codec") + set_kind("$(kind)") + set_languages("cxx14") + add_options("mimalloc") + add_files( + "lzhamlib/lzham_lib.cpp", + + "lzhamcomp/lzham_lzbase.cpp", + "lzhamcomp/lzham_lzcomp_internal.cpp", + "lzhamcomp/lzham_lzcomp_state.cpp", + "lzhamcomp/lzham_lzcomp.cpp", + "lzhamcomp/lzham_match_accel.cpp", + + "lzhamdecomp/lzham_assert.cpp", + "lzhamdecomp/lzham_checksum.cpp", + "lzhamdecomp/lzham_huffman_codes.cpp", + "lzhamdecomp/lzham_lzdecomp.cpp", + "lzhamdecomp/lzham_lzdecompbase.cpp", + "lzhamdecomp/lzham_mem.cpp", + "lzhamdecomp/lzham_platform.cpp", + "lzhamdecomp/lzham_prefix_coding.cpp", + "lzhamdecomp/lzham_symbol_codec.cpp", + "lzhamdecomp/lzham_timer.cpp", + "lzhamdecomp/lzham_vector.cpp" + ) + add_headerfiles( + "include/lzham_dynamic_lib.h", + "include/lzham_static_lib.h", + "include/lzham.h", + "include/zlib.h", + + "lzhamcomp/lzham_comp.h", + "lzhamcomp/lzham_lzbase.h", + "lzhamcomp/lzham_lzcomp_internal.h", + "lzhamcomp/lzham_match_accel.h", + "lzhamcomp/lzham_null_threading.h", + "lzhamcomp/lzham_threading.h", + + "lzhamdecomp/lzham_assert.h", + "lzhamdecomp/lzham_checksum.h", + "lzhamdecomp/lzham_config.h", + "lzhamdecomp/lzham_core.h", + "lzhamdecomp/lzham_decomp.h", + "lzhamdecomp/lzham_helpers.h", + "lzhamdecomp/lzham_huffman_codes.h", + "lzhamdecomp/lzham_lzdecompbase.h", + "lzhamdecomp/lzham_math.h", + "lzhamdecomp/lzham_mem.h", + "lzhamdecomp/lzham_platform.h", + "lzhamdecomp/lzham_prefix_coding.h", + "lzhamdecomp/lzham_symbol_codec.h", + "lzhamdecomp/lzham_timer.h", + "lzhamdecomp/lzham_traits.h", + "lzhamdecomp/lzham_types.h", + "lzhamdecomp/lzham_utils.h", + "lzhamdecomp/lzham_vector.h" + ) + add_includedirs("include", {public = true}) + add_includedirs("lzhamcomp", "lzhamdecomp") + + if has_config("mimalloc") then + add_packages("mimalloc") + add_defines("ASSERT_USE_MIMALLOC") + end + + if is_arch("x86_64") then + add_defines("__x86_64__") + elseif is_arch("i386") then + add_defines("__i386__") + end + if is_plat("mingw") then + add_defines("__GNUC__") + if is_arch("i386", "x86") then + add_defines("__MINGW32__") + else + add_defines("__MINGW64__") + end + end + if is_plat("windows") then + add_defines("WIN32", "__WIN32__") + if is_arch("arm64") then + add_defines("__AARCH64__") + elseif is_arch("x64") then + add_defines("_WIN64") + end + add_files("lzhamcomp/lzham_win32_threading.cpp") + add_headerfiles("lzhamcomp/lzham_win32_threading.h") + else + add_syslinks("pthread") + if is_plat("linux") then + add_defines("__linux__") + elseif is_plat("freebsd") then + add_defines("__FreeBSD__") + end + if is_plat("macosx", "iphoneos") then + add_defines("__APPLE__") + add_defines("__MACH__") + if is_plat("macosx") then + add_defines("TARGET_OS_MAC") + else + add_defines("TARGET_OS_IPHONE") + end + end + add_files("lzhamcomp/lzham_pthreads_threading.cpp") + add_headerfiles("lzhamcomp/lzham_pthreads_threading.h") + end diff --git a/packages/l/lzham_codec/xmake.lua b/packages/l/lzham_codec/xmake.lua new file mode 100644 index 000000000..fc3600b1d --- /dev/null +++ b/packages/l/lzham_codec/xmake.lua @@ -0,0 +1,42 @@ +package("lzham_codec") + set_homepage("https://github.com/richgel999/lzham_codec") + set_description("Lossless data compression codec with LZMA-like ratios but 1.5x-8x faster decompression speed, C/C++") + + set_urls("https://github.com/richgel999/lzham_codec.git") + + add_versions("2023.01.03", "d379b1f9121e2197881c61cfc4713c78848bdfe7") + add_patches("2023.01.03", path.join(os.scriptdir(), "patches", "2023.01.03", "fix_linux.patch"), "f43db780903b98567d5039bcc99c08d3ed871a979333b3387e8416536b3ba925") + add_patches("2023.01.03", path.join(os.scriptdir(), "patches", "2023.01.03", "use_lzham_prefixed_max_int_values.patch"), "bf8dd1bf584fb0e8a7dcdb846e009ef52c1fcc0fbee7158635322b69883874a6") + add_patches("2023.01.03", path.join(os.scriptdir(), "patches", "2023.01.03", "fix_macosx.patch"), "8c5ec78e9381215f0283dde82059775c3f8406c444013c04bb55b578415ff7ef") + add_patches("2023.01.03", path.join(os.scriptdir(), "patches", "2023.01.03", "fix_arm64.patch"), "c1493e4e0b097e3cf0657a90d836952b1dd47c15d3977b8923805004336945d2") + add_patches("2023.01.03", path.join(os.scriptdir(), "patches", "2023.01.03", "fix_mingw.patch"), "b35bb937a0fc2ba7a61c7e3253ede9d3e8c0f952a8f312e6fa2fe577987fa9c6") + add_patches("2023.01.03", path.join(os.scriptdir(), "patches", "2023.01.03", "add_mimalloc.patch"), "7d42ce1d7f1d5d8874f99714ddfff97f35247506d423b488e0de8c74ded92a2f") + + add_configs("mimalloc", {description = "Use mimalloc instead of default malloc headers", default = is_plat("mingw"), type = "boolean", readonly = is_plat("mingw")}) + + on_load(function (package) + if package:config("mimalloc") then + package:add("deps", "mimalloc") + end + end) + + on_install(function (package) + os.cp(path.join(package:scriptdir(), "port", "xmake.lua"), "xmake.lua") + local configs = {} + if package:config("mimalloc") then + package:add("defines", "ASSERT_USE_MIMALLOC") + configs.mimalloc = true + end + import("package.tools.xmake").install(package, configs) + end) + + on_test(function (package) + assert(package:has_cfuncs("lzham_compress_init", {includes = "lzham_static_lib.h"})) + assert(package:check_cxxsnippets({test = [[ + #include + void test() { + lzham_static_lib lzham_lib; + lzham_lib.load(); + } + ]]})) + end)