From 6c0e331f1d6fe08c5b4650e6b10286936ec98c0c Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Thu, 13 Aug 2026 19:36:16 -0300 Subject: [PATCH 01/14] add missing include --- code/graphics/vulkan/VulkanRenderer.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/code/graphics/vulkan/VulkanRenderer.cpp b/code/graphics/vulkan/VulkanRenderer.cpp index a0e1f426051..042d8576672 100644 --- a/code/graphics/vulkan/VulkanRenderer.cpp +++ b/code/graphics/vulkan/VulkanRenderer.cpp @@ -17,6 +17,7 @@ #include "mod_table/mod_table.h" #include +#include VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE From 7ae8d87573926763420f8be6ef719fa9bfe1ce2d Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 15 Aug 2026 14:32:43 -0300 Subject: [PATCH 02/14] Initial work --- code/CMakeLists.txt | 2 + code/bmpman/bmpman.cpp | 4 + code/cfile/cfile.cpp | 25 + code/cfile/cfile.h | 1 + code/cmdline/cmdline.cpp | 8 + code/cmdline/cmdline.h | 1 + code/ddsutils/ddsutils.cpp | 178 +- code/ddsutils/ddsutils.h | 1 + code/ddsutils/ddsutils_etc_cache.cpp | 155 + code/ddsutils/ddsutils_etc_cache.h | 25 + code/graphics/2d.h | 1 + code/graphics/opengl/gropengl.cpp | 6 + code/graphics/vulkan/VulkanRenderer.cpp | 32 + code/graphics/vulkan/VulkanRenderer.h | 10 + code/graphics/vulkan/gr_vulkan.cpp | 5 +- code/source_groups.cmake | 2 + lib/CMakeLists.txt | 2 + lib/etcpak/CMakeLists.txt | 16 + lib/etcpak/etcpak/AUTHORS.txt | 5 + lib/etcpak/etcpak/Bitmap.cpp | 176 + lib/etcpak/etcpak/Bitmap.hpp | 44 + lib/etcpak/etcpak/BitmapDownsampled.cpp | 369 ++ lib/etcpak/etcpak/BitmapDownsampled.hpp | 13 + lib/etcpak/etcpak/BlockData.cpp | 400 +++ lib/etcpak/etcpak/BlockData.hpp | 52 + lib/etcpak/etcpak/ColorSpace.cpp | 114 + lib/etcpak/etcpak/ColorSpace.hpp | 36 + lib/etcpak/etcpak/DataProvider.cpp | 78 + lib/etcpak/etcpak/DataProvider.hpp | 42 + lib/etcpak/etcpak/Debug.cpp | 31 + lib/etcpak/etcpak/Debug.hpp | 27 + lib/etcpak/etcpak/Decode.cpp | 1286 +++++++ lib/etcpak/etcpak/Decode.hpp | 19 + lib/etcpak/etcpak/Dither.cpp | 125 + lib/etcpak/etcpak/Dither.hpp | 21 + lib/etcpak/etcpak/Error.cpp | 48 + lib/etcpak/etcpak/Error.hpp | 9 + lib/etcpak/etcpak/ForceInline.hpp | 20 + lib/etcpak/etcpak/LICENSE.txt | 26 + lib/etcpak/etcpak/Math.hpp | 92 + lib/etcpak/etcpak/MipMap.hpp | 11 + lib/etcpak/etcpak/ProcessCommon.hpp | 50 + lib/etcpak/etcpak/ProcessDxtc.cpp | 1120 ++++++ lib/etcpak/etcpak/ProcessDxtc.hpp | 18 + lib/etcpak/etcpak/ProcessRGB.cpp | 4215 +++++++++++++++++++++++ lib/etcpak/etcpak/ProcessRGB.hpp | 14 + lib/etcpak/etcpak/README.md | 85 + lib/etcpak/etcpak/Semaphore.hpp | 46 + lib/etcpak/etcpak/System.cpp | 68 + lib/etcpak/etcpak/System.hpp | 15 + lib/etcpak/etcpak/Tables.cpp | 223 ++ lib/etcpak/etcpak/Tables.hpp | 54 + lib/etcpak/etcpak/TaskDispatch.cpp | 115 + lib/etcpak/etcpak/TaskDispatch.hpp | 34 + lib/etcpak/etcpak/TextureHeader.cpp | 129 + lib/etcpak/etcpak/TextureHeader.hpp | 24 + lib/etcpak/etcpak/Timing.cpp | 8 + lib/etcpak/etcpak/Timing.hpp | 8 + lib/etcpak/etcpak/Vector.hpp | 222 ++ lib/etcpak/etcpak/mmap.cpp | 38 + lib/etcpak/etcpak/mmap.hpp | 19 + lib/etcpak/etcpak/simd.py | 118 + lib/opengl/gl/glad/include/glad/glad.h | 11 +- lib/opengl/gl/glad/src/glad.c | 9 +- 64 files changed, 10146 insertions(+), 15 deletions(-) create mode 100644 code/ddsutils/ddsutils_etc_cache.cpp create mode 100644 code/ddsutils/ddsutils_etc_cache.h create mode 100644 lib/etcpak/CMakeLists.txt create mode 100644 lib/etcpak/etcpak/AUTHORS.txt create mode 100644 lib/etcpak/etcpak/Bitmap.cpp create mode 100644 lib/etcpak/etcpak/Bitmap.hpp create mode 100644 lib/etcpak/etcpak/BitmapDownsampled.cpp create mode 100644 lib/etcpak/etcpak/BitmapDownsampled.hpp create mode 100644 lib/etcpak/etcpak/BlockData.cpp create mode 100644 lib/etcpak/etcpak/BlockData.hpp create mode 100644 lib/etcpak/etcpak/ColorSpace.cpp create mode 100644 lib/etcpak/etcpak/ColorSpace.hpp create mode 100644 lib/etcpak/etcpak/DataProvider.cpp create mode 100644 lib/etcpak/etcpak/DataProvider.hpp create mode 100644 lib/etcpak/etcpak/Debug.cpp create mode 100644 lib/etcpak/etcpak/Debug.hpp create mode 100644 lib/etcpak/etcpak/Decode.cpp create mode 100644 lib/etcpak/etcpak/Decode.hpp create mode 100644 lib/etcpak/etcpak/Dither.cpp create mode 100644 lib/etcpak/etcpak/Dither.hpp create mode 100644 lib/etcpak/etcpak/Error.cpp create mode 100644 lib/etcpak/etcpak/Error.hpp create mode 100644 lib/etcpak/etcpak/ForceInline.hpp create mode 100644 lib/etcpak/etcpak/LICENSE.txt create mode 100644 lib/etcpak/etcpak/Math.hpp create mode 100644 lib/etcpak/etcpak/MipMap.hpp create mode 100644 lib/etcpak/etcpak/ProcessCommon.hpp create mode 100644 lib/etcpak/etcpak/ProcessDxtc.cpp create mode 100644 lib/etcpak/etcpak/ProcessDxtc.hpp create mode 100644 lib/etcpak/etcpak/ProcessRGB.cpp create mode 100644 lib/etcpak/etcpak/ProcessRGB.hpp create mode 100644 lib/etcpak/etcpak/README.md create mode 100644 lib/etcpak/etcpak/Semaphore.hpp create mode 100644 lib/etcpak/etcpak/System.cpp create mode 100644 lib/etcpak/etcpak/System.hpp create mode 100644 lib/etcpak/etcpak/Tables.cpp create mode 100644 lib/etcpak/etcpak/Tables.hpp create mode 100644 lib/etcpak/etcpak/TaskDispatch.cpp create mode 100644 lib/etcpak/etcpak/TaskDispatch.hpp create mode 100644 lib/etcpak/etcpak/TextureHeader.cpp create mode 100644 lib/etcpak/etcpak/TextureHeader.hpp create mode 100644 lib/etcpak/etcpak/Timing.cpp create mode 100644 lib/etcpak/etcpak/Timing.hpp create mode 100644 lib/etcpak/etcpak/Vector.hpp create mode 100644 lib/etcpak/etcpak/mmap.cpp create mode 100644 lib/etcpak/etcpak/mmap.hpp create mode 100644 lib/etcpak/etcpak/simd.py diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt index 4cc52dcea77..e7511e28a24 100644 --- a/code/CMakeLists.txt +++ b/code/CMakeLists.txt @@ -52,6 +52,8 @@ TARGET_LINK_LIBRARIES(code PUBLIC compiler) target_link_libraries(code PUBLIC md5) +target_link_libraries(code PUBLIC etcpak) + if (FSO_BUILD_WITH_DISCORD) target_link_libraries(code PUBLIC discord-rpc) add_definitions(-DWITH_DISCORD) diff --git a/code/bmpman/bmpman.cpp b/code/bmpman/bmpman.cpp index 9b9788adb67..77f8b0be69e 100644 --- a/code/bmpman/bmpman.cpp +++ b/code/bmpman/bmpman.cpp @@ -1154,6 +1154,10 @@ static int bm_load_info(BM_TYPE type, const char *filename, CFILE *img_cfp, int *c_type = BM_TYPE_BC7; break; + case DDS_ETC2_RGBA8: + *c_type = BM_TYPE_ETC2_RGBA_EAC; + break; + case DDS_UNCOMPRESSED: *c_type = BM_TYPE_DDS; break; diff --git a/code/cfile/cfile.cpp b/code/cfile/cfile.cpp index 12f6df421a9..d90eee647a2 100644 --- a/code/cfile/cfile.cpp +++ b/code/cfile/cfile.cpp @@ -566,6 +566,31 @@ int cf_rename(const char *old_name, const char *name, int dir_type) } +int cf_rename(const char* old_name, const char* name, int dir_type, int location_flags) +{ + Assert(CF_TYPE_SPECIFIED(dir_type)); + + int ret_code; + SCP_string old_longname; + SCP_string new_longname; + + cf_create_default_path_string(old_longname, dir_type, old_name, location_flags); + cf_create_default_path_string(new_longname, dir_type, name, location_flags); + + ret_code = rename(old_longname.c_str(), new_longname.c_str()); + if (ret_code != 0) { + switch (errno) { + case EACCES: + return CF_RENAME_FAIL_ACCESS; + case ENOENT: + default: + return CF_RENAME_FAIL_EXIST; + } + } + + return CF_RENAME_SUCCESS; +} + // This takes a path (e.g. "C:\Games\FreeSpace2\Lots\More\Directories") and creates it in its entirety. // Do note that this requires the path to have normalized directory separators as defined by DIR_SEPARATOR_CHAR diff --git a/code/cfile/cfile.h b/code/cfile/cfile.h index 7c720ac2371..fea27dededa 100644 --- a/code/cfile/cfile.h +++ b/code/cfile/cfile.h @@ -289,6 +289,7 @@ uint cf_add_chksum_long(uint seed, ubyte *buffer, size_t size); #define CF_RENAME_FAIL_ACCESS 1 // new name could not be created #define CF_RENAME_FAIL_EXIST 2 // old name does not exist int cf_rename(const char *old_name, const char *name, int type = CF_TYPE_ANY ); +int cf_rename(const char *old_name, const char *name, int type, int location_flags); // Creates the directory path if it doesn't exist. Even creates all its // parent paths. diff --git a/code/cmdline/cmdline.cpp b/code/cmdline/cmdline.cpp index 7d3cd575ca1..9077541732e 100644 --- a/code/cmdline/cmdline.cpp +++ b/code/cmdline/cmdline.cpp @@ -238,6 +238,7 @@ Flag exe_params[] = { "-log_multi_packet", "Log multi packet types ", true, 0, EASY_DEFAULT, "Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-log_multi_packet",}, { "-no_bsp_align", "Disable pof BSP data alignment", true, 0, EASY_DEFAULT, "Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_bsp_align", }, { "-no_large_shaders", "Split large shader into smaller shaders", true, 0, EASY_DEFAULT, "Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_large_shaders", }, + { "-no_transcode_cache","Disables the ETC2 transcode cache", true, 0, EASY_DEFAULT, "Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_transcode_cache", }, #ifdef WIN32 { "-fix_registry", "Use a different registry path", true, 0, EASY_DEFAULT, "Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fix_registry", }, @@ -470,6 +471,7 @@ cmdline_parm no_large_shaders("-no_large_shaders", NULL, AT_NONE); #ifdef WIN32 cmdline_parm fix_registry("-fix_registry", NULL, AT_NONE); #endif +cmdline_parm no_transcode_cache_arg("-no_transcode_cache", NULL, AT_NONE); int Cmdline_load_all_weapons = 0; int Cmdline_nomovies = 0; @@ -494,6 +496,7 @@ bool Cmdline_no_large_shaders = false; #ifdef WIN32 bool Cmdline_alternate_registry_path = false; #endif +bool Cmdline_no_transcode_cache = false; uint Cmdline_rng_seed = 0; bool Cmdline_reuse_rng_seed = false; @@ -2162,6 +2165,11 @@ bool SetCmdlineParams() if (no_large_shaders.found()) { Cmdline_no_large_shaders = true; } + + if (no_transcode_cache_arg.found()) + { + Cmdline_no_transcode_cache = true; + } #ifdef WIN32 if (fix_registry.found()) { diff --git a/code/cmdline/cmdline.h b/code/cmdline/cmdline.h index c2c1c4911b3..10009e0dee6 100644 --- a/code/cmdline/cmdline.h +++ b/code/cmdline/cmdline.h @@ -129,6 +129,7 @@ extern bool Cmdline_no_large_shaders; #ifdef WIN32 extern bool Cmdline_alternate_registry_path; #endif +extern bool Cmdline_no_transcode_cache; // Developer/Testing related extern char *Cmdline_start_mission; diff --git a/code/ddsutils/ddsutils.cpp b/code/ddsutils/ddsutils.cpp index 1cf1bd78187..2b37d5ed60e 100644 --- a/code/ddsutils/ddsutils.cpp +++ b/code/ddsutils/ddsutils.cpp @@ -1,8 +1,10 @@ #include "ddsutils/ddsutils.h" +#include "ddsutils/ddsutils_etc_cache.h" #include "cfile/cfile.h" #include "graphics/2d.h" #include "osapi/osregistry.h" +#include "cmdline/cmdline.h" #ifdef USE_OPENGL_ES #include "graphics/opengl/es_compatibility.h" #endif @@ -12,6 +14,10 @@ PUSH_SUPPRESS_WARNINGS #include "ddsutils/bcdec.h" POP_SUPPRESS_WARNINGS +PUSH_SUPPRESS_WARNINGS +#include +POP_SUPPRESS_WARNINGS + /* Currently supported formats: * DXT1a (compressed) * DXT1c (compressed) @@ -68,6 +74,37 @@ static bool conversion_needed(const DDS_HEADER &dds_header) return false; } +enum class dds_conv_target { none, bgra, etc2 }; + +static dds_conv_target dds_get_conversion_target(const DDS_HEADER &dds_header) +{ + if ( !conversion_needed(dds_header) ) { + return dds_conv_target::none; + } + + const bool is_cubemap = (dds_header.dwCaps2 & DDSCAPS2_CUBEMAP) == DDSCAPS2_CUBEMAP; + const bool has_depth = (dds_header.dwFlags & DDSD_DEPTH) == DDSD_DEPTH; + + if ( !is_cubemap && !has_depth && gr_is_capable(gr_capability::CAPABILITY_ETC2) ) { + return dds_conv_target::etc2; + } + + return dds_conv_target::bgra; +} + +static size_t compute_etc2_rgba_size(const DDS_HEADER &dds_header) +{ + size_t total = 0; + + for (uint i = 0; i < dds_header.dwMipMapCount; i++) { + const uint w = std::max(1U, dds_header.dwWidth >> i); + const uint h = std::max(1U, dds_header.dwHeight >> i); + total += static_cast((w + 3) / 4) * ((h + 3) / 4) * 16; + } + + return total; +} + // Memory usage for uncompressed textures is quite high. Some MVP assets can // require well over a GB of VRAM for a single ship after conversion. To help // alleviate this we need to resize those textures where possible. At 1024x1024 @@ -262,6 +299,7 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh int ct = DDS_UNCOMPRESSED; int is_cubemap = 0; bool convert = false; + dds_conv_target conv_target = dds_conv_target::none; if (img_cfp == NULL) { @@ -352,9 +390,15 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh } // maybe do conversion if format not supported - convert = conversion_needed(dds_header); + conv_target = dds_get_conversion_target(dds_header); + convert = (conv_target != dds_conv_target::none); + + if (conv_target == dds_conv_target::etc2) { + dds_header.dwMipMapCount -= conversion_resize(dds_header); + dds_header.dwMipMapCount = std::max(1U, dds_header.dwMipMapCount); - if (convert) { + ct = DDS_ETC2_RGBA8; + } else if (convert) { // switch to uncompressed format and reset vars dds_header.ddspf.dwFlags &= ~DDPF_FOURCC; dds_header.ddspf.dwFlags |= DDPF_RGB; @@ -375,8 +419,12 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh } // stuff important info - if (size) - *size = compute_dds_size(dds_header, convert); + if (size) { + if (conv_target == dds_conv_target::etc2) + *size = compute_etc2_rgba_size(dds_header); + else + *size = compute_dds_size(dds_header, convert); + } if (bpp) *bpp = get_bit_count(dds_header); @@ -420,8 +468,8 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) // make sure there is an extension strcpy_s(real_name, filename); - char *p = strchr(real_name, '.'); - if (p) { *p = 0; } + char *per = strchr(real_name, '.'); + if (per) { *per = 0; } strcat_s(real_name, ".dds"); // open it up and go to the data section @@ -445,9 +493,123 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) size = compute_dds_size(dds_header); // don't add padding on this one!! + const dds_conv_target tgt = dds_get_conversion_target(dds_header); + // read in the data - if ( !conversion_needed(dds_header) ) { + if ( tgt == dds_conv_target::none ) { cfread(data, 1, (int)size, cfp); + } else if (tgt == dds_conv_target::etc2) { + //Convert to ETC2 RGBA8 EAC + const uint orig_width = dds_header.dwWidth; + const uint orig_height = dds_header.dwHeight; + const uint orig_mips = dds_header.dwMipMapCount; + + // NOTE: this alters the width, height, and depth values in the header, + // so we have to jump through some hoops to get the proper values + const uint mipmap_offset = conversion_resize(dds_header); + const uint out_mips = orig_mips - mipmap_offset; + + size_t etc2_size = 0; + for (uint m = 0; m < out_mips; ++m) { + const uint w = std::max(1U, dds_header.dwWidth >> m); + const uint h = std::max(1U, dds_header.dwHeight >> m); + etc2_size += (size_t)((w + 3) / 4) * ((h + 3) / 4) * 16; + } + + extern bool Cmdline_no_transcode_cache; + SCP_string key; + + if (!Cmdline_no_transcode_cache) { + //Build the cache MD5 hash + key = etc2_cache_make_key(cfp, dds_header.ddspf.dwFourCC, DDS_ETC2_RGBA8, 1024); + + //Try to load from a cache file + if (etc2_cache_try_load(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, DDS_ETC2_RGBA8, etc2_size, data)) { + if (bpp) + *bpp = (ubyte)32; + cfclose(cfp); + return DDS_ERROR_NONE; + } + } + + void (*decode)(const void* in, void* out, int pitch) = nullptr; + uint32_t block_bytes = 0; + + switch (dds_header.ddspf.dwFourCC) { + case FOURCC_DX10: + decode = bcdec_bc7; + block_bytes = BCDEC_BC7_BLOCK_SIZE; + break; + case FOURCC_DXT5: + decode = bcdec_bc3; + block_bytes = BCDEC_BC3_BLOCK_SIZE; + break; + case FOURCC_DXT1: + decode = bcdec_bc1; + block_bytes = BCDEC_BC1_BLOCK_SIZE; + break; + case FOURCC_DXT3: + decode = bcdec_bc2; + block_bytes = BCDEC_BC2_BLOCK_SIZE; + break; + default: + Error(LOCATION, "Invalid FourCC (%d) for DDS ETC2 transcode!", dds_header.ddspf.dwFourCC); + break; + } + + ubyte* comp_data = (ubyte*)vm_malloc(size); + cfread(comp_data, 1, (int)size, cfp); + + const uint max_w = (dds_header.dwWidth + 3) & ~3u; + const uint max_h = (dds_header.dwHeight + 3) & ~3u; + ubyte* rgba = (ubyte*)vm_malloc((size_t)max_w * max_h * 4); + + ubyte* src = comp_data; + size_t out_offset = 0; + + // if we resized then skip over all of that data (altering values to match pre-resize) + for (uint x = 0; x < mipmap_offset; ++x) { + const uint sw = std::max(1U, orig_width >> x); + const uint sh = std::max(1U, orig_height >> x); + src += (size_t)((sw + 3) / 4) * ((sh + 3) / 4) * block_bytes; + } + + for (uint m = mipmap_offset; m < orig_mips; ++m) { + // width/height/depth at post-resize mipmap sizes, so compensate here + const uint w = std::max(1U, dds_header.dwWidth >> (m - mipmap_offset)); + const uint h = std::max(1U, dds_header.dwHeight >> (m - mipmap_offset)); + const uint pw = (w + 3) & ~3u; + const uint ph = (h + 3) & ~3u; + + for (uint i = 0; i < ph; i += 4) { + for (uint j = 0; j < pw; j += 4) { + decode(src, rgba + ((size_t)i * pw + j) * 4, (int)(pw * 4)); + src += block_bytes; + } + } + + // R<->B + const size_t px_count = (size_t)pw * ph; + for (size_t p = 0; p < px_count; ++p) { + ubyte* px = rgba + p * 4; + const ubyte tmp = px[0]; + px[0] = px[2]; + px[2] = tmp; + } + + const uint32_t blocks = (pw / 4) * (ph / 4); + CompressEtc2Rgba(reinterpret_cast(rgba), reinterpret_cast(data + out_offset), blocks, pw, true); + // bump data offset to next layer + out_offset += (size_t)blocks * 16; + } + + if (!Cmdline_no_transcode_cache) { + //Save to cache + etc2_cache_store(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, DDS_ETC2_RGBA8, data, etc2_size); + } + vm_free(rgba); + vm_free(comp_data); + comp_data = nullptr; } else { // Compression format not supported, convert to BGRA ubyte *comp_data = (ubyte*)vm_malloc(size); @@ -538,7 +700,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) } if (bpp) - *bpp = (ubyte)get_bit_count(dds_header); + *bpp = (tgt == dds_conv_target::etc2) ? (ubyte)32 : (ubyte)get_bit_count(dds_header); // we look done here cfclose(cfp); diff --git a/code/ddsutils/ddsutils.h b/code/ddsutils/ddsutils.h index 5145f360a9b..c15a436fe01 100644 --- a/code/ddsutils/ddsutils.h +++ b/code/ddsutils/ddsutils.h @@ -28,6 +28,7 @@ #define DDS_CUBEMAP_DXT1 11 #define DDS_CUBEMAP_DXT3 13 #define DDS_CUBEMAP_DXT5 15 +#define DDS_ETC2_RGBA8 20 #ifndef MAKEFOURCC #define MAKEFOURCC(ch0, ch1, ch2, ch3) \ diff --git a/code/ddsutils/ddsutils_etc_cache.cpp b/code/ddsutils/ddsutils_etc_cache.cpp new file mode 100644 index 00000000000..c1cbe1640bd --- /dev/null +++ b/code/ddsutils/ddsutils_etc_cache.cpp @@ -0,0 +1,155 @@ +#include "ddsutils/ddsutils_etc_cache.h" +#include "cfile/cfile.h" + +#include + +#include + +#define ETC2_CACHE_VERSION_TAG "etc2-v1" +#define ETC2_CACHE_MAGIC 0x32435445u +#define ETC2_CACHE_VERSION 1u +#define ETC2_CACHE_CHKSUM_WINDOW 65536 + +static const uint32_t CACHE_LOCATION_FLAGS = CF_LOCATION_ROOT_USER | CF_LOCATION_TYPE_ROOT; + +static SCP_string etc2_cache_filename(const SCP_string &key) +{ + return SCP_string("etc2-") + key + ".cache"; +} + +static SCP_string etc2_cache_temp_filename(const SCP_string &key) +{ + return SCP_string("etc2-") + key + ".cache.tmp"; +} + +SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint max_size) +{ + const int saved_pos = cftell(dds); + + cfseek(dds, 0, CF_SEEK_SET); + + uint src_crc = 0; + cf_chksum_long(dds, &src_crc, ETC2_CACHE_CHKSUM_WINDOW); + + const uint src_len = (uint)cfilelength(dds); + + cfseek(dds, saved_pos, CF_SEEK_SET); + + const char* name = cf_get_filename(dds); + if (name == nullptr) { + name = ""; + } + + MD5 md5; + md5.update(ETC2_CACHE_VERSION_TAG, (MD5::size_type)strlen(ETC2_CACHE_VERSION_TAG)); + md5.update(name, (MD5::size_type)strlen(name)); + md5.update(reinterpret_cast(&src_crc), sizeof(src_crc)); + md5.update(reinterpret_cast(&src_len), sizeof(src_len)); + md5.update(reinterpret_cast(&src_fourcc), sizeof(src_fourcc)); + md5.update(reinterpret_cast(&dst_format), sizeof(dst_format)); + md5.update(reinterpret_cast(&max_size), sizeof(max_size)); + md5.finalize(); + + return md5.hexdigest(); +} + +bool etc2_cache_try_load(const SCP_string &key, + uint expected_width, + uint expected_height, + uint expected_mips, + int expected_format, + size_t expected_size, + ubyte *out_data) +{ + const SCP_string name = etc2_cache_filename(key); + + CFILE *fp = cfopen(name.c_str(), "rb", CF_TYPE_CACHE, false, CACHE_LOCATION_FLAGS); + + if (fp == nullptr) { + return false; + } + + const uint magic = cfread_uint(fp); + const uint version = cfread_uint(fp); + const uint format = cfread_uint(fp); + const uint width = cfread_uint(fp); + const uint height = cfread_uint(fp); + const uint mips = cfread_uint(fp); + const uint payload_size = cfread_uint(fp); + const uint payload_crc = cfread_uint(fp); + + const bool header_ok = (magic == ETC2_CACHE_MAGIC) && + (version == ETC2_CACHE_VERSION) && + (format == (uint)expected_format) && + (width == expected_width) && + (height == expected_height) && + (mips == expected_mips) && + (payload_size == (uint)expected_size); + + if (!header_ok) { + cfclose(fp); + return false; + } + + const int got = cfread(out_data, 1, (int)payload_size, fp); + + cfclose(fp); + + if (got != (int)payload_size) { + cf_delete(name.c_str(), CF_TYPE_CACHE); + return false; + } + + const uint crc = cf_add_chksum_long(0, out_data, payload_size); + + if (crc != payload_crc) { + cf_delete(name.c_str(), CF_TYPE_CACHE); + return false; + } + + return true; +} + +void etc2_cache_store(const SCP_string &key, + uint width, + uint height, + uint mips, + int format, + const ubyte *payload, + size_t payload_size) +{ + if (payload == nullptr || payload_size == 0) { + return; + } + + const SCP_string temp_name = etc2_cache_temp_filename(key); + const SCP_string final_name = etc2_cache_filename(key); + + CFILE *fp = cfopen(temp_name.c_str(), "wb", CF_TYPE_CACHE, false, CACHE_LOCATION_FLAGS); + + if (fp == nullptr) { + return; + } + + const uint payload_crc = cf_add_chksum_long(0, const_cast(payload), payload_size); + + cfwrite_uint(ETC2_CACHE_MAGIC, fp); + cfwrite_uint(ETC2_CACHE_VERSION, fp); + cfwrite_uint((uint)format, fp); + cfwrite_uint(width, fp); + cfwrite_uint(height, fp); + cfwrite_uint(mips, fp); + cfwrite_uint((uint)payload_size, fp); + cfwrite_uint(payload_crc, fp); + + const int written = cfwrite(payload, 1, (int)payload_size, fp); + + cfclose(fp); + + if (written != (int)payload_size) { + cf_delete(temp_name.c_str(), CF_TYPE_CACHE); + return; + } + + cf_rename(temp_name.c_str(), final_name.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); +} diff --git a/code/ddsutils/ddsutils_etc_cache.h b/code/ddsutils/ddsutils_etc_cache.h new file mode 100644 index 00000000000..e3ad4357cae --- /dev/null +++ b/code/ddsutils/ddsutils_etc_cache.h @@ -0,0 +1,25 @@ +#ifndef _DDSUTILS_ETC_CACHE_H +#define _DDSUTILS_ETC_CACHE_H + +#include "globalincs/pstypes.h" +#include "cfile/cfile.h" + +SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint max_size); + +bool etc2_cache_try_load(const SCP_string &key, + uint expected_width, + uint expected_height, + uint expected_mips, + int expected_format, + size_t expected_size, + ubyte *out_data); + +void etc2_cache_store(const SCP_string &key, + uint width, + uint height, + uint mips, + int format, + const ubyte *payload, + size_t payload_size); + +#endif diff --git a/code/graphics/2d.h b/code/graphics/2d.h index 0f66ba3539b..71a7935fa27 100644 --- a/code/graphics/2d.h +++ b/code/graphics/2d.h @@ -366,6 +366,7 @@ enum class gr_capability { CAPABILITY_PERSISTENT_BUFFER_MAPPING, CAPABILITY_BPTC, CAPABILITY_S3TC, + CAPABILITY_ETC2, CAPABILITY_LARGE_SHADER, CAPABILITY_INSTANCED_RENDERING, CAPABILITY_FAST_SHADOWS, diff --git a/code/graphics/opengl/gropengl.cpp b/code/graphics/opengl/gropengl.cpp index 444515b797a..01cfdede56e 100644 --- a/code/graphics/opengl/gropengl.cpp +++ b/code/graphics/opengl/gropengl.cpp @@ -1617,6 +1617,12 @@ bool gr_opengl_is_capable(gr_capability capability) return GLAD_GL_ARB_texture_compression_bptc != 0; case gr_capability::CAPABILITY_S3TC: return GLAD_GL_EXT_texture_compression_s3tc != 0; + case gr_capability::CAPABILITY_ETC2: +#ifdef USE_OPENGL_ES + return true; +#else + return GLAD_GL_ARB_ES3_compatibility != 0; +#endif case gr_capability::CAPABILITY_LARGE_SHADER: return !Cmdline_no_large_shaders; case gr_capability::CAPABILITY_INSTANCED_RENDERING: diff --git a/code/graphics/vulkan/VulkanRenderer.cpp b/code/graphics/vulkan/VulkanRenderer.cpp index 042d8576672..63f0ee706ff 100644 --- a/code/graphics/vulkan/VulkanRenderer.cpp +++ b/code/graphics/vulkan/VulkanRenderer.cpp @@ -801,6 +801,38 @@ bool VulkanRenderer::isTextureCompressionBCSupported() const return m_deviceFeatures.textureCompressionBC == VK_TRUE; } +bool VulkanRenderer::isTextureCompressionS3TCSupported() const +{ + if (!m_physicalDevice) { + return false; + } + + if (m_deviceFeatures.textureCompressionBC == VK_TRUE) + return true; + + constexpr std::array formats = { + vk::Format::eBc1RgbaUnormBlock, // DXT1 + vk::Format::eBc2UnormBlock, // DXT3 + vk::Format::eBc3UnormBlock, // DXT5 + }; + + constexpr vk::FormatFeatureFlags required = vk::FormatFeatureFlagBits::eSampledImage | vk::FormatFeatureFlagBits::eSampledImageFilterLinear; + + return std::all_of(formats.begin(), formats.end(), [this, required](vk::Format fmt) { + const auto props = m_physicalDevice.getFormatProperties(fmt); + return (props.optimalTilingFeatures & required) == required; + }); +} + +bool VulkanRenderer::isTextureCompressionETC2Supported() const +{ + if (!m_physicalDevice) { + return false; + } + + return m_deviceFeatures.textureCompressionETC2 == VK_TRUE; +} + bool VulkanRenderer::isDepthClampSupported() const { if (!m_physicalDevice) { diff --git a/code/graphics/vulkan/VulkanRenderer.h b/code/graphics/vulkan/VulkanRenderer.h index 3d890b18a84..528fe52ea5b 100644 --- a/code/graphics/vulkan/VulkanRenderer.h +++ b/code/graphics/vulkan/VulkanRenderer.h @@ -192,6 +192,16 @@ class VulkanRenderer { */ bool isTextureCompressionBCSupported() const; + /** + * @brief Check if BC 1/2/3 texture compression is supported + */ + bool isTextureCompressionS3TCSupported() const; + + /** + * @brief Check if ETC2 texture compression is supported + */ + bool isTextureCompressionETC2Supported() const; + /** * @brief Check if depth clamping is supported (used by the shadow pass) */ diff --git a/code/graphics/vulkan/gr_vulkan.cpp b/code/graphics/vulkan/gr_vulkan.cpp index 8fb01daa2a0..d8ddda284ba 100644 --- a/code/graphics/vulkan/gr_vulkan.cpp +++ b/code/graphics/vulkan/gr_vulkan.cpp @@ -140,7 +140,10 @@ bool vulkan_is_capable(gr_capability capability) return getRendererInstance()->isTextureCompressionBCSupported(); case gr_capability::CAPABILITY_S3TC: // Vulkan always supports BC1/BC2/BC3 (S3TC equivalent) as core features - return true; + // But this is optional on mobile gpus, so check anyway + return getRendererInstance()->isTextureCompressionS3TCSupported(); + case gr_capability::CAPABILITY_ETC2: + return getRendererInstance()->isTextureCompressionETC2Supported(); case gr_capability::CAPABILITY_LARGE_SHADER: // Same troubleshooting switch as OpenGL: -no_large_shaders splits the model // ubershader into per-flag-combination variants for drivers that choke on the diff --git a/code/source_groups.cmake b/code/source_groups.cmake index 913aeff5543..09046652e56 100644 --- a/code/source_groups.cmake +++ b/code/source_groups.cmake @@ -192,6 +192,8 @@ endif() add_file_folder("ddsutils" ddsutils/ddsutils.cpp ddsutils/ddsutils.h + ddsutils/ddsutils_etc_cache.cpp + ddsutils/ddsutils_etc_cache.h ) # Debris files diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 32bae9c16b6..290a4ef394e 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -53,6 +53,8 @@ ADD_SUBDIRECTORY(lz4) ADD_SUBDIRECTORY(imgui) +ADD_SUBDIRECTORY(etcpak) + if(FSO_BUILD_WITH_OPENXR) add_subdirectory(openxr EXCLUDE_FROM_ALL) endif() diff --git a/lib/etcpak/CMakeLists.txt b/lib/etcpak/CMakeLists.txt new file mode 100644 index 00000000000..ef3eac13c67 --- /dev/null +++ b/lib/etcpak/CMakeLists.txt @@ -0,0 +1,16 @@ +set(ETCPAK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/etcpak") + +set(ETCPAK_SOURCES + "${ETCPAK_DIR}/ProcessRGB.cpp" + "${ETCPAK_DIR}/Tables.cpp" + "${ETCPAK_DIR}/Dither.cpp") + +add_library(etcpak STATIC ${ETCPAK_SOURCES}) + +target_include_directories(etcpak SYSTEM PUBLIC "${ETCPAK_DIR}") + +suppress_warnings(etcpak) + +set_target_properties(etcpak PROPERTIES FOLDER "3rdparty") + +target_link_libraries(etcpak PUBLIC compiler) \ No newline at end of file diff --git a/lib/etcpak/etcpak/AUTHORS.txt b/lib/etcpak/etcpak/AUTHORS.txt new file mode 100644 index 00000000000..675b4eb2a9d --- /dev/null +++ b/lib/etcpak/etcpak/AUTHORS.txt @@ -0,0 +1,5 @@ +Bartosz Taudul +Daniel Jungmann +Florian Penzkofer +Jae-Ho Nah +Marcin Ławicki diff --git a/lib/etcpak/etcpak/Bitmap.cpp b/lib/etcpak/etcpak/Bitmap.cpp new file mode 100644 index 00000000000..0260e781eb1 --- /dev/null +++ b/lib/etcpak/etcpak/Bitmap.cpp @@ -0,0 +1,176 @@ +#include +#include +#include +#include + +#include + +#include "Bitmap.hpp" +#include "Debug.hpp" + +Bitmap::Bitmap( const char* fn, unsigned int lines, bool bgr ) + : m_block( nullptr ) + , m_lines( lines ) + , m_alpha( true ) + , m_sema( 0 ) +{ + FILE* f = fopen( fn, "rb" ); + assert( f ); + + unsigned int sig_read = 0; + int bit_depth, color_type, interlace_type; + + png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL ); + png_infop info_ptr = png_create_info_struct( png_ptr ); + setjmp( png_jmpbuf( png_ptr ) ); + + png_init_io( png_ptr, f ); + png_set_sig_bytes( png_ptr, sig_read ); + + png_uint_32 w, h; + + png_read_info( png_ptr, info_ptr ); + png_get_IHDR( png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, &interlace_type, NULL, NULL ); + + m_size = v2i( w, h ); + + png_set_strip_16( png_ptr ); + if( color_type == PNG_COLOR_TYPE_PALETTE ) + { + png_set_palette_to_rgb( png_ptr ); + } + else if( color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8 ) + { + png_set_expand_gray_1_2_4_to_8( png_ptr ); + } + if( png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS ) ) + { + png_set_tRNS_to_alpha( png_ptr ); + } + if( color_type == PNG_COLOR_TYPE_GRAY_ALPHA ) + { + png_set_gray_to_rgb(png_ptr); + } + if( bgr ) + { + png_set_bgr(png_ptr); + } + + switch( color_type ) + { + case PNG_COLOR_TYPE_PALETTE: + if( !png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS ) ) + { + png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER ); + m_alpha = false; + } + break; + case PNG_COLOR_TYPE_GRAY_ALPHA: + png_set_gray_to_rgb( png_ptr ); + break; + case PNG_COLOR_TYPE_RGB: + png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER ); + m_alpha = false; + break; + default: + break; + } + + DBGPRINT( "Bitmap " << fn << " " << w << "x" << h ); + + assert( w % 4 == 0 ); + assert( h % 4 == 0 ); + + m_block = m_data = new uint32_t[w*h]; + m_linesLeft = h / 4; + + m_load = std::async( std::launch::async, [this, f, png_ptr, info_ptr]() mutable + { + auto ptr = m_data; + unsigned int lines = 0; + for( int i=0; i= m_lines ) + { + lines = 0; + m_sema.unlock(); + } + } + + if( lines != 0 ) + { + m_sema.unlock(); + } + + png_read_end( png_ptr, info_ptr ); + png_destroy_read_struct( &png_ptr, &info_ptr, NULL ); + fclose( f ); + } ); +} + +Bitmap::Bitmap( const v2i& size ) + : m_data( new uint32_t[size.x*size.y] ) + , m_block( nullptr ) + , m_lines( 1 ) + , m_linesLeft( size.y / 4 ) + , m_size( size ) + , m_sema( 0 ) +{ +} + +Bitmap::Bitmap( const Bitmap& src, unsigned int lines ) + : m_lines( lines ) + , m_alpha( src.Alpha() ) + , m_sema( 0 ) +{ +} + +Bitmap::~Bitmap() +{ + delete[] m_data; +} + +void Bitmap::Write( const char* fn ) +{ + FILE* f = fopen( fn, "wb" ); + assert( f ); + + png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL ); + png_infop info_ptr = png_create_info_struct( png_ptr ); + setjmp( png_jmpbuf( png_ptr ) ); + png_init_io( png_ptr, f ); + + png_set_IHDR( png_ptr, info_ptr, m_size.x, m_size.y, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE ); + + png_write_info( png_ptr, info_ptr ); + + uint32_t* ptr = m_data; + for( int i=0; i lock( m_lock ); + lines = std::min( m_lines, m_linesLeft ); + auto ret = m_block; + m_sema.lock(); + m_block += m_size.x * 4 * lines; + m_linesLeft -= lines; + done = m_linesLeft == 0; + return ret; +} diff --git a/lib/etcpak/etcpak/Bitmap.hpp b/lib/etcpak/etcpak/Bitmap.hpp new file mode 100644 index 00000000000..f197e7d2963 --- /dev/null +++ b/lib/etcpak/etcpak/Bitmap.hpp @@ -0,0 +1,44 @@ +#ifndef __DARKRL__BITMAP_HPP__ +#define __DARKRL__BITMAP_HPP__ + +#include +#include +#include +#include + +#include "Semaphore.hpp" +#include "Vector.hpp" + +class Bitmap +{ +public: + Bitmap( const char* fn, unsigned int lines, bool bgr ); + Bitmap( const v2i& size ); + virtual ~Bitmap(); + + void Write( const char* fn ); + + uint32_t* Data() { if( m_load.valid() ) m_load.wait(); return m_data; } + const uint32_t* Data() const { if( m_load.valid() ) m_load.wait(); return m_data; } + const v2i& Size() const { return m_size; } + bool Alpha() const { return m_alpha; } + + const uint32_t* NextBlock( unsigned int& lines, bool& done ); + +protected: + Bitmap( const Bitmap& src, unsigned int lines ); + + uint32_t* m_data; + uint32_t* m_block; + unsigned int m_lines; + unsigned int m_linesLeft; + v2i m_size; + bool m_alpha; + Semaphore m_sema; + std::mutex m_lock; + std::future m_load; +}; + +typedef std::shared_ptr BitmapPtr; + +#endif diff --git a/lib/etcpak/etcpak/BitmapDownsampled.cpp b/lib/etcpak/etcpak/BitmapDownsampled.cpp new file mode 100644 index 00000000000..4fb06cabc93 --- /dev/null +++ b/lib/etcpak/etcpak/BitmapDownsampled.cpp @@ -0,0 +1,369 @@ +#include +#include + +#include "BitmapDownsampled.hpp" +#include "Debug.hpp" + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER +# ifdef _MSC_VER +# include +# else +# include +# endif +#endif + + +static const float SrgbToLinear[256] = { + 0.00000000f, 0.00030353f, 0.00060705f, 0.00091058f, 0.00121411f, 0.00151763f, 0.00182116f, 0.00212469f, 0.00242822f, 0.00273174f, 0.00303527f, 0.00334654f, 0.00367651f, 0.00402472f, 0.00439144f, 0.00477695f, + 0.00518152f, 0.00560539f, 0.00604883f, 0.00651209f, 0.00699541f, 0.00749903f, 0.00802319f, 0.00856813f, 0.00913406f, 0.00972122f, 0.01032982f, 0.01096010f, 0.01161225f, 0.01228649f, 0.01298303f, 0.01370208f, + 0.01444385f, 0.01520852f, 0.01599630f, 0.01680738f, 0.01764196f, 0.01850022f, 0.01938237f, 0.02028857f, 0.02121901f, 0.02217389f, 0.02315337f, 0.02415763f, 0.02518686f, 0.02624123f, 0.02732090f, 0.02842604f, + 0.02955684f, 0.03071345f, 0.03189604f, 0.03310477f, 0.03433981f, 0.03560132f, 0.03688945f, 0.03820437f, 0.03954624f, 0.04091520f, 0.04231142f, 0.04373503f, 0.04518621f, 0.04666509f, 0.04817183f, 0.04970657f, + 0.05126947f, 0.05286066f, 0.05448029f, 0.05612850f, 0.05780544f, 0.05951125f, 0.06124608f, 0.06301004f, 0.06480329f, 0.06662596f, 0.06847819f, 0.07036012f, 0.07227187f, 0.07421359f, 0.07618540f, 0.07818744f, + 0.08021984f, 0.08228272f, 0.08437622f, 0.08650047f, 0.08865561f, 0.09084174f, 0.09305899f, 0.09530749f, 0.09758737f, 0.09989875f, 0.10224175f, 0.10461651f, 0.10702312f, 0.10946173f, 0.11193245f, 0.11443539f, + 0.11697068f, 0.11953844f, 0.12213881f, 0.12477185f, 0.12743771f, 0.13013650f, 0.13286835f, 0.13563335f, 0.13843164f, 0.14126332f, 0.14412849f, 0.14702728f, 0.14995980f, 0.15292618f, 0.15592648f, 0.15896088f, + 0.16202942f, 0.16513222f, 0.16826941f, 0.17144111f, 0.17464741f, 0.17788842f, 0.18116425f, 0.18447499f, 0.18782078f, 0.19120169f, 0.19461782f, 0.19806932f, 0.20155625f, 0.20507872f, 0.20863685f, 0.21223074f, + 0.21586055f, 0.21952623f, 0.22322799f, 0.22696590f, 0.23074009f, 0.23455067f, 0.23839766f, 0.24228121f, 0.24620141f, 0.25015837f, 0.25415218f, 0.25818294f, 0.26225075f, 0.26635569f, 0.27049786f, 0.27467740f, + 0.27889434f, 0.28314883f, 0.28744090f, 0.29177073f, 0.29613835f, 0.30054384f, 0.30498737f, 0.30946898f, 0.31398878f, 0.31854683f, 0.32314327f, 0.32777816f, 0.33245158f, 0.33716366f, 0.34191447f, 0.34670410f, + 0.35153273f, 0.35640025f, 0.36130691f, 0.36625272f, 0.37123778f, 0.37626222f, 0.38132611f, 0.38642955f, 0.39157256f, 0.39675534f, 0.40197787f, 0.40724030f, 0.41254270f, 0.41788515f, 0.42326775f, 0.42869058f, + 0.43415371f, 0.43965724f, 0.44520128f, 0.45078585f, 0.45641109f, 0.46207705f, 0.46778387f, 0.47353154f, 0.47932023f, 0.48515001f, 0.49102089f, 0.49693304f, 0.50288659f, 0.50888145f, 0.51491779f, 0.52099568f, + 0.52711529f, 0.53327656f, 0.53947961f, 0.54572457f, 0.55201155f, 0.55834049f, 0.56471163f, 0.57112491f, 0.57758057f, 0.58407855f, 0.59061897f, 0.59720188f, 0.60382742f, 0.61049569f, 0.61720663f, 0.62396049f, + 0.63075721f, 0.63759696f, 0.64447975f, 0.65140569f, 0.65837491f, 0.66538733f, 0.67244321f, 0.67954254f, 0.68668550f, 0.69387192f, 0.70110208f, 0.70837593f, 0.71569365f, 0.72305530f, 0.73046088f, 0.73791057f, + 0.74540436f, 0.75294232f, 0.76052463f, 0.76815128f, 0.77582234f, 0.78353792f, 0.79129803f, 0.79910284f, 0.80695236f, 0.81484669f, 0.82278585f, 0.83076996f, 0.83879912f, 0.84687334f, 0.85499269f, 0.86315727f, + 0.87136722f, 0.87962234f, 0.88792318f, 0.89626944f, 0.90466136f, 0.91309869f, 0.92158204f, 0.93011087f, 0.93868589f, 0.94730657f, 0.95597351f, 0.96468627f, 0.97344548f, 0.98225057f, 0.99110222f, 1.00000000f, +}; + + +static inline float rsqrt( float v ) +{ + return 1.f / sqrt( v ); +} + +static inline uint32_t LinearToSrgb( float v ) +{ + const float a = 0.00279491f; + const float b = 1.15907984f; + const float c = 0.15746343f; // b * rsqrt( 1 + a ) - 1; + + return uint32_t( 255 * ( ( b * rsqrt( v + a ) - c ) * v ) ); +} + + +BitmapDownsampled::BitmapDownsampled( const Bitmap& bmp, unsigned int lines, bool linearize ) + : Bitmap( bmp, lines ) +{ + m_size.x = std::max( 1, bmp.Size().x / 2 ); + m_size.y = std::max( 1, bmp.Size().y / 2 ); + + int w = std::max( m_size.x, 4 ); + int h = std::max( m_size.y, 4 ); + + DBGPRINT( "Subbitmap " << m_size.x << "x" << m_size.y ); + + m_block = m_data = new uint32_t[w*h]; + + if( m_size.x < w || m_size.y < h ) + { + memset( m_data, 0, w*h*sizeof( uint32_t ) ); + m_linesLeft = h / 4; + unsigned int lines = 0; + for( int i=0; i m_lines ) + { + lines = 0; + m_sema.unlock(); + } + } + } + if( lines != 0 ) + { + m_sema.unlock(); + } + } + else + { + m_linesLeft = h / 4; + if( linearize ) + { + m_load = std::async( std::launch::async, [this, &bmp, w, h]() mutable + { + auto ptr = m_data; + auto src1 = bmp.Data(); + auto src2 = src1 + bmp.Size().x; + unsigned int lines = 0; + for( int i=0; i 2 ) + { + k -= 2; + + __m128i p0 = _mm_loadu_si128( (__m128i*)src1 ); + __m128i p1 = _mm_loadu_si128( (__m128i*)src2 ); + src1 += 4; + src2 += 4; + + __m256i pxa = _mm256_cvtepu8_epi16( p0 ); + __m256i pxb = _mm256_cvtepu8_epi16( p1 ); + __m256i px0 = _mm256_unpacklo_epi16( pxa, _mm256_setzero_si256() ); + __m256i px1 = _mm256_unpackhi_epi16( pxa, _mm256_setzero_si256() ); + __m256i px2 = _mm256_unpacklo_epi16( pxb, _mm256_setzero_si256() ); + __m256i px3 = _mm256_unpackhi_epi16( pxb, _mm256_setzero_si256() ); + + __m256 f0 = _mm256_cvtepi32_ps( px0 ); + __m256 f1 = _mm256_cvtepi32_ps( px1 ); + __m256 f2 = _mm256_cvtepi32_ps( px2 ); + __m256 f3 = _mm256_cvtepi32_ps( px3 ); + + __m256 m0 = _mm256_mul_ps( f0, _mm256_set1_ps( 0.003921568f ) ); + __m256 m1 = _mm256_mul_ps( f1, _mm256_set1_ps( 0.003921568f ) ); + __m256 m2 = _mm256_mul_ps( f2, _mm256_set1_ps( 0.003921568f ) ); + __m256 m3 = _mm256_mul_ps( f3, _mm256_set1_ps( 0.003921568f ) ); + + __m256 l00 = _mm256_fmadd_ps( m0, _mm256_set1_ps( 0.305306011f ), _mm256_set1_ps( 0.682171111f ) ); + __m256 l01 = _mm256_fmadd_ps( m1, _mm256_set1_ps( 0.305306011f ), _mm256_set1_ps( 0.682171111f ) ); + __m256 l02 = _mm256_fmadd_ps( m2, _mm256_set1_ps( 0.305306011f ), _mm256_set1_ps( 0.682171111f ) ); + __m256 l03 = _mm256_fmadd_ps( m3, _mm256_set1_ps( 0.305306011f ), _mm256_set1_ps( 0.682171111f ) ); + + __m256 l10 = _mm256_fmadd_ps( m0, l00, _mm256_set1_ps( 0.012522878f ) ); + __m256 l11 = _mm256_fmadd_ps( m1, l01, _mm256_set1_ps( 0.012522878f ) ); + __m256 l12 = _mm256_fmadd_ps( m2, l02, _mm256_set1_ps( 0.012522878f ) ); + __m256 l13 = _mm256_fmadd_ps( m3, l03, _mm256_set1_ps( 0.012522878f ) ); + + __m256 l20 = _mm256_mul_ps( m0, l10 ); + __m256 l21 = _mm256_mul_ps( m1, l11 ); + __m256 l22 = _mm256_mul_ps( m2, l12 ); + __m256 l23 = _mm256_mul_ps( m3, l13 ); + + __m256 s0 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( l20 ), _mm256_castps_si256( m0 ), 0x88 ) ); + __m256 s1 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( l21 ), _mm256_castps_si256( m1 ), 0x88 ) ); + __m256 s2 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( l22 ), _mm256_castps_si256( m2 ), 0x88 ) ); + __m256 s3 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( l23 ), _mm256_castps_si256( m3 ), 0x88 ) ); + + __m256 a0 = _mm256_add_ps( s0, s1 ); + __m256 a1 = _mm256_add_ps( s2, s3 ); + __m256 a2 = _mm256_add_ps( a0, a1 ); + + __m256 v = _mm256_mul_ps( a2, _mm256_set1_ps( 0.25f ) ); + __m256 r0 = _mm256_add_ps( v, _mm256_set1_ps( 0.00279491f ) ); + __m256 r1 = _mm256_rsqrt_ps( r0 ); + __m256 r2 = _mm256_fmadd_ps( r1, _mm256_set1_ps( 1.15907984f ), _mm256_set1_ps( -0.15746343f ) ); + __m256 r3 = _mm256_mul_ps( r2, v ); + + __m256 b0 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( r3 ), _mm256_castps_si256( v ), 0x88 ) ); + __m256 b1 = _mm256_mul_ps( b0, _mm256_set1_ps( 255 ) ); + __m256i b2 = _mm256_cvtps_epi32( b1 ); + __m256i b3 = _mm256_packus_epi32( b2, b2 ); + __m256i b4 = _mm256_packus_epi16( b3, b3 ); + + *ptr++ = _mm_cvtsi128_si32( _mm256_castsi256_si128( b4 ) ); + *ptr++ = _mm_cvtsi128_si32( _mm256_extracti128_si256( b4, 1 ) ); + } +#endif + while( k-- ) + { +#ifdef __SSE4_1__ + uint32_t px0 = *src1; + uint32_t px1 = *(src1+1); + uint32_t px2 = *src2; + uint32_t px3 = *(src2+1); + + float p0[4]; + float p1[4]; + float p2[4]; + float p3[4]; + + p0[0] = SrgbToLinear[px0 & 0x000000FF]; + p0[1] = SrgbToLinear[( px0 & 0x0000FF00 ) >> 8]; + p0[2] = SrgbToLinear[( px0 & 0x00FF0000 ) >> 16]; + p0[3] = px0 >> 24; + + p1[0] = SrgbToLinear[px1 & 0x000000FF]; + p1[1] = SrgbToLinear[( px1 & 0x0000FF00 ) >> 8]; + p1[2] = SrgbToLinear[( px1 & 0x00FF0000 ) >> 16]; + p1[3] = px1 >> 24; + + p2[0] = SrgbToLinear[px2 & 0x000000FF]; + p2[1] = SrgbToLinear[( px2 & 0x0000FF00 ) >> 8]; + p2[2] = SrgbToLinear[( px2 & 0x00FF0000 ) >> 16]; + p2[3] = px2 >> 24; + + p3[0] = SrgbToLinear[px3 & 0x000000FF]; + p3[1] = SrgbToLinear[( px3 & 0x0000FF00 ) >> 8]; + p3[2] = SrgbToLinear[( px3 & 0x00FF0000 ) >> 16]; + p3[3] = px3 >> 24; + + __m128 s0 = _mm_loadu_ps( p0 ); + __m128 s1 = _mm_loadu_ps( p1 ); + __m128 s2 = _mm_loadu_ps( p2 ); + __m128 s3 = _mm_loadu_ps( p3 ); + + __m128 a0 = _mm_add_ps( s0, s1 ); + __m128 a1 = _mm_add_ps( s2, s3 ); + __m128 a2 = _mm_add_ps( a0, a1 ); + + __m128 v = _mm_mul_ps( a2, _mm_set_ps1( 0.25f ) ); + __m128 r0 = _mm_add_ps( v, _mm_set_ps1( 0.00279491f ) ); + __m128 r1 = _mm_rsqrt_ps( r0 ); + __m128 r2 = _mm_mul_ps( r1, _mm_set_ps1( 1.15907984f ) ); + __m128 r3 = _mm_sub_ps( r2, _mm_set_ps1( 0.15746343f ) ); + __m128 r4 = _mm_mul_ps( r3, v ); + + __m128 b0 = _mm_blend_ps( r4, v, 8 ); + __m128 b1 = _mm_mul_ps( b0, _mm_set_ps1( 255 ) ); + __m128i b2 = _mm_cvtps_epi32( b1 ); + __m128i b3 = _mm_packus_epi32( b2, b2 ); + __m128i b4 = _mm_packus_epi16( b3, b3 ); + + *ptr++ = _mm_cvtsi128_si32( b4 ); + src1 += 2; + src2 += 2; +#else + uint32_t px0 = *src1; + uint32_t px1 = *(src1+1); + uint32_t px2 = *src2; + uint32_t px3 = *(src2+1); + + float r0 = SrgbToLinear[px0 & 0x000000FF]; + float r1 = SrgbToLinear[px1 & 0x000000FF]; + float r2 = SrgbToLinear[px2 & 0x000000FF]; + float r3 = SrgbToLinear[px3 & 0x000000FF]; + + float g0 = SrgbToLinear[( px0 & 0x0000FF00 ) >> 8]; + float g1 = SrgbToLinear[( px1 & 0x0000FF00 ) >> 8]; + float g2 = SrgbToLinear[( px2 & 0x0000FF00 ) >> 8]; + float g3 = SrgbToLinear[( px3 & 0x0000FF00 ) >> 8]; + + float b0 = SrgbToLinear[( px0 & 0x00FF0000 ) >> 16]; + float b1 = SrgbToLinear[( px1 & 0x00FF0000 ) >> 16]; + float b2 = SrgbToLinear[( px2 & 0x00FF0000 ) >> 16]; + float b3 = SrgbToLinear[( px3 & 0x00FF0000 ) >> 16]; + + uint32_t r = LinearToSrgb( ( r0+r1+r2+r3 ) / 4 ); + uint32_t g = LinearToSrgb( ( g0+g1+g2+g3 ) / 4 ) << 8; + uint32_t b = LinearToSrgb( ( b0+b1+b2+b3 ) / 4 ) << 16; + uint32_t a = ( ( ( ( ( *src1 & 0xFF000000 ) >> 8 ) + ( ( *(src1+1) & 0xFF000000 ) >> 8 ) + ( ( *src2 & 0xFF000000 ) >> 8 ) + ( ( *(src2+1) & 0xFF000000 ) >> 8 ) ) / 4 ) & 0x00FF0000 ) << 8; + + *ptr++ = r | g | b | a; + src1 += 2; + src2 += 2; +#endif + } + src1 += m_size.x * 2; + src2 += m_size.x * 2; + } + lines++; + if( lines >= m_lines ) + { + lines = 0; + m_sema.unlock(); + } + } + + if( lines != 0 ) + { + m_sema.unlock(); + } + } ); + } + else + { + m_load = std::async( std::launch::async, [this, &bmp, w, h]() mutable + { + auto ptr = m_data; + auto src1 = bmp.Data(); + auto src2 = src1 + bmp.Size().x; + unsigned int lines = 0; + for( int i=0; i 2 ) + { + k -= 2; + + __m128i p0 = _mm_loadu_si128( (__m128i*)src1 ); + __m128i p1 = _mm_loadu_si128( (__m128i*)src2 ); + src1 += 4; + src2 += 4; + + __m256i px0 = _mm256_cvtepu8_epi16( p0 ); + __m256i px1 = _mm256_cvtepu8_epi16( p1 ); + + __m256i s0 = _mm256_add_epi16( px0, px1 ); + __m256i s1 = _mm256_shuffle_epi32( s0, _MM_SHUFFLE( 1, 0, 3, 2 ) ); + __m256i s2 = _mm256_add_epi16( s0, s1 ); + + __m256i r0 = _mm256_srli_epi16( s2, 2 ); + __m256i r1 = _mm256_packus_epi16( r0, r0 ); + + *ptr++ = _mm_cvtsi128_si32( _mm256_castsi256_si128( r1 ) ); + *ptr++ = _mm_cvtsi128_si32( _mm256_extracti128_si256( r1, 1 ) ); + } +#endif + while( k-- ) + { +#ifdef __SSE4_1__ + uint64_t p0, p1; + memcpy( &p0, src1, 8 ); + memcpy( &p1, src2, 8 ); + src1 += 2; + src2 += 2; + + __m128i px = _mm_set_epi64x( p0, p1 ); + __m128i px0 = _mm_unpacklo_epi8( px, _mm_setzero_si128() ); + __m128i px1 = _mm_unpackhi_epi8( px, _mm_setzero_si128() ); + + __m128i s0 = _mm_add_epi16( px0, px1 ); + __m128i s1 = _mm_shuffle_epi32( s0, _MM_SHUFFLE( 1, 0, 3, 2 ) ); + __m128i s2 = _mm_add_epi16( s0, s1 ); + + __m128i r0 = _mm_srli_epi16( s2, 2 ); + __m128i r1 = _mm_packus_epi16( r0, r0 ); + + *ptr++ = _mm_cvtsi128_si32( r1 ); +#else + int r = ( ( *src1 & 0x000000FF ) + ( *(src1+1) & 0x000000FF ) + ( *src2 & 0x000000FF ) + ( *(src2+1) & 0x000000FF ) ) / 4; + int g = ( ( ( *src1 & 0x0000FF00 ) + ( *(src1+1) & 0x0000FF00 ) + ( *src2 & 0x0000FF00 ) + ( *(src2+1) & 0x0000FF00 ) ) / 4 ) & 0x0000FF00; + int b = ( ( ( *src1 & 0x00FF0000 ) + ( *(src1+1) & 0x00FF0000 ) + ( *src2 & 0x00FF0000 ) + ( *(src2+1) & 0x00FF0000 ) ) / 4 ) & 0x00FF0000; + int a = ( ( ( ( ( *src1 & 0xFF000000 ) >> 8 ) + ( ( *(src1+1) & 0xFF000000 ) >> 8 ) + ( ( *src2 & 0xFF000000 ) >> 8 ) + ( ( *(src2+1) & 0xFF000000 ) >> 8 ) ) / 4 ) & 0x00FF0000 ) << 8; + *ptr++ = r | g | b | a; + src1 += 2; + src2 += 2; +#endif + } + src1 += m_size.x * 2; + src2 += m_size.x * 2; + } + lines++; + if( lines >= m_lines ) + { + lines = 0; + m_sema.unlock(); + } + } + + if( lines != 0 ) + { + m_sema.unlock(); + } + } ); + } + } +} + +BitmapDownsampled::~BitmapDownsampled() +{ +} diff --git a/lib/etcpak/etcpak/BitmapDownsampled.hpp b/lib/etcpak/etcpak/BitmapDownsampled.hpp new file mode 100644 index 00000000000..a78037fbb65 --- /dev/null +++ b/lib/etcpak/etcpak/BitmapDownsampled.hpp @@ -0,0 +1,13 @@ +#ifndef __DARKRL__BITMAPDOWNSAMPLED_HPP__ +#define __DARKRL__BITMAPDOWNSAMPLED_HPP__ + +#include "Bitmap.hpp" + +class BitmapDownsampled : public Bitmap +{ +public: + BitmapDownsampled( const Bitmap& bmp, unsigned int lines, bool linearize ); + ~BitmapDownsampled(); +}; + +#endif diff --git a/lib/etcpak/etcpak/BlockData.cpp b/lib/etcpak/etcpak/BlockData.cpp new file mode 100644 index 00000000000..4f9ec88eafc --- /dev/null +++ b/lib/etcpak/etcpak/BlockData.cpp @@ -0,0 +1,400 @@ +#include +#include + +#include "bcdec.h" +#include "BlockData.hpp" +#include "ColorSpace.hpp" +#include "Debug.hpp" +#include "MipMap.hpp" +#include "mmap.hpp" +#include "ProcessRGB.hpp" +#include "ProcessDxtc.hpp" +#include "Tables.hpp" +#include "TaskDispatch.hpp" +#include "Decode.hpp" + +#ifdef __ARM_NEON +# include +#endif + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER +# ifdef _MSC_VER +# include +# include +# define _bswap(x) _byteswap_ulong(x) +# define _bswap64(x) _byteswap_uint64(x) +# else +# include +# endif +#endif + +#ifndef _bswap +# define _bswap(x) __builtin_bswap32(x) +# define _bswap64(x) __builtin_bswap64(x) +#endif + +static uint8_t table59T58H[8] = { 3,6,11,16,23,32,41,64 }; + +BlockData::BlockData( const char* fn ) + : m_file( fopen( fn, "rb" ) ) +{ + assert( m_file ); + fseek( m_file, 0, SEEK_END ); + m_maplen = ftell( m_file ); + fseek( m_file, 0, SEEK_SET ); + m_data = (uint8_t*)mmap( nullptr, m_maplen, PROT_READ, MAP_SHARED, fileno( m_file ), 0 ); + ProcessHeader(m_data, m_type, m_size.x, m_size.y, m_dataOffset); +} + +static void WritePvrHeader( uint32_t* dst, CodecType type, const v2i& size, int levels ) +{ + *dst++ = 0x03525650; // version + *dst++ = 0; // flags + switch( type ) // pixelformat[0] + { + case CodecType::Etc1: + *dst++ = 6; + break; + case CodecType::Etc2_RGB: + *dst++ = 22; + break; + case CodecType::Etc2_RGBA: + *dst++ = 23; + break; + case CodecType::Etc2_R11: + *dst++ = 25; + break; + case CodecType::Etc2_RG11: + *dst++ = 26; + break; + case CodecType::Bc1: + *dst++ = 7; + break; + case CodecType::Bc3: + *dst++ = 11; + break; + case CodecType::Bc4: + *dst++ = 12; + break; + case CodecType::Bc5: + *dst++ = 13; + break; + case CodecType::Bc7: + *dst++ = 15; + break; + default: + assert( false ); + break; + } + *dst++ = 0; // pixelformat[1] + *dst++ = 0; // colourspace + *dst++ = 0; // channel type + *dst++ = size.y; // height + *dst++ = size.x; // width + *dst++ = 1; // depth + *dst++ = 1; // num surfs + *dst++ = 1; // num faces + *dst++ = levels; // mipmap count + *dst++ = 0; // metadata size +} + +static void WriteDdsHeader( uint32_t* dst, CodecType type, const v2i& size, int levels ) +{ + const uint32_t flags = levels == 1 ? 0x1007 : 0x21007; + uint32_t pitch = size.x * size.y / 2; + if( type == CodecType::Etc2_RGBA || type == CodecType::Bc3 || type == CodecType::Bc5 || type == CodecType::Bc7 || type == CodecType::Etc2_RG11 ) pitch *= 2; + const uint32_t caps = levels == 1 ? 0x1000 : 0x401008; + + *dst++ = 0x20534444; // magic + *dst++ = 124; // size + *dst++ = flags; // flags + *dst++ = size.y; // height + *dst++ = size.x; // width + *dst++ = pitch; // pitch + *dst++ = 0; // depth + *dst++ = levels; // mipmap count + memset( dst, 0, 44 ); + dst += 11; + *dst++ = 32; // size + *dst++ = 4; // flags + switch( type ) + { + case CodecType::Bc1: + memcpy( dst++, "DXT1", 4 ); + break; + case CodecType::Bc3: + memcpy( dst++, "DXT5", 4 ); + break; + case CodecType::Bc4: + memcpy( dst++, "DX10", 4 ); + break; + case CodecType::Bc5: + memcpy( dst++, "DX10", 4 ); + break; + case CodecType::Bc7: + memcpy( dst++, "DX10", 4 ); + break; + default: + assert( false ); + break; + } + memset( dst, 0, 20 ); + dst += 5; + *dst++ = caps; + memset( dst, 0, 16 ); + dst+= 4; + + if( type == CodecType::Bc1 || type == CodecType::Bc3 ) return; + + switch( type ) + { + case CodecType::Bc4: + *dst++ = 80; // DXGI_FORMAT_BC4_UNORM + break; + case CodecType::Bc5: + *dst++ = 83; // DXGI_FORMAT_BC5_UNORM + break; + case CodecType::Bc7: + *dst++ = 98; // DXGI_FORMAT_BC7_UNORM + break; + default: + assert( false ); + break; + } + *dst++ = 3; // DXGI_FORMAT_DIMENSION_TEXTURE2D + *dst++ = 0; // miscFlag + *dst++ = 1; // arraySize + *dst++ = 0; // miscFlags2 +} + +static uint8_t* OpenForWriting( const char* fn, size_t len, const v2i& size, FILE** f, int levels, CodecType type, BlockData::Format format ) +{ + *f = fopen( fn, "wb+" ); + assert( *f ); + fseek( *f, len - 1, SEEK_SET ); + const char zero = 0; + fwrite( &zero, 1, 1, *f ); + fseek( *f, 0, SEEK_SET ); + + auto ret = (uint8_t*)mmap( nullptr, len, PROT_WRITE, MAP_SHARED, fileno( *f ), 0 ); + auto dst = (uint32_t*)ret; + + switch( format ) + { + case BlockData::Pvr: + WritePvrHeader( dst, type, size, levels ); + break; + case BlockData::Dds: + WriteDdsHeader( dst, type, size, levels ); + break; + default: + assert( false ); + break; + } + + return ret; +} + +static int AdjustSizeForMipmaps( const v2i& size, int levels ) +{ + int len = 0; + v2i current = size; + for( int i=1; i(m_size); + const uint64_t* src = (const uint64_t*)(m_data + m_dataOffset); + + switch( m_type ) + { + case Etc1: + case Etc2_RGB: + ::DecodeRGB(src, ret->Data(), m_size.x, m_size.y); + break; + case Etc2_RGBA: + ::DecodeRGBA(src, ret->Data(), m_size.x, m_size.y); + break; + case Etc2_R11: + ::DecodeR(src, ret->Data(), m_size.x, m_size.y); + break; + case Etc2_RG11: + ::DecodeRG(src, ret->Data(), m_size.x, m_size.y); + break; + case Bc1: + ::DecodeBc1(src, ret->Data(), m_size.x, m_size.y); + break; + case Bc3: + ::DecodeBc3(src, ret->Data(), m_size.x, m_size.y); + break; + case Bc4: + ::DecodeBc4(src, ret->Data(), m_size.x, m_size.y); + break; + case Bc5: + ::DecodeBc5(src, ret->Data(), m_size.x, m_size.y); + break; + case Bc7: + ::DecodeBc7(src, ret->Data(), m_size.x, m_size.y); + break; + default: + assert( false ); + return nullptr; + } + return ret; +} diff --git a/lib/etcpak/etcpak/BlockData.hpp b/lib/etcpak/etcpak/BlockData.hpp new file mode 100644 index 00000000000..90071331d31 --- /dev/null +++ b/lib/etcpak/etcpak/BlockData.hpp @@ -0,0 +1,52 @@ +#ifndef __BLOCKDATA_HPP__ +#define __BLOCKDATA_HPP__ + +#include +#include +#include +#include +#include +#include +#include + +#include "Bitmap.hpp" +#include "ForceInline.hpp" +#include "Vector.hpp" +#include "TextureHeader.hpp" + +struct bc7enc_compress_block_params; + +class BlockData +{ +public: + + enum Format + { + Pvr, + Dds + }; + + BlockData( const char* fn ); + BlockData( const char* fn, const v2i& size, bool mipmap, CodecType type, Format format ); + BlockData( const v2i& size, bool mipmap, CodecType type ); + ~BlockData(); + + BitmapPtr Decode(); + + void Process( const uint32_t* src, uint32_t blocks, size_t offset, size_t width, bool dither, bool useHeuristics ); + void ProcessRGBA( const uint32_t* src, uint32_t blocks, size_t offset, size_t width, bool useHeuristics, const bc7enc_compress_block_params* params ); + + const v2i& Size() const { return m_size; } + +private: + uint8_t* m_data; + v2i m_size; + size_t m_dataOffset; + FILE* m_file; + size_t m_maplen; + CodecType m_type; +}; + +typedef std::shared_ptr BlockDataPtr; + +#endif diff --git a/lib/etcpak/etcpak/ColorSpace.cpp b/lib/etcpak/etcpak/ColorSpace.cpp new file mode 100644 index 00000000000..04115410662 --- /dev/null +++ b/lib/etcpak/etcpak/ColorSpace.cpp @@ -0,0 +1,114 @@ +#include +#include + +#include "Math.hpp" +#include "ColorSpace.hpp" + +namespace Color +{ + + static const XYZ white( v3b( 255, 255, 255 ) ); + static const v3f rwhite( 1.f / white.x, 1.f / white.y, 1.f / white.z ); + + + XYZ::XYZ( float _x, float _y, float _z ) + : x( _x ) + , y( _y ) + , z( _z ) + { + } + + XYZ::XYZ( const v3b& rgb ) + { + const float r = rgb.x / 255.f; + const float g = rgb.y / 255.f; + const float b = rgb.z / 255.f; + + const float rl = sRGB2linear( r ); + const float gl = sRGB2linear( g ); + const float bl = sRGB2linear( b ); + + x = 0.4124f * rl + 0.3576f * gl + 0.1805f * bl; + y = 0.2126f * rl + 0.7152f * gl + 0.0722f * bl; + z = 0.0193f * rl + 0.1192f * gl + 0.9505f * bl; + } + + static float revlab( float t ) + { + const float p1 = 6.f/29.f; + const float p2 = 4.f/29.f; + + if( t > p1 ) + { + return t*t*t; + } + else + { + return 3 * sq( p1 ) * ( t - p2 ); + } + } + + XYZ::XYZ( const Lab& lab ) + { + y = white.y * revlab( 1.f/116.f * ( lab.L + 16 ) ); + x = white.x * revlab( 1.f/116.f * ( lab.L + 16 ) + 1.f/500.f * lab.a ); + z = white.z * revlab( 1.f/116.f * ( lab.L + 16 ) - 1.f/200.f * lab.b ); + } + + v3i XYZ::RGB() const + { + const float rl = 3.2406f * x - 1.5372f * y - 0.4986f * z; + const float gl = -0.9689f * x + 1.8758f * y + 0.0415f * z; + const float bl = 0.0557f * x - 0.2040f * y + 1.0570f * z; + + const float r = linear2sRGB( rl ); + const float g = linear2sRGB( gl ); + const float b = linear2sRGB( bl ); + + return v3i( clampu8( int32_t( r * 255 ) ), clampu8( int32_t( g * 255 ) ), clampu8( int32_t( b * 255 ) ) ); + } + + + Lab::Lab() + : L( 0 ) + , a( 0 ) + , b( 0 ) + { + } + + Lab::Lab( float L, float a, float b ) + : L( L ) + , a( a ) + , b( b ) + { + } + + static float labfunc( float t ) + { + const float p1 = (6.f/29.f)*(6.f/29.f)*(6.f/29.f); + const float p2 = (1.f/3.f)*(29.f/6.f)*(29.f/6.f); + const float p3 = (4.f/29.f); + + if( t > p1 ) + { + return pow( t, 1.f/3.f ); + } + else + { + return p2 * t + p3; + } + } + + Lab::Lab( const XYZ& xyz ) + { + L = 116 * labfunc( xyz.y * rwhite.y ) - 16; + a = 500 * ( labfunc( xyz.x * rwhite.x ) - labfunc( xyz.y * rwhite.y ) ); + b = 200 * ( labfunc( xyz.y * rwhite.y ) - labfunc( xyz.z * rwhite.z ) ); + } + + Lab::Lab( const v3b& rgb ) + { + new(this) Lab( XYZ( rgb ) ); + } + +} diff --git a/lib/etcpak/etcpak/ColorSpace.hpp b/lib/etcpak/etcpak/ColorSpace.hpp new file mode 100644 index 00000000000..c9d0a9cf3f0 --- /dev/null +++ b/lib/etcpak/etcpak/ColorSpace.hpp @@ -0,0 +1,36 @@ +#ifndef __DARKRL__COLORSPACE_HPP__ +#define __DARKRL__COLORSPACE_HPP__ + +#include "Vector.hpp" + +namespace Color +{ + + class Lab; + + class XYZ + { + public: + XYZ( float x, float y, float z ); + XYZ( const v3b& rgb ); + XYZ( const Lab& lab ); + + v3i RGB() const; + + float x, y, z; + }; + + class Lab + { + public: + Lab(); + Lab( float L, float a, float b ); + Lab( const XYZ& xyz ); + Lab( const v3b& rgb ); + + float L, a, b; + }; + +} + +#endif diff --git a/lib/etcpak/etcpak/DataProvider.cpp b/lib/etcpak/etcpak/DataProvider.cpp new file mode 100644 index 00000000000..3de3668ccf2 --- /dev/null +++ b/lib/etcpak/etcpak/DataProvider.cpp @@ -0,0 +1,78 @@ +#include +#include + +#include "BitmapDownsampled.hpp" +#include "DataProvider.hpp" +#include "MipMap.hpp" + +DataProvider::DataProvider( const char* fn, bool mipmap, bool bgr, bool linearize ) + : m_offset( 0 ) + , m_lines( 32 ) + , m_mipmap( mipmap ) + , m_done( false ) + , m_linearize( linearize ) +{ + m_bmp.emplace_back( new Bitmap( fn, m_lines, bgr ) ); + m_current = m_bmp[0].get(); +} + +DataProvider::~DataProvider() +{ +} + +unsigned int DataProvider::NumberOfParts() const +{ + unsigned int parts = ( ( m_bmp[0]->Size().y / 4 ) + m_lines - 1 ) / m_lines; + + if( m_mipmap ) + { + v2i current = m_bmp[0]->Size(); + int levels = NumberOfMipLevels( current ); + unsigned int lines = m_lines; + for( int i=1; iNextBlock( lines, done ); + DataPart ret = { + ptr, + std::max( 4, m_current->Size().x ), + lines, + m_offset + }; + + m_offset += m_current->Size().x / 4 * lines; + + if( done ) + { + if( m_mipmap && ( m_current->Size().x != 1 || m_current->Size().y != 1 ) ) + { + m_lines *= 2; + m_bmp.emplace_back( new BitmapDownsampled( *m_current, m_lines, m_linearize ) ); + m_current = m_bmp[m_bmp.size()-1].get(); + } + else + { + m_done = true; + } + } + + return ret; +} diff --git a/lib/etcpak/etcpak/DataProvider.hpp b/lib/etcpak/etcpak/DataProvider.hpp new file mode 100644 index 00000000000..bdd3af2ee46 --- /dev/null +++ b/lib/etcpak/etcpak/DataProvider.hpp @@ -0,0 +1,42 @@ +#ifndef __DATAPROVIDER_HPP__ +#define __DATAPROVIDER_HPP__ + +#include +#include +#include + +#include "Bitmap.hpp" + +struct DataPart +{ + const uint32_t* src; + unsigned int width; + unsigned int lines; + unsigned int offset; +}; + +class DataProvider +{ +public: + DataProvider( const char* fn, bool mipmap, bool bgr, bool linearize ); + ~DataProvider(); + + unsigned int NumberOfParts() const; + + DataPart NextPart(); + + bool Alpha() const { return m_bmp[0]->Alpha(); } + const v2i& Size() const { return m_bmp[0]->Size(); } + const Bitmap& ImageData() const { return *m_bmp[0]; } + +private: + std::vector> m_bmp; + Bitmap* m_current; + unsigned int m_offset; + unsigned int m_lines; + bool m_mipmap; + bool m_done; + bool m_linearize; +}; + +#endif diff --git a/lib/etcpak/etcpak/Debug.cpp b/lib/etcpak/etcpak/Debug.cpp new file mode 100644 index 00000000000..72dc4e05268 --- /dev/null +++ b/lib/etcpak/etcpak/Debug.cpp @@ -0,0 +1,31 @@ +#include +#include +#include "Debug.hpp" + +static std::vector s_callbacks; + +void DebugLog::Message( const char* msg ) +{ + for( auto it = s_callbacks.begin(); it != s_callbacks.end(); ++it ) + { + (*it)->OnDebugMessage( msg ); + } +} + +void DebugLog::AddCallback( Callback* c ) +{ + const auto it = std::find( s_callbacks.begin(), s_callbacks.end(), c ); + if( it == s_callbacks.end() ) + { + s_callbacks.push_back( c ); + } +} + +void DebugLog::RemoveCallback( Callback* c ) +{ + const auto it = std::find( s_callbacks.begin(), s_callbacks.end(), c ); + if( it != s_callbacks.end() ) + { + s_callbacks.erase( it ); + } +} diff --git a/lib/etcpak/etcpak/Debug.hpp b/lib/etcpak/etcpak/Debug.hpp new file mode 100644 index 00000000000..524eaa7bafe --- /dev/null +++ b/lib/etcpak/etcpak/Debug.hpp @@ -0,0 +1,27 @@ +#ifndef __DARKRL__DEBUG_HPP__ +#define __DARKRL__DEBUG_HPP__ + +#ifdef DEBUG +# include +# define DBGPRINT(msg) { std::stringstream __buf; __buf << msg; DebugLog::Message( __buf.str().c_str() ); } +#else +# define DBGPRINT(msg) ((void)0) +#endif + +class DebugLog +{ +public: + struct Callback + { + virtual void OnDebugMessage( const char* msg ) = 0; + }; + + static void Message( const char* msg ); + static void AddCallback( Callback* c ); + static void RemoveCallback( Callback* c ); + +private: + DebugLog() {} +}; + +#endif diff --git a/lib/etcpak/etcpak/Decode.cpp b/lib/etcpak/etcpak/Decode.cpp new file mode 100644 index 00000000000..dbc6be545d9 --- /dev/null +++ b/lib/etcpak/etcpak/Decode.cpp @@ -0,0 +1,1286 @@ +#include +#include + +#include "bcdec.h" +#include "Decode.hpp" +#include "ForceInline.hpp" +#include "Tables.hpp" +#include "Math.hpp" + + +#ifdef __ARM_NEON +# include +#endif + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER +# ifdef _MSC_VER +# include +# include +# define _bswap(x) _byteswap_ulong(x) +# define _bswap64(x) _byteswap_uint64(x) +# else +# include +# endif +#endif + +#ifndef _bswap +# define _bswap(x) __builtin_bswap32(x) +# define _bswap64(x) __builtin_bswap64(x) +#endif + +static uint8_t table59T58H[8] = { 3,6,11,16,23,32,41,64 }; + +namespace +{ + +static etcpak_force_inline int32_t expand6(uint32_t value) +{ + return (value << 2) | (value >> 4); +} + +static etcpak_force_inline int32_t expand7(uint32_t value) +{ + return (value << 1) | (value >> 6); +} + +static etcpak_force_inline void DecodeT( uint64_t block, uint32_t* dst, uint32_t w ) +{ + const auto r0 = ( block >> 24 ) & 0x1B; + const auto rh0 = ( r0 >> 3 ) & 0x3; + const auto rl0 = r0 & 0x3; + const auto g0 = ( block >> 20 ) & 0xF; + const auto b0 = ( block >> 16 ) & 0xF; + + const auto r1 = ( block >> 12 ) & 0xF; + const auto g1 = ( block >> 8 ) & 0xF; + const auto b1 = ( block >> 4 ) & 0xF; + + const auto cr0 = ( ( rh0 << 6 ) | ( rl0 << 4 ) | ( rh0 << 2 ) | rl0); + const auto cg0 = ( g0 << 4 ) | g0; + const auto cb0 = ( b0 << 4 ) | b0; + + const auto cr1 = ( r1 << 4 ) | r1; + const auto cg1 = ( g1 << 4 ) | g1; + const auto cb1 = ( b1 << 4 ) | b1; + + const auto codeword_hi = ( block >> 2 ) & 0x3; + const auto codeword_lo = block & 0x1; + const auto codeword = ( codeword_hi << 1 ) | codeword_lo; + + const auto c2r = clampu8( cr1 + table59T58H[codeword] ); + const auto c2g = clampu8( cg1 + table59T58H[codeword] ); + const auto c2b = clampu8( cb1 + table59T58H[codeword] ); + + const auto c3r = clampu8( cr1 - table59T58H[codeword] ); + const auto c3g = clampu8( cg1 - table59T58H[codeword] ); + const auto c3b = clampu8( cb1 - table59T58H[codeword] ); + + const uint32_t col_tab[4] = { + uint32_t( cr0 | ( cg0 << 8 ) | ( cb0 << 16 ) | 0xFF000000 ), + uint32_t( c2r | ( c2g << 8 ) | ( c2b << 16 ) | 0xFF000000 ), + uint32_t( cr1 | ( cg1 << 8 ) | ( cb1 << 16 ) | 0xFF000000 ), + uint32_t( c3r | ( c3g << 8 ) | ( c3b << 16 ) | 0xFF000000 ) + }; + + const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF; + for( uint8_t j = 0; j < 4; j++ ) + { + for( uint8_t i = 0; i < 4; i++ ) + { + //2bit indices distributed on two lane 16bit numbers + const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1) | ( ( indexes >> ( j + i * 4 ) ) & 0x1); + dst[j * w + i] = col_tab[index]; + } + } +} + +static etcpak_force_inline void DecodeTAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w ) +{ + const auto r0 = ( block >> 24 ) & 0x1B; + const auto rh0 = ( r0 >> 3 ) & 0x3; + const auto rl0 = r0 & 0x3; + const auto g0 = ( block >> 20 ) & 0xF; + const auto b0 = ( block >> 16 ) & 0xF; + + const auto r1 = ( block >> 12 ) & 0xF; + const auto g1 = ( block >> 8 ) & 0xF; + const auto b1 = ( block >> 4 ) & 0xF; + + const auto cr0 = ( ( rh0 << 6 ) | ( rl0 << 4 ) | ( rh0 << 2 ) | rl0); + const auto cg0 = ( g0 << 4 ) | g0; + const auto cb0 = ( b0 << 4 ) | b0; + + const auto cr1 = ( r1 << 4 ) | r1; + const auto cg1 = ( g1 << 4 ) | g1; + const auto cb1 = ( b1 << 4 ) | b1; + + const auto codeword_hi = ( block >> 2 ) & 0x3; + const auto codeword_lo = block & 0x1; + const auto codeword = (codeword_hi << 1) | codeword_lo; + + const int32_t base = alpha >> 56; + const int32_t mul = ( alpha >> 52 ) & 0xF; + const auto tbl = g_alpha[( alpha >> 48 ) & 0xF]; + + const auto c2r = clampu8( cr1 + table59T58H[codeword] ); + const auto c2g = clampu8( cg1 + table59T58H[codeword] ); + const auto c2b = clampu8( cb1 + table59T58H[codeword] ); + + const auto c3r = clampu8( cr1 - table59T58H[codeword] ); + const auto c3g = clampu8( cg1 - table59T58H[codeword] ); + const auto c3b = clampu8( cb1 - table59T58H[codeword] ); + + const uint32_t col_tab[4] = { + uint32_t( cr0 | ( cg0 << 8 ) | ( cb0 << 16 ) ), + uint32_t( c2r | ( c2g << 8 ) | ( c2b << 16 ) ), + uint32_t( cr1 | ( cg1 << 8 ) | ( cb1 << 16 ) ), + uint32_t( c3r | ( c3g << 8 ) | ( c3b << 16 ) ) + }; + + const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF; + for( uint8_t j = 0; j < 4; j++ ) + { + for( uint8_t i = 0; i < 4; i++ ) + { + //2bit indices distributed on two lane 16bit numbers + const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 ); + const auto amod = tbl[( alpha >> ( 45 - j * 3 - i * 12 ) ) & 0x7]; + const uint32_t a = clampu8( base + amod * mul ); + dst[j * w + i] = col_tab[index] | ( a << 24 ); + } + } +} + +static etcpak_force_inline void DecodeH( uint64_t block, uint32_t* dst, uint32_t w ) +{ + const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF; + + const auto r0444 = ( block >> 27 ) & 0xF; + const auto g0444 = ( ( block >> 20 ) & 0x1 ) | ( ( ( block >> 24 ) & 0x7 ) << 1 ); + const auto b0444 = ( ( block >> 15 ) & 0x7 ) | ( ( ( block >> 19 ) & 0x1 ) << 3 ); + + const auto r1444 = ( block >> 11 ) & 0xF; + const auto g1444 = ( block >> 7 ) & 0xF; + const auto b1444 = ( block >> 3 ) & 0xF; + + const auto r0 = ( r0444 << 4 ) | r0444; + const auto g0 = ( g0444 << 4 ) | g0444; + const auto b0 = ( b0444 << 4 ) | b0444; + + const auto r1 = ( r1444 << 4 ) | r1444; + const auto g1 = ( g1444 << 4 ) | g1444; + const auto b1 = ( b1444 << 4 ) | b1444; + + const auto codeword_hi = ( ( block & 0x1 ) << 1 ) | ( ( block & 0x4 ) ); + const auto c0 = ( r0444 << 8 ) | ( g0444 << 4 ) | ( b0444 << 0 ); + const auto c1 = ( block >> 3 ) & ( ( 1 << 12 ) - 1 ); + const auto codeword_lo = ( c0 >= c1 ) ? 1 : 0; + const auto codeword = codeword_hi | codeword_lo; + + const uint32_t col_tab[] = { + uint32_t( clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 ) ), + uint32_t( clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 ) ), + uint32_t( clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 ) ), + uint32_t( clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 ) ) + }; + + for( uint8_t j = 0; j < 4; j++ ) + { + for( uint8_t i = 0; i < 4; i++ ) + { + const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 ); + dst[j * w + i] = col_tab[index] | 0xFF000000; + } + } +} + +static etcpak_force_inline void DecodeHAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w ) +{ + const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF; + + const auto r0444 = ( block >> 27 ) & 0xF; + const auto g0444 = ( ( block >> 20 ) & 0x1 ) | ( ( ( block >> 24 ) & 0x7 ) << 1 ); + const auto b0444 = ( ( block >> 15 ) & 0x7 ) | ( ( ( block >> 19 ) & 0x1 ) << 3 ); + + const auto r1444 = ( block >> 11 ) & 0xF; + const auto g1444 = ( block >> 7 ) & 0xF; + const auto b1444 = ( block >> 3 ) & 0xF; + + const auto r0 = ( r0444 << 4 ) | r0444; + const auto g0 = ( g0444 << 4 ) | g0444; + const auto b0 = ( b0444 << 4 ) | b0444; + + const auto r1 = ( r1444 << 4 ) | r1444; + const auto g1 = ( g1444 << 4 ) | g1444; + const auto b1 = ( b1444 << 4 ) | b1444; + + const auto codeword_hi = ( ( block & 0x1 ) << 1 ) | ( ( block & 0x4 ) ); + const auto c0 = ( r0444 << 8 ) | ( g0444 << 4 ) | ( b0444 << 0 ); + const auto c1 = ( block >> 3 ) & ( ( 1 << 12 ) - 1 ); + const auto codeword_lo = ( c0 >= c1 ) ? 1 : 0; + const auto codeword = codeword_hi | codeword_lo; + + const int32_t base = alpha >> 56; + const int32_t mul = ( alpha >> 52 ) & 0xF; + const auto tbl = g_alpha[(alpha >> 48) & 0xF]; + + const uint32_t col_tab[] = { + uint32_t( clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 ) ), + uint32_t( clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 ) ), + uint32_t( clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 ) ), + uint32_t( clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 ) ) + }; + + for( uint8_t j = 0; j < 4; j++ ) + { + for( uint8_t i = 0; i < 4; i++ ) + { + const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 ); + const auto amod = tbl[( alpha >> ( 45 - j * 3 - i * 12) ) & 0x7]; + const uint32_t a = clampu8( base + amod * mul ); + dst[j * w + i] = col_tab[index] | ( a << 24 ); + } + } +} + +static etcpak_force_inline void DecodePlanar( uint64_t block, uint32_t* dst, uint32_t w ) +{ + const auto bv = expand6((block >> ( 0 + 32)) & 0x3F); + const auto gv = expand7((block >> ( 6 + 32)) & 0x7F); + const auto rv = expand6((block >> (13 + 32)) & 0x3F); + + const auto bh = expand6((block >> (19 + 32)) & 0x3F); + const auto gh = expand7((block >> (25 + 32)) & 0x7F); + + const auto rh0 = (block >> (32 - 32)) & 0x01; + const auto rh1 = ((block >> (34 - 32)) & 0x1F) << 1; + const auto rh = expand6(rh0 | rh1); + + const auto bo0 = (block >> (39 - 32)) & 0x07; + const auto bo1 = ((block >> (43 - 32)) & 0x3) << 3; + const auto bo2 = ((block >> (48 - 32)) & 0x1) << 5; + const auto bo = expand6(bo0 | bo1 | bo2); + const auto go0 = (block >> (49 - 32)) & 0x3F; + const auto go1 = ((block >> (56 - 32)) & 0x01) << 6; + const auto go = expand7(go0 | go1); + const auto ro = expand6((block >> (57 - 32)) & 0x3F); + +#ifdef __ARM_NEON + uint64_t init = uint64_t(uint16_t(rh-ro)) | ( uint64_t(uint16_t(gh-go)) << 16 ) | ( uint64_t(uint16_t(bh-bo)) << 32 ); + int16x8_t chco = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); + init = uint64_t(uint16_t( (rv-ro) - 4 * (rh-ro) )) | ( uint64_t(uint16_t( (gv-go) - 4 * (gh-go) )) << 16 ) | ( uint64_t(uint16_t( (bv-bo) - 4 * (bh-bo) )) << 32 ); + int16x8_t cvco = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); + init = uint64_t(4*ro+2) | ( uint64_t(4*go+2) << 16 ) | ( uint64_t(4*bo+2) << 32 ) | ( uint64_t(0xFFF) << 48 ); + int16x8_t col = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); + + for( int j=0; j<4; j++ ) + { + for( int i=0; i<4; i++ ) + { + uint8x8_t c = vqshrun_n_s16( col, 2 ); + vst1_lane_u32( dst+j*w+i, vreinterpret_u32_u8( c ), 0 ); + col = vaddq_s16( col, chco ); + } + col = vaddq_s16( col, cvco ); + } +#elif defined __AVX2__ + const auto R0 = 4*ro+2; + const auto G0 = 4*go+2; + const auto B0 = 4*bo+2; + const auto RHO = rh-ro; + const auto GHO = gh-go; + const auto BHO = bh-bo; + + __m256i cvco = _mm256_setr_epi16( rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0 ); + __m256i col = _mm256_setr_epi16( R0, G0, B0, 0xFFF, R0+RHO, G0+GHO, B0+BHO, 0xFFF, R0+2*RHO, G0+2*GHO, B0+2*BHO, 0xFFF, R0+3*RHO, G0+3*GHO, B0+3*BHO, 0xFFF ); + + for( int j=0; j<4; j++ ) + { + __m256i c = _mm256_srai_epi16( col, 2 ); + __m128i s = _mm_packus_epi16( _mm256_castsi256_si128( c ), _mm256_extracti128_si256( c, 1 ) ); + _mm_storeu_si128( (__m128i*)(dst+j*w), s ); + col = _mm256_add_epi16( col, cvco ); + } +#elif defined __SSE4_1__ + __m128i chco = _mm_setr_epi16( rh - ro, gh - go, bh - bo, 0, 0, 0, 0, 0 ); + __m128i cvco = _mm_setr_epi16( (rv - ro) - 4 * (rh - ro), (gv - go) - 4 * (gh - go), (bv - bo) - 4 * (bh - bo), 0, 0, 0, 0, 0 ); + __m128i col = _mm_setr_epi16( 4*ro+2, 4*go+2, 4*bo+2, 0xFFF, 0, 0, 0, 0 ); + + for( int j=0; j<4; j++ ) + { + for( int i=0; i<4; i++ ) + { + __m128i c = _mm_srai_epi16( col, 2 ); + __m128i s = _mm_packus_epi16( c, c ); + dst[j*w+i] = _mm_cvtsi128_si32( s ); + col = _mm_add_epi16( col, chco ); + } + col = _mm_add_epi16( col, cvco ); + } +#else + for( int j=0; j<4; j++ ) + { + for( int i=0; i<4; i++ ) + { + const uint32_t r = (i * (rh - ro) + j * (rv - ro) + 4 * ro + 2) >> 2; + const uint32_t g = (i * (gh - go) + j * (gv - go) + 4 * go + 2) >> 2; + const uint32_t b = (i * (bh - bo) + j * (bv - bo) + 4 * bo + 2) >> 2; + if( ( ( r | g | b ) & ~0xFF ) == 0 ) + { + dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000; + } + else + { + const auto rc = clampu8( r ); + const auto gc = clampu8( g ); + const auto bc = clampu8( b ); + dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000; + } + } + } +#endif +} + +static etcpak_force_inline void DecodePlanarAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w ) +{ + const auto bv = expand6((block >> ( 0 + 32)) & 0x3F); + const auto gv = expand7((block >> ( 6 + 32)) & 0x7F); + const auto rv = expand6((block >> (13 + 32)) & 0x3F); + + const auto bh = expand6((block >> (19 + 32)) & 0x3F); + const auto gh = expand7((block >> (25 + 32)) & 0x7F); + + const auto rh0 = (block >> (32 - 32)) & 0x01; + const auto rh1 = ((block >> (34 - 32)) & 0x1F) << 1; + const auto rh = expand6(rh0 | rh1); + + const auto bo0 = (block >> (39 - 32)) & 0x07; + const auto bo1 = ((block >> (43 - 32)) & 0x3) << 3; + const auto bo2 = ((block >> (48 - 32)) & 0x1) << 5; + const auto bo = expand6(bo0 | bo1 | bo2); + const auto go0 = (block >> (49 - 32)) & 0x3F; + const auto go1 = ((block >> (56 - 32)) & 0x01) << 6; + const auto go = expand7(go0 | go1); + const auto ro = expand6((block >> (57 - 32)) & 0x3F); + + const int32_t base = alpha >> 56; + const int32_t mul = ( alpha >> 52 ) & 0xF; + const auto tbl = g_alpha[( alpha >> 48 ) & 0xF]; + +#ifdef __ARM_NEON + uint64_t init = uint64_t(uint16_t(rh-ro)) | ( uint64_t(uint16_t(gh-go)) << 16 ) | ( uint64_t(uint16_t(bh-bo)) << 32 ); + int16x8_t chco = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); + init = uint64_t(uint16_t( (rv-ro) - 4 * (rh-ro) )) | ( uint64_t(uint16_t( (gv-go) - 4 * (gh-go) )) << 16 ) | ( uint64_t(uint16_t( (bv-bo) - 4 * (bh-bo) )) << 32 ); + int16x8_t cvco = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); + init = uint64_t(4*ro+2) | ( uint64_t(4*go+2) << 16 ) | ( uint64_t(4*bo+2) << 32 ); + int16x8_t col = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); + + for( int j=0; j<4; j++ ) + { + for( int i=0; i<4; i++ ) + { + const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; + const uint32_t a = clampu8( base + amod * mul ); + uint8x8_t c = vqshrun_n_s16( col, 2 ); + dst[j*w+i] = vget_lane_u32( vreinterpret_u32_u8( c ), 0 ) | ( a << 24 ); + col = vaddq_s16( col, chco ); + } + col = vaddq_s16( col, cvco ); + } +#elif defined __SSE4_1__ + __m128i chco = _mm_setr_epi16( rh - ro, gh - go, bh - bo, 0, 0, 0, 0, 0 ); + __m128i cvco = _mm_setr_epi16( (rv - ro) - 4 * (rh - ro), (gv - go) - 4 * (gh - go), (bv - bo) - 4 * (bh - bo), 0, 0, 0, 0, 0 ); + __m128i col = _mm_setr_epi16( 4*ro+2, 4*go+2, 4*bo+2, 0, 0, 0, 0, 0 ); + + for( int j=0; j<4; j++ ) + { + for( int i=0; i<4; i++ ) + { + const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; + const uint32_t a = clampu8( base + amod * mul ); + __m128i c = _mm_srai_epi16( col, 2 ); + __m128i s = _mm_packus_epi16( c, c ); + dst[j*w+i] = _mm_cvtsi128_si32( s ) | ( a << 24 ); + col = _mm_add_epi16( col, chco ); + } + col = _mm_add_epi16( col, cvco ); + } +#else + for (auto j = 0; j < 4; j++) + { + for (auto i = 0; i < 4; i++) + { + const uint32_t r = (i * (rh - ro) + j * (rv - ro) + 4 * ro + 2) >> 2; + const uint32_t g = (i * (gh - go) + j * (gv - go) + 4 * go + 2) >> 2; + const uint32_t b = (i * (bh - bo) + j * (bv - bo) + 4 * bo + 2) >> 2; + const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; + const uint32_t a = clampu8( base + amod * mul ); + if( ( ( r | g | b ) & ~0xFF ) == 0 ) + { + dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 ); + } + else + { + const auto rc = clampu8( r ); + const auto gc = clampu8( g ); + const auto bc = clampu8( b ); + dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 ); + } + } + } +#endif +} + +static etcpak_force_inline uint64_t ConvertByteOrder( uint64_t d ) +{ + uint32_t word[2]; + memcpy( word, &d, 8 ); + word[0] = _bswap( word[0] ); + word[1] = _bswap( word[1] ); + memcpy( &d, word, 8 ); + return d; +} + +static etcpak_force_inline void DecodeRGBPart( uint64_t d, uint32_t* dst, uint32_t w ) +{ + d = ConvertByteOrder( d ); + + uint32_t br[2], bg[2], bb[2]; + + if( d & 0x2 ) + { + int32_t dr, dg, db; + + uint32_t r0 = ( d & 0xF8000000 ) >> 27; + uint32_t g0 = ( d & 0x00F80000 ) >> 19; + uint32_t b0 = ( d & 0x0000F800 ) >> 11; + + dr = ( int32_t(d) << 5 ) >> 29; + dg = ( int32_t(d) << 13 ) >> 29; + db = ( int32_t(d) << 21 ) >> 29; + + int32_t r1 = int32_t(r0) + dr; + int32_t g1 = int32_t(g0) + dg; + int32_t b1 = int32_t(b0) + db; + + // T mode + if ( (r1 < 0) || (r1 > 31) ) + { + DecodeT( d, dst, w ); + return; + } + + // H mode + if ((g1 < 0) || (g1 > 31)) + { + DecodeH( d, dst, w ); + return; + } + + // P mode + if( (b1 < 0) || (b1 > 31) ) + { + DecodePlanar( d, dst, w ); + return; + } + + br[0] = ( r0 << 3 ) | ( r0 >> 2 ); + br[1] = ( r1 << 3 ) | ( r1 >> 2 ); + bg[0] = ( g0 << 3 ) | ( g0 >> 2 ); + bg[1] = ( g1 << 3 ) | ( g1 >> 2 ); + bb[0] = ( b0 << 3 ) | ( b0 >> 2 ); + bb[1] = ( b1 << 3 ) | ( b1 >> 2 ); + } + else + { + br[0] = ( ( d & 0xF0000000 ) >> 24 ) | ( ( d & 0xF0000000 ) >> 28 ); + br[1] = ( ( d & 0x0F000000 ) >> 20 ) | ( ( d & 0x0F000000 ) >> 24 ); + bg[0] = ( ( d & 0x00F00000 ) >> 16 ) | ( ( d & 0x00F00000 ) >> 20 ); + bg[1] = ( ( d & 0x000F0000 ) >> 12 ) | ( ( d & 0x000F0000 ) >> 16 ); + bb[0] = ( ( d & 0x0000F000 ) >> 8 ) | ( ( d & 0x0000F000 ) >> 12 ); + bb[1] = ( ( d & 0x00000F00 ) >> 4 ) | ( ( d & 0x00000F00 ) >> 8 ); + } + + unsigned int tcw[2]; + tcw[0] = ( d & 0xE0 ) >> 5; + tcw[1] = ( d & 0x1C ) >> 2; + + uint32_t b1 = ( d >> 32 ) & 0xFFFF; + uint32_t b2 = ( d >> 48 ); + + b1 = ( b1 | ( b1 << 8 ) ) & 0x00FF00FF; + b1 = ( b1 | ( b1 << 4 ) ) & 0x0F0F0F0F; + b1 = ( b1 | ( b1 << 2 ) ) & 0x33333333; + b1 = ( b1 | ( b1 << 1 ) ) & 0x55555555; + + b2 = ( b2 | ( b2 << 8 ) ) & 0x00FF00FF; + b2 = ( b2 | ( b2 << 4 ) ) & 0x0F0F0F0F; + b2 = ( b2 | ( b2 << 2 ) ) & 0x33333333; + b2 = ( b2 | ( b2 << 1 ) ) & 0x55555555; + + uint32_t idx = b1 | ( b2 << 1 ); + + if( d & 0x1 ) + { + for( int i=0; i<4; i++ ) + { + for( int j=0; j<4; j++ ) + { + const auto mod = g_table[tcw[j/2]][idx & 0x3]; + const auto r = br[j/2] + mod; + const auto g = bg[j/2] + mod; + const auto b = bb[j/2] + mod; + if( ( ( r | g | b ) & ~0xFF ) == 0 ) + { + dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000; + } + else + { + const auto rc = clampu8( r ); + const auto gc = clampu8( g ); + const auto bc = clampu8( b ); + dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000; + } + idx >>= 2; + } + } + } + else + { + for( int i=0; i<4; i++ ) + { + const auto tbl = g_table[tcw[i/2]]; + const auto cr = br[i/2]; + const auto cg = bg[i/2]; + const auto cb = bb[i/2]; + + for( int j=0; j<4; j++ ) + { + const auto mod = tbl[idx & 0x3]; + const auto r = cr + mod; + const auto g = cg + mod; + const auto b = cb + mod; + if( ( ( r | g | b ) & ~0xFF ) == 0 ) + { + dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000; + } + else + { + const auto rc = clampu8( r ); + const auto gc = clampu8( g ); + const auto bc = clampu8( b ); + dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000; + } + idx >>= 2; + } + } + } +} + +static etcpak_force_inline void DecodeRGBAPart( uint64_t d, uint64_t alpha, uint32_t* dst, uint32_t w ) +{ + d = ConvertByteOrder( d ); + alpha = _bswap64( alpha ); + + uint32_t br[2], bg[2], bb[2]; + + if( d & 0x2 ) + { + int32_t dr, dg, db; + + uint32_t r0 = ( d & 0xF8000000 ) >> 27; + uint32_t g0 = ( d & 0x00F80000 ) >> 19; + uint32_t b0 = ( d & 0x0000F800 ) >> 11; + + dr = ( int32_t(d) << 5 ) >> 29; + dg = ( int32_t(d) << 13 ) >> 29; + db = ( int32_t(d) << 21 ) >> 29; + + int32_t r1 = int32_t(r0) + dr; + int32_t g1 = int32_t(g0) + dg; + int32_t b1 = int32_t(b0) + db; + + // T mode + if ( (r1 < 0) || (r1 > 31) ) + { + DecodeTAlpha( d, alpha, dst, w ); + return; + } + + // H mode + if ( (g1 < 0) || (g1 > 31) ) + { + DecodeHAlpha( d, alpha, dst, w ); + return; + } + + // P mode + if ( (b1 < 0) || (b1 > 31) ) + { + DecodePlanarAlpha( d, alpha, dst, w ); + return; + } + + br[0] = ( r0 << 3 ) | ( r0 >> 2 ); + br[1] = ( r1 << 3 ) | ( r1 >> 2 ); + bg[0] = ( g0 << 3 ) | ( g0 >> 2 ); + bg[1] = ( g1 << 3 ) | ( g1 >> 2 ); + bb[0] = ( b0 << 3 ) | ( b0 >> 2 ); + bb[1] = ( b1 << 3 ) | ( b1 >> 2 ); + } + else + { + br[0] = ( ( d & 0xF0000000 ) >> 24 ) | ( ( d & 0xF0000000 ) >> 28 ); + br[1] = ( ( d & 0x0F000000 ) >> 20 ) | ( ( d & 0x0F000000 ) >> 24 ); + bg[0] = ( ( d & 0x00F00000 ) >> 16 ) | ( ( d & 0x00F00000 ) >> 20 ); + bg[1] = ( ( d & 0x000F0000 ) >> 12 ) | ( ( d & 0x000F0000 ) >> 16 ); + bb[0] = ( ( d & 0x0000F000 ) >> 8 ) | ( ( d & 0x0000F000 ) >> 12 ); + bb[1] = ( ( d & 0x00000F00 ) >> 4 ) | ( ( d & 0x00000F00 ) >> 8 ); + } + + unsigned int tcw[2]; + tcw[0] = ( d & 0xE0 ) >> 5; + tcw[1] = ( d & 0x1C ) >> 2; + + uint32_t b1 = ( d >> 32 ) & 0xFFFF; + uint32_t b2 = ( d >> 48 ); + + b1 = ( b1 | ( b1 << 8 ) ) & 0x00FF00FF; + b1 = ( b1 | ( b1 << 4 ) ) & 0x0F0F0F0F; + b1 = ( b1 | ( b1 << 2 ) ) & 0x33333333; + b1 = ( b1 | ( b1 << 1 ) ) & 0x55555555; + + b2 = ( b2 | ( b2 << 8 ) ) & 0x00FF00FF; + b2 = ( b2 | ( b2 << 4 ) ) & 0x0F0F0F0F; + b2 = ( b2 | ( b2 << 2 ) ) & 0x33333333; + b2 = ( b2 | ( b2 << 1 ) ) & 0x55555555; + + uint32_t idx = b1 | ( b2 << 1 ); + + const int32_t base = alpha >> 56; + const int32_t mul = ( alpha >> 52 ) & 0xF; + const auto atbl = g_alpha[( alpha >> 48 ) & 0xF]; + + if( d & 0x1 ) + { + for( int i=0; i<4; i++ ) + { + for( int j=0; j<4; j++ ) + { + const auto mod = g_table[tcw[j/2]][idx & 0x3]; + const auto r = br[j/2] + mod; + const auto g = bg[j/2] + mod; + const auto b = bb[j/2] + mod; + const auto amod = atbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; + const uint32_t a = clampu8( base + amod * mul ); + if( ( ( r | g | b ) & ~0xFF ) == 0 ) + { + dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 ); + } + else + { + const auto rc = clampu8( r ); + const auto gc = clampu8( g ); + const auto bc = clampu8( b ); + dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 ); + } + idx >>= 2; + } + } + } + else + { + for( int i=0; i<4; i++ ) + { + const auto tbl = g_table[tcw[i/2]]; + const auto cr = br[i/2]; + const auto cg = bg[i/2]; + const auto cb = bb[i/2]; + + for( int j=0; j<4; j++ ) + { + const auto mod = tbl[idx & 0x3]; + const auto r = cr + mod; + const auto g = cg + mod; + const auto b = cb + mod; + const auto amod = atbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; + const uint32_t a = clampu8( base + amod * mul ); + if( ( ( r | g | b ) & ~0xFF ) == 0 ) + { + dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 ); + } + else + { + const auto rc = clampu8( r ); + const auto gc = clampu8( g ); + const auto bc = clampu8( b ); + dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 ); + } + idx >>= 2; + } + } + } +} + +static etcpak_force_inline void DecodeRPart( uint64_t r, uint32_t* dst, uint32_t w, bool isSigned = false ) +{ + r = _bswap64( r ); + + const int32_t base_byte = ( r >> 56 ); + int32_t base; + if (isSigned) { + int32_t signed_base = (int8_t)base_byte; + if (signed_base == -128) signed_base = -127; + base = signed_base * 8; + } else { + base = base_byte * 8 + 4; + } + const int32_t mul = ( r >> 52 ) & 0xF; + const auto atbl = g_alpha[( r >> 48 ) & 0xF]; + + for( int i=0; i<4; i++ ) + { + for ( int j=0; j<4; j++ ) + { + const auto amod = atbl[(r >> ( 45 - j*3 - i*12 )) & 0x7]; + const int32_t val = ( base + amod * g_alpha11Mul[mul] )/8; + const uint32_t rc = clampu8( isSigned ? val + 128 : val ); + dst[j*w+i] = rc | 0xFF000000; + } + } +} + +static etcpak_force_inline void DecodeRGPart( uint64_t r, uint64_t g, uint32_t* dst, uint32_t w, bool isSigned = false ) +{ + r = _bswap64( r ); + g = _bswap64( g ); + + const int32_t rbase_byte = ( r >> 56 ); + int32_t rbase; + if (isSigned) { + int32_t signed_rbase = (int8_t)rbase_byte; + if (signed_rbase == -128) signed_rbase = -127; + rbase = signed_rbase * 8; + } else { + rbase = rbase_byte * 8 + 4; + } + const int32_t rmul = ( r >> 52 ) & 0xF; + const auto rtbl = g_alpha[( r >> 48 ) & 0xF]; + + const int32_t gbase_byte = ( g >> 56 ); + int32_t gbase; + if (isSigned) { + int32_t signed_gbase = (int8_t)gbase_byte; + if (signed_gbase == -128) signed_gbase = -127; + gbase = signed_gbase * 8; + } else { + gbase = gbase_byte * 8 + 4; + } + const int32_t gmul = ( g >> 52 ) & 0xF; + const auto gtbl = g_alpha[( g >> 48 ) & 0xF]; + + for( int i=0; i<4; i++ ) + { + for( int j=0; j<4; j++ ) + { + const auto rmod = rtbl[(r >> ( 45 - j*3 - i*12 )) & 0x7]; + const int32_t rval = ( rbase + rmod * g_alpha11Mul[rmul] )/8; + const uint32_t rc = clampu8( isSigned ? rval + 128 : rval ); + + const auto gmod = gtbl[(g >> ( 45 - j*3 - i*12 )) & 0x7]; + const int32_t gval = ( gbase + gmod * g_alpha11Mul[gmul] )/8; + const uint32_t gc = clampu8( isSigned ? gval + 128 : gval ); + + dst[j*w+i] = rc | (gc << 8) | 0xFF000000; + } + } +} + +static etcpak_force_inline void DecodeBc1Part( uint64_t d, uint32_t* dst, uint32_t w ) +{ + uint8_t* in = (uint8_t*)&d; + uint16_t c0, c1; + uint32_t idx; + memcpy( &c0, in, 2 ); + memcpy( &c1, in+2, 2 ); + memcpy( &idx, in+4, 4 ); + + uint8_t r0 = ( ( c0 & 0xF800 ) >> 8 ) | ( ( c0 & 0xF800 ) >> 13 ); + uint8_t g0 = ( ( c0 & 0x07E0 ) >> 3 ) | ( ( c0 & 0x07E0 ) >> 9 ); + uint8_t b0 = ( ( c0 & 0x001F ) << 3 ) | ( ( c0 & 0x001F ) >> 2 ); + + uint8_t r1 = ( ( c1 & 0xF800 ) >> 8 ) | ( ( c1 & 0xF800 ) >> 13 ); + uint8_t g1 = ( ( c1 & 0x07E0 ) >> 3 ) | ( ( c1 & 0x07E0 ) >> 9 ); + uint8_t b1 = ( ( c1 & 0x001F ) << 3 ) | ( ( c1 & 0x001F ) >> 2 ); + + uint32_t dict[4]; + + dict[0] = 0xFF000000 | ( b0 << 16 ) | ( g0 << 8 ) | r0; + dict[1] = 0xFF000000 | ( b1 << 16 ) | ( g1 << 8 ) | r1; + + uint32_t r, g, b; + if( c0 > c1 ) + { + r = (2*r0+r1)/3; + g = (2*g0+g1)/3; + b = (2*b0+b1)/3; + dict[2] = 0xFF000000 | ( b << 16 ) | ( g << 8 ) | r; + r = (2*r1+r0)/3; + g = (2*g1+g0)/3; + b = (2*b1+b0)/3; + dict[3] = 0xFF000000 | ( b << 16 ) | ( g << 8 ) | r; + } + else + { + r = (int(r0)+r1)/2; + g = (int(g0)+g1)/2; + b = (int(b0)+b1)/2; + dict[2] = 0xFF000000 | ( b << 16 ) | ( g << 8 ) | r; + dict[3] = 0xFF000000; + } + + memcpy( dst+0, dict + (idx & 0x3), 4 ); + idx >>= 2; + memcpy( dst+1, dict + (idx & 0x3), 4 ); + idx >>= 2; + memcpy( dst+2, dict + (idx & 0x3), 4 ); + idx >>= 2; + memcpy( dst+3, dict + (idx & 0x3), 4 ); +} + +static etcpak_force_inline void DecodeBc3Part( uint64_t a, uint64_t d, uint32_t* dst, uint32_t w ) +{ + uint8_t* ain = (uint8_t*)&a; + uint8_t a0, a1; + uint64_t aidx = 0; + memcpy( &a0, ain, 1 ); + memcpy( &a1, ain+1, 1 ); + memcpy( &aidx, ain+2, 6 ); + + uint8_t* in = (uint8_t*)&d; + uint16_t c0, c1; + uint32_t idx; + memcpy( &c0, in, 2 ); + memcpy( &c1, in+2, 2 ); + memcpy( &idx, in+4, 4 ); + + uint32_t adict[8]; + adict[0] = a0 << 24; + adict[1] = a1 << 24; + if( a0 > a1 ) + { + adict[2] = ( (6*a0+1*a1)/7 ) << 24; + adict[3] = ( (5*a0+2*a1)/7 ) << 24; + adict[4] = ( (4*a0+3*a1)/7 ) << 24; + adict[5] = ( (3*a0+4*a1)/7 ) << 24; + adict[6] = ( (2*a0+5*a1)/7 ) << 24; + adict[7] = ( (1*a0+6*a1)/7 ) << 24; + } + else + { + adict[2] = ( (4*a0+1*a1)/5 ) << 24; + adict[3] = ( (3*a0+2*a1)/5 ) << 24; + adict[4] = ( (2*a0+3*a1)/5 ) << 24; + adict[5] = ( (1*a0+4*a1)/5 ) << 24; + adict[6] = 0; + adict[7] = 0xFF000000; + } + + uint8_t r0 = ( ( c0 & 0xF800 ) >> 8 ) | ( ( c0 & 0xF800 ) >> 13 ); + uint8_t g0 = ( ( c0 & 0x07E0 ) >> 3 ) | ( ( c0 & 0x07E0 ) >> 9 ); + uint8_t b0 = ( ( c0 & 0x001F ) << 3 ) | ( ( c0 & 0x001F ) >> 2 ); + + uint8_t r1 = ( ( c1 & 0xF800 ) >> 8 ) | ( ( c1 & 0xF800 ) >> 13 ); + uint8_t g1 = ( ( c1 & 0x07E0 ) >> 3 ) | ( ( c1 & 0x07E0 ) >> 9 ); + uint8_t b1 = ( ( c1 & 0x001F ) << 3 ) | ( ( c1 & 0x001F ) >> 2 ); + + uint32_t dict[4]; + + dict[0] = ( b0 << 16 ) | ( g0 << 8 ) | r0; + dict[1] = ( b1 << 16 ) | ( g1 << 8 ) | r1; + + uint32_t r, g, b; + if( c0 > c1 ) + { + r = (2*r0+r1)/3; + g = (2*g0+g1)/3; + b = (2*b0+b1)/3; + dict[2] = ( b << 16 ) | ( g << 8 ) | r; + r = (2*r1+r0)/3; + g = (2*g1+g0)/3; + b = (2*b1+b0)/3; + dict[3] = ( b << 16 ) | ( g << 8 ) | r; + } + else + { + r = (int(r0)+r1)/2; + g = (int(g0)+g1)/2; + b = (int(b0)+b1)/2; + dict[2] = ( b << 16 ) | ( g << 8 ) | r; + dict[3] = 0; + } + + dst[0] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[1] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[2] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[3] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst += w; + + dst[0] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[1] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[2] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[3] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst += w; + + dst[0] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[1] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[2] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[3] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst += w; + + dst[0] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[1] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[2] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; + dst[3] = dict[idx & 0x3] | adict[aidx & 0x7]; + idx >>= 2; + aidx >>= 3; +} + +static etcpak_force_inline void DecodeBc4Part( uint64_t a, uint32_t* dst, uint32_t w ) +{ + uint8_t* ain = (uint8_t*)&a; + uint8_t a0, a1; + uint64_t aidx = 0; + memcpy( &a0, ain, 1 ); + memcpy( &a1, ain+1, 1 ); + memcpy( &aidx, ain+2, 6 ); + + uint32_t adict[8]; + adict[0] = a0; + adict[1] = a1; + if(a0 > a1) + { + adict[2] = ( (6*a0+1*a1)/7 ); + adict[3] = ( (5*a0+2*a1)/7 ); + adict[4] = ( (4*a0+3*a1)/7 ); + adict[5] = ( (3*a0+4*a1)/7 ); + adict[6] = ( (2*a0+5*a1)/7 ); + adict[7] = ( (1*a0+6*a1)/7 ); + } + else + { + adict[2] = ( (4*a0+1*a1)/5 ); + adict[3] = ( (3*a0+2*a1)/5 ); + adict[4] = ( (2*a0+3*a1)/5 ); + adict[5] = ( (1*a0+4*a1)/5 ); + adict[6] = 0; + adict[7] = 0xFF; + } + + dst[0] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[1] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[2] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[3] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst += w; + + dst[0] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[1] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[2] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[3] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst += w; + + dst[0] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[1] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[2] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[3] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst += w; + + dst[0] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[1] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[2] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst[3] = adict[aidx & 0x7] | 0xFF000000; + aidx >>= 3; + dst += w; +} + +static etcpak_force_inline void DecodeBc5Part( uint64_t r, uint64_t g, uint32_t* dst, uint32_t w ) +{ + uint8_t* rin = (uint8_t*)&r; + uint8_t r0, r1; + uint64_t ridx = 0; + memcpy( &r0, rin, 1 ); + memcpy( &r1, rin+1, 1 ); + memcpy( &ridx, rin+2, 6 ); + + uint8_t* gin = (uint8_t*)&g; + uint8_t g0, g1; + uint64_t gidx = 0; + memcpy( &g0, gin, 1 ); + memcpy( &g1, gin+1, 1 ); + memcpy( &gidx, gin+2, 6 ); + + uint32_t rdict[8]; + rdict[0] = r0; + rdict[1] = r1; + if(r0 > r1) + { + rdict[2] = ( (6*r0+1*r1)/7 ); + rdict[3] = ( (5*r0+2*r1)/7 ); + rdict[4] = ( (4*r0+3*r1)/7 ); + rdict[5] = ( (3*r0+4*r1)/7 ); + rdict[6] = ( (2*r0+5*r1)/7 ); + rdict[7] = ( (1*r0+6*r1)/7 ); + } + else + { + rdict[2] = ( (4*r0+1*r1)/5 ); + rdict[3] = ( (3*r0+2*r1)/5 ); + rdict[4] = ( (2*r0+3*r1)/5 ); + rdict[5] = ( (1*r0+4*r1)/5 ); + rdict[6] = 0; + rdict[7] = 0xFF; + } + + uint32_t gdict[8]; + gdict[0] = g0 << 8; + gdict[1] = g1 << 8; + if(g0 > g1) + { + gdict[2] = ( (6*g0+1*g1)/7 ) << 8; + gdict[3] = ( (5*g0+2*g1)/7 ) << 8; + gdict[4] = ( (4*g0+3*g1)/7 ) << 8; + gdict[5] = ( (3*g0+4*g1)/7 ) << 8; + gdict[6] = ( (2*g0+5*g1)/7 ) << 8; + gdict[7] = ( (1*g0+6*g1)/7 ) << 8; + } + else + { + gdict[2] = ( (4*g0+1*g1)/5 ) << 8; + gdict[3] = ( (3*g0+2*g1)/5 ) << 8; + gdict[4] = ( (2*g0+3*g1)/5 ) << 8; + gdict[5] = ( (1*g0+4*g1)/5 ) << 8; + gdict[6] = 0; + gdict[7] = 0xFF00; + } + + dst[0] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[1] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[2] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[3] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst += w; + + dst[0] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[1] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[2] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[3] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst += w; + + dst[0] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[1] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[2] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; + dst[3] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; + ridx >>= 3; + gidx >>= 3; +} + +} +void DecodeBc1(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height) +{ + for( int y=0; y + +// Public interface for decoding functions +etcpak_no_inline void DecodeBc1(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); +etcpak_no_inline void DecodeBc3(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); +etcpak_no_inline void DecodeBc4(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); +etcpak_no_inline void DecodeBc5(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); +etcpak_no_inline void DecodeBc7(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); +etcpak_no_inline void DecodeRGB(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); +etcpak_no_inline void DecodeRGBA(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); +etcpak_no_inline void DecodeR(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height, bool isSigned = false); +etcpak_no_inline void DecodeRG(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height, bool isSigned = false); + +#endif + diff --git a/lib/etcpak/etcpak/Dither.cpp b/lib/etcpak/etcpak/Dither.cpp new file mode 100644 index 00000000000..a016b4f3f8c --- /dev/null +++ b/lib/etcpak/etcpak/Dither.cpp @@ -0,0 +1,125 @@ +#include +#include + +#include "Dither.hpp" +#include "Math.hpp" + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#ifdef __SSE4_1__ +# ifdef _MSC_VER +# include +# include +# else +# include +# endif +#endif + +#ifdef __AVX2__ +void DitherAvx2( uint8_t* data, __m128i px0, __m128i px1, __m128i px2, __m128i px3 ) +{ + static constexpr uint8_t a31[] = { 0, 0, 0, 1, 2, 0, 4, 0, 0, 2, 0, 0, 4, 0, 3, 0 }; + static constexpr uint8_t a63[] = { 0, 0, 0, 0, 1, 0, 2, 0, 0, 1, 0, 0, 2, 0, 1, 0 }; + static constexpr uint8_t s31[] = { 5, 0, 4, 0, 0, 2, 0, 1, 3, 0, 4, 0, 0, 0, 0, 2 }; + static constexpr uint8_t s63[] = { 2, 0, 2, 0, 0, 1, 0, 0, 1, 0, 2, 0, 0, 0, 0, 1 }; + + const __m256i BayerAdd0 = _mm256_setr_epi8( + a31[0], a63[0], a31[0], 0, a31[1], a63[1], a31[1], 0, a31[2], a63[2], a31[2], 0, a31[3], a63[3], a31[3], 0, + a31[4], a63[4], a31[4], 0, a31[5], a63[5], a31[5], 0, a31[6], a63[6], a31[6], 0, a31[7], a63[7], a31[7], 0 + ); + const __m256i BayerAdd1 = _mm256_setr_epi8( + a31[8], a63[8], a31[8], 0, a31[9], a63[9], a31[9], 0, a31[10], a63[10], a31[10], 0, a31[11], a63[11], a31[11], 0, + a31[12], a63[12], a31[12], 0, a31[13], a63[13], a31[13], 0, a31[14], a63[14], a31[14], 0, a31[15], a63[15], a31[15], 0 + ); + const __m256i BayerSub0 = _mm256_setr_epi8( + s31[0], s63[0], s31[0], 0, s31[1], s63[1], s31[1], 0, s31[2], s63[2], s31[2], 0, s31[3], s63[3], s31[3], 0, + s31[4], s63[4], s31[4], 0, s31[5], s63[5], s31[5], 0, s31[6], s63[6], s31[6], 0, s31[7], s63[7], s31[7], 0 + ); + const __m256i BayerSub1 = _mm256_setr_epi8( + s31[8], s63[8], s31[8], 0, s31[9], s63[9], s31[9], 0, s31[10], s63[10], s31[10], 0, s31[11], s63[11], s31[11], 0, + s31[12], s63[12], s31[12], 0, s31[13], s63[13], s31[13], 0, s31[14], s63[14], s31[14], 0, s31[15], s63[15], s31[15], 0 + ); + + __m256i l0 = _mm256_inserti128_si256( _mm256_castsi128_si256( px0 ), px1, 1 ); + __m256i l1 = _mm256_inserti128_si256( _mm256_castsi128_si256( px2 ), px3, 1 ); + + __m256i a0 = _mm256_adds_epu8( l0, BayerAdd0 ); + __m256i a1 = _mm256_adds_epu8( l1, BayerAdd1 ); + __m256i s0 = _mm256_subs_epu8( a0, BayerSub0 ); + __m256i s1 = _mm256_subs_epu8( a1, BayerSub1 ); + + _mm256_storeu_si256( (__m256i*)(data ), s0 ); + _mm256_storeu_si256( (__m256i*)(data+32), s1 ); + +} +#endif + +void Dither( uint8_t* data ) +{ +#ifdef __AVX2__ + static constexpr uint8_t a31[] = { 0, 0, 0, 1, 2, 0, 4, 0, 0, 2, 0, 0, 4, 0, 3, 0 }; + static constexpr uint8_t a63[] = { 0, 0, 0, 0, 1, 0, 2, 0, 0, 1, 0, 0, 2, 0, 1, 0 }; + static constexpr uint8_t s31[] = { 5, 0, 4, 0, 0, 2, 0, 1, 3, 0, 4, 0, 0, 0, 0, 2 }; + static constexpr uint8_t s63[] = { 2, 0, 2, 0, 0, 1, 0, 0, 1, 0, 2, 0, 0, 0, 0, 1 }; + + const __m256i BayerAdd0 = _mm256_setr_epi8( + a31[0], a63[0], a31[0], 0, a31[1], a63[1], a31[1], 0, a31[2], a63[2], a31[2], 0, a31[3], a63[3], a31[3], 0, + a31[4], a63[4], a31[4], 0, a31[5], a63[5], a31[5], 0, a31[6], a63[6], a31[6], 0, a31[7], a63[7], a31[7], 0 + ); + const __m256i BayerAdd1 = _mm256_setr_epi8( + a31[8], a63[8], a31[8], 0, a31[9], a63[9], a31[9], 0, a31[10], a63[10], a31[10], 0, a31[11], a63[11], a31[11], 0, + a31[12], a63[12], a31[12], 0, a31[13], a63[13], a31[13], 0, a31[14], a63[14], a31[14], 0, a31[15], a63[15], a31[15], 0 + ); + const __m256i BayerSub0 = _mm256_setr_epi8( + s31[0], s63[0], s31[0], 0, s31[1], s63[1], s31[1], 0, s31[2], s63[2], s31[2], 0, s31[3], s63[3], s31[3], 0, + s31[4], s63[4], s31[4], 0, s31[5], s63[5], s31[5], 0, s31[6], s63[6], s31[6], 0, s31[7], s63[7], s31[7], 0 + ); + const __m256i BayerSub1 = _mm256_setr_epi8( + s31[8], s63[8], s31[8], 0, s31[9], s63[9], s31[9], 0, s31[10], s63[10], s31[10], 0, s31[11], s63[11], s31[11], 0, + s31[12], s63[12], s31[12], 0, s31[13], s63[13], s31[13], 0, s31[14], s63[14], s31[14], 0, s31[15], s63[15], s31[15], 0 + ); + + __m256i px0 = _mm256_loadu_si256( (__m256i*)(data ) ); + __m256i px1 = _mm256_loadu_si256( (__m256i*)(data+32) ); + + __m256i a0 = _mm256_adds_epu8( px0, BayerAdd0 ); + __m256i a1 = _mm256_adds_epu8( px1, BayerAdd1 ); + __m256i s0 = _mm256_subs_epu8( a0, BayerSub0 ); + __m256i s1 = _mm256_subs_epu8( a1, BayerSub1 ); + + _mm256_storeu_si256( (__m256i*)(data ), s0 ); + _mm256_storeu_si256( (__m256i*)(data+32), s1 ); +#else + static constexpr int8_t Bayer31[16] = { + ( 0-8)*2/3, ( 8-8)*2/3, ( 2-8)*2/3, (10-8)*2/3, + (12-8)*2/3, ( 4-8)*2/3, (14-8)*2/3, ( 6-8)*2/3, + ( 3-8)*2/3, (11-8)*2/3, ( 1-8)*2/3, ( 9-8)*2/3, + (15-8)*2/3, ( 7-8)*2/3, (13-8)*2/3, ( 5-8)*2/3 + }; + static constexpr int8_t Bayer63[16] = { + ( 0-8)*2/6, ( 8-8)*2/6, ( 2-8)*2/6, (10-8)*2/6, + (12-8)*2/6, ( 4-8)*2/6, (14-8)*2/6, ( 6-8)*2/6, + ( 3-8)*2/6, (11-8)*2/6, ( 1-8)*2/6, ( 9-8)*2/6, + (15-8)*2/6, ( 7-8)*2/6, (13-8)*2/6, ( 5-8)*2/6 + }; + + for( int i=0; i<16; i++ ) + { + uint32_t col; + memcpy( &col, data, 4 ); + uint8_t r = col & 0xFF; + uint8_t g = ( col >> 8 ) & 0xFF; + uint8_t b = ( col >> 16 ) & 0xFF; + + r = clampu8( r + Bayer31[i] ); + g = clampu8( g + Bayer63[i] ); + b = clampu8( b + Bayer31[i] ); + + col = r | ( g << 8 ) | ( b << 16 ); + memcpy( data, &col, 4 ); + data += 4; + } +#endif +} diff --git a/lib/etcpak/etcpak/Dither.hpp b/lib/etcpak/etcpak/Dither.hpp new file mode 100644 index 00000000000..e43ce5676db --- /dev/null +++ b/lib/etcpak/etcpak/Dither.hpp @@ -0,0 +1,21 @@ +#ifndef __DITHER_HPP__ +#define __DITHER_HPP__ + +#include +#include + +#ifdef __AVX2__ +# ifdef _MSC_VER +# include +# else +# include +# endif +#endif + +void Dither( uint8_t* data ); + +#ifdef __AVX2__ +void DitherAvx2( uint8_t* data, __m128i px0, __m128i px1, __m128i px2, __m128i px3 ); +#endif + +#endif diff --git a/lib/etcpak/etcpak/Error.cpp b/lib/etcpak/etcpak/Error.cpp new file mode 100644 index 00000000000..014ecdab667 --- /dev/null +++ b/lib/etcpak/etcpak/Error.cpp @@ -0,0 +1,48 @@ +#include + +#include "Error.hpp" +#include "Math.hpp" + +float CalcMSE3( const Bitmap& bmp, const Bitmap& out ) +{ + float err = 0; + + const uint32_t* p1 = bmp.Data(); + const uint32_t* p2 = out.Data(); + size_t cnt = bmp.Size().x * bmp.Size().y; + + for( size_t i=0; i> 8 ) - ( ( c2 & 0x0000FF00 ) >> 8 ) ); + err += sq( ( ( c1 & 0x00FF0000 ) >> 16 ) - ( ( c2 & 0x00FF0000 ) >> 16 ) ); + } + + err /= cnt * 3; + + return err; +} + +float CalcMSE1( const Bitmap& bmp, const Bitmap& out ) +{ + float err = 0; + + const uint32_t* p1 = bmp.Data(); + const uint32_t* p2 = out.Data(); + size_t cnt = bmp.Size().x * bmp.Size().y; + + for( size_t i=0; i> 24 ) - ( c2 & 0xFF ) ); + } + + err /= cnt; + + return err; +} diff --git a/lib/etcpak/etcpak/Error.hpp b/lib/etcpak/etcpak/Error.hpp new file mode 100644 index 00000000000..9817754b741 --- /dev/null +++ b/lib/etcpak/etcpak/Error.hpp @@ -0,0 +1,9 @@ +#ifndef __ERROR_HPP__ +#define __ERROR_HPP__ + +#include "Bitmap.hpp" + +float CalcMSE3( const Bitmap& bmp, const Bitmap& out ); +float CalcMSE1( const Bitmap& bmp, const Bitmap& out ); + +#endif diff --git a/lib/etcpak/etcpak/ForceInline.hpp b/lib/etcpak/etcpak/ForceInline.hpp new file mode 100644 index 00000000000..b6f012841ba --- /dev/null +++ b/lib/etcpak/etcpak/ForceInline.hpp @@ -0,0 +1,20 @@ +#ifndef __FORCEINLINE_HPP__ +#define __FORCEINLINE_HPP__ + +#if defined(__GNUC__) +# define etcpak_force_inline __attribute__((always_inline)) inline +#elif defined(_MSC_VER) +# define etcpak_force_inline __forceinline +#else +# define etcpak_force_inline inline +#endif + +#if defined(__GNUC__) +# define etcpak_no_inline __attribute__((noinline)) +#elif defined(_MSC_VER) +# define etcpak_no_inline __declspec(noinline) +#else +# define etcpak_no_inline +#endif + +#endif diff --git a/lib/etcpak/etcpak/LICENSE.txt b/lib/etcpak/etcpak/LICENSE.txt new file mode 100644 index 00000000000..015506c2de0 --- /dev/null +++ b/lib/etcpak/etcpak/LICENSE.txt @@ -0,0 +1,26 @@ +etcpak, an extremely fast ETC compression utility (https://github.com/wolfpld/etcpak) + +Copyright (c) 2013-2026, Bartosz Taudul +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/lib/etcpak/etcpak/Math.hpp b/lib/etcpak/etcpak/Math.hpp new file mode 100644 index 00000000000..994e1ac4eae --- /dev/null +++ b/lib/etcpak/etcpak/Math.hpp @@ -0,0 +1,92 @@ +#ifndef __DARKRL__MATH_HPP__ +#define __DARKRL__MATH_HPP__ + +#include +#include +#include + +#include "ForceInline.hpp" + +template +static etcpak_force_inline T AlignPOT( T val ) +{ + if( val == 0 ) return 1; + val--; + for( unsigned int i=1; i> i; + } + return val + 1; +} + +static etcpak_force_inline int CountSetBits( uint32_t val ) +{ + val -= ( val >> 1 ) & 0x55555555; + val = ( ( val >> 2 ) & 0x33333333 ) + ( val & 0x33333333 ); + val = ( ( val >> 4 ) + val ) & 0x0f0f0f0f; + val += val >> 8; + val += val >> 16; + return val & 0x0000003f; +} + +static etcpak_force_inline int CountLeadingZeros( uint32_t val ) +{ + val |= val >> 1; + val |= val >> 2; + val |= val >> 4; + val |= val >> 8; + val |= val >> 16; + return 32 - CountSetBits( val ); +} + +static etcpak_force_inline float sRGB2linear( float v ) +{ + const float a = 0.055f; + if( v <= 0.04045f ) + { + return v / 12.92f; + } + else + { + return pow( ( v + a ) / ( 1 + a ), 2.4f ); + } +} + +static etcpak_force_inline float linear2sRGB( float v ) +{ + const float a = 0.055f; + if( v <= 0.0031308f ) + { + return 12.92f * v; + } + else + { + return ( 1 + a ) * pow( v, 1/2.4f ) - a; + } +} + +template +static etcpak_force_inline T SmoothStep( T x ) +{ + return x*x*(3-2*x); +} + +static etcpak_force_inline uint8_t clampu8( int32_t val ) +{ + if( ( val & ~0xFF ) == 0 ) return val; + return ( ( ~val ) >> 31 ) & 0xFF; +} + +template +static etcpak_force_inline T sq( T val ) +{ + return val * val; +} + +static etcpak_force_inline int mul8bit( int a, int b ) +{ + int t = a*b + 128; + return ( t + ( t >> 8 ) ) >> 8; +} + +#endif diff --git a/lib/etcpak/etcpak/MipMap.hpp b/lib/etcpak/etcpak/MipMap.hpp new file mode 100644 index 00000000000..d3b4bc9e7cf --- /dev/null +++ b/lib/etcpak/etcpak/MipMap.hpp @@ -0,0 +1,11 @@ +#ifndef __MIPMAP_HPP__ +#define __MIPMAP_HPP__ + +#include "Vector.hpp" + +inline int NumberOfMipLevels( const v2i& size ) +{ + return (int)floor( log2( std::max( size.x, size.y ) ) ) + 1; +} + +#endif diff --git a/lib/etcpak/etcpak/ProcessCommon.hpp b/lib/etcpak/etcpak/ProcessCommon.hpp new file mode 100644 index 00000000000..657d68888f9 --- /dev/null +++ b/lib/etcpak/etcpak/ProcessCommon.hpp @@ -0,0 +1,50 @@ +#ifndef __PROCESSCOMMON_HPP__ +#define __PROCESSCOMMON_HPP__ + +#include +#include +#include + +template +static size_t GetLeastError( const T* err, size_t num ) +{ + size_t idx = 0; + for( size_t i=1; i> 24 ) | + ( ( d & 0x000000FF00000000 ) << 24 ) | + ( ( d & 0x00FF000000000000 ) >> 8 ) | + ( ( d & 0x0000FF0000000000 ) << 8 ); +} + +template +static uint64_t EncodeSelectors( uint64_t d, const T terr[2][8], const S tsel[16][8], const uint32_t* id ) +{ + size_t tidx[2]; + tidx[0] = GetLeastError( terr[0], 8 ); + tidx[1] = GetLeastError( terr[1], 8 ); + + d |= tidx[0] << 26; + d |= tidx[1] << 29; + for( int i=0; i<16; i++ ) + { + uint64_t t = tsel[i][tidx[id[i]%2]]; + d |= ( t & 0x1 ) << ( i + 32 ); + d |= ( t & 0x2 ) << ( i + 47 ); + } + + return d; +} + +#endif diff --git a/lib/etcpak/etcpak/ProcessDxtc.cpp b/lib/etcpak/etcpak/ProcessDxtc.cpp new file mode 100644 index 00000000000..23a3326a898 --- /dev/null +++ b/lib/etcpak/etcpak/ProcessDxtc.cpp @@ -0,0 +1,1120 @@ +#include "bc7enc.h" +#include "Dither.hpp" +#include "ForceInline.hpp" +#include "ProcessDxtc.hpp" + +#include +#include +#include + +#ifdef __ARM_NEON +# include +#endif + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#if defined __SSE4_1__ || defined __AVX2__ +# ifdef _MSC_VER +# include +# else +# include +# ifndef _mm256_cvtsi256_si32 +# define _mm256_cvtsi256_si32( v ) ( _mm_cvtsi128_si32( _mm256_castsi256_si128( v ) ) ) +# endif +# endif +#endif + + +static etcpak_force_inline uint16_t to565( uint8_t r, uint8_t g, uint8_t b ) +{ + return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( b >> 3 ); +} + +static etcpak_force_inline uint16_t to565( uint32_t c ) +{ + return + ( ( c & 0xF80000 ) >> 19 ) | + ( ( c & 0x00FC00 ) >> 5 ) | + ( ( c & 0x0000F8 ) << 8 ); +} + +static const uint8_t DxtcIndexTable[256] = { + 85, 87, 86, 84, 93, 95, 94, 92, 89, 91, 90, 88, 81, 83, 82, 80, + 117, 119, 118, 116, 125, 127, 126, 124, 121, 123, 122, 120, 113, 115, 114, 112, + 101, 103, 102, 100, 109, 111, 110, 108, 105, 107, 106, 104, 97, 99, 98, 96, + 69, 71, 70, 68, 77, 79, 78, 76, 73, 75, 74, 72, 65, 67, 66, 64, + 213, 215, 214, 212, 221, 223, 222, 220, 217, 219, 218, 216, 209, 211, 210, 208, + 245, 247, 246, 244, 253, 255, 254, 252, 249, 251, 250, 248, 241, 243, 242, 240, + 229, 231, 230, 228, 237, 239, 238, 236, 233, 235, 234, 232, 225, 227, 226, 224, + 197, 199, 198, 196, 205, 207, 206, 204, 201, 203, 202, 200, 193, 195, 194, 192, + 149, 151, 150, 148, 157, 159, 158, 156, 153, 155, 154, 152, 145, 147, 146, 144, + 181, 183, 182, 180, 189, 191, 190, 188, 185, 187, 186, 184, 177, 179, 178, 176, + 165, 167, 166, 164, 173, 175, 174, 172, 169, 171, 170, 168, 161, 163, 162, 160, + 133, 135, 134, 132, 141, 143, 142, 140, 137, 139, 138, 136, 129, 131, 130, 128, + 21, 23, 22, 20, 29, 31, 30, 28, 25, 27, 26, 24, 17, 19, 18, 16, + 53, 55, 54, 52, 61, 63, 62, 60, 57, 59, 58, 56, 49, 51, 50, 48, + 37, 39, 38, 36, 45, 47, 46, 44, 41, 43, 42, 40, 33, 35, 34, 32, + 5, 7, 6, 4, 13, 15, 14, 12, 9, 11, 10, 8, 1, 3, 2, 0 +}; + +static const uint8_t AlphaIndexTable_SSE[64] = { + 9, 15, 14, 13, 12, 11, 10, 8, 57, 63, 62, 61, 60, 59, 58, 56, + 49, 55, 54, 53, 52, 51, 50, 48, 41, 47, 46, 45, 44, 43, 42, 40, + 33, 39, 38, 37, 36, 35, 34, 32, 25, 31, 30, 29, 28, 27, 26, 24, + 17, 23, 22, 21, 20, 19, 18, 16, 1, 7, 6, 5, 4, 3, 2, 0, +}; + +static const uint16_t DivTable[255*3+1] = { + 0xffff, 0xffff, 0xffff, 0xffff, 0xcccc, 0xaaaa, 0x9249, 0x8000, 0x71c7, 0x6666, 0x5d17, 0x5555, 0x4ec4, 0x4924, 0x4444, 0x4000, + 0x3c3c, 0x38e3, 0x35e5, 0x3333, 0x30c3, 0x2e8b, 0x2c85, 0x2aaa, 0x28f5, 0x2762, 0x25ed, 0x2492, 0x234f, 0x2222, 0x2108, 0x2000, + 0x1f07, 0x1e1e, 0x1d41, 0x1c71, 0x1bac, 0x1af2, 0x1a41, 0x1999, 0x18f9, 0x1861, 0x17d0, 0x1745, 0x16c1, 0x1642, 0x15c9, 0x1555, + 0x14e5, 0x147a, 0x1414, 0x13b1, 0x1352, 0x12f6, 0x129e, 0x1249, 0x11f7, 0x11a7, 0x115b, 0x1111, 0x10c9, 0x1084, 0x1041, 0x1000, + 0x0fc0, 0x0f83, 0x0f48, 0x0f0f, 0x0ed7, 0x0ea0, 0x0e6c, 0x0e38, 0x0e07, 0x0dd6, 0x0da7, 0x0d79, 0x0d4c, 0x0d20, 0x0cf6, 0x0ccc, + 0x0ca4, 0x0c7c, 0x0c56, 0x0c30, 0x0c0c, 0x0be8, 0x0bc5, 0x0ba2, 0x0b81, 0x0b60, 0x0b40, 0x0b21, 0x0b02, 0x0ae4, 0x0ac7, 0x0aaa, + 0x0a8e, 0x0a72, 0x0a57, 0x0a3d, 0x0a23, 0x0a0a, 0x09f1, 0x09d8, 0x09c0, 0x09a9, 0x0991, 0x097b, 0x0964, 0x094f, 0x0939, 0x0924, + 0x090f, 0x08fb, 0x08e7, 0x08d3, 0x08c0, 0x08ad, 0x089a, 0x0888, 0x0876, 0x0864, 0x0853, 0x0842, 0x0831, 0x0820, 0x0810, 0x0800, + 0x07f0, 0x07e0, 0x07d1, 0x07c1, 0x07b3, 0x07a4, 0x0795, 0x0787, 0x0779, 0x076b, 0x075d, 0x0750, 0x0743, 0x0736, 0x0729, 0x071c, + 0x070f, 0x0703, 0x06f7, 0x06eb, 0x06df, 0x06d3, 0x06c8, 0x06bc, 0x06b1, 0x06a6, 0x069b, 0x0690, 0x0685, 0x067b, 0x0670, 0x0666, + 0x065c, 0x0652, 0x0648, 0x063e, 0x0634, 0x062b, 0x0621, 0x0618, 0x060f, 0x0606, 0x05fd, 0x05f4, 0x05eb, 0x05e2, 0x05d9, 0x05d1, + 0x05c9, 0x05c0, 0x05b8, 0x05b0, 0x05a8, 0x05a0, 0x0598, 0x0590, 0x0588, 0x0581, 0x0579, 0x0572, 0x056b, 0x0563, 0x055c, 0x0555, + 0x054e, 0x0547, 0x0540, 0x0539, 0x0532, 0x052b, 0x0525, 0x051e, 0x0518, 0x0511, 0x050b, 0x0505, 0x04fe, 0x04f8, 0x04f2, 0x04ec, + 0x04e6, 0x04e0, 0x04da, 0x04d4, 0x04ce, 0x04c8, 0x04c3, 0x04bd, 0x04b8, 0x04b2, 0x04ad, 0x04a7, 0x04a2, 0x049c, 0x0497, 0x0492, + 0x048d, 0x0487, 0x0482, 0x047d, 0x0478, 0x0473, 0x046e, 0x0469, 0x0465, 0x0460, 0x045b, 0x0456, 0x0452, 0x044d, 0x0448, 0x0444, + 0x043f, 0x043b, 0x0436, 0x0432, 0x042d, 0x0429, 0x0425, 0x0421, 0x041c, 0x0418, 0x0414, 0x0410, 0x040c, 0x0408, 0x0404, 0x0400, + 0x03fc, 0x03f8, 0x03f4, 0x03f0, 0x03ec, 0x03e8, 0x03e4, 0x03e0, 0x03dd, 0x03d9, 0x03d5, 0x03d2, 0x03ce, 0x03ca, 0x03c7, 0x03c3, + 0x03c0, 0x03bc, 0x03b9, 0x03b5, 0x03b2, 0x03ae, 0x03ab, 0x03a8, 0x03a4, 0x03a1, 0x039e, 0x039b, 0x0397, 0x0394, 0x0391, 0x038e, + 0x038b, 0x0387, 0x0384, 0x0381, 0x037e, 0x037b, 0x0378, 0x0375, 0x0372, 0x036f, 0x036c, 0x0369, 0x0366, 0x0364, 0x0361, 0x035e, + 0x035b, 0x0358, 0x0355, 0x0353, 0x0350, 0x034d, 0x034a, 0x0348, 0x0345, 0x0342, 0x0340, 0x033d, 0x033a, 0x0338, 0x0335, 0x0333, + 0x0330, 0x032e, 0x032b, 0x0329, 0x0326, 0x0324, 0x0321, 0x031f, 0x031c, 0x031a, 0x0317, 0x0315, 0x0313, 0x0310, 0x030e, 0x030c, + 0x0309, 0x0307, 0x0305, 0x0303, 0x0300, 0x02fe, 0x02fc, 0x02fa, 0x02f7, 0x02f5, 0x02f3, 0x02f1, 0x02ef, 0x02ec, 0x02ea, 0x02e8, + 0x02e6, 0x02e4, 0x02e2, 0x02e0, 0x02de, 0x02dc, 0x02da, 0x02d8, 0x02d6, 0x02d4, 0x02d2, 0x02d0, 0x02ce, 0x02cc, 0x02ca, 0x02c8, + 0x02c6, 0x02c4, 0x02c2, 0x02c0, 0x02be, 0x02bc, 0x02bb, 0x02b9, 0x02b7, 0x02b5, 0x02b3, 0x02b1, 0x02b0, 0x02ae, 0x02ac, 0x02aa, + 0x02a8, 0x02a7, 0x02a5, 0x02a3, 0x02a1, 0x02a0, 0x029e, 0x029c, 0x029b, 0x0299, 0x0297, 0x0295, 0x0294, 0x0292, 0x0291, 0x028f, + 0x028d, 0x028c, 0x028a, 0x0288, 0x0287, 0x0285, 0x0284, 0x0282, 0x0280, 0x027f, 0x027d, 0x027c, 0x027a, 0x0279, 0x0277, 0x0276, + 0x0274, 0x0273, 0x0271, 0x0270, 0x026e, 0x026d, 0x026b, 0x026a, 0x0268, 0x0267, 0x0265, 0x0264, 0x0263, 0x0261, 0x0260, 0x025e, + 0x025d, 0x025c, 0x025a, 0x0259, 0x0257, 0x0256, 0x0255, 0x0253, 0x0252, 0x0251, 0x024f, 0x024e, 0x024d, 0x024b, 0x024a, 0x0249, + 0x0247, 0x0246, 0x0245, 0x0243, 0x0242, 0x0241, 0x0240, 0x023e, 0x023d, 0x023c, 0x023b, 0x0239, 0x0238, 0x0237, 0x0236, 0x0234, + 0x0233, 0x0232, 0x0231, 0x0230, 0x022e, 0x022d, 0x022c, 0x022b, 0x022a, 0x0229, 0x0227, 0x0226, 0x0225, 0x0224, 0x0223, 0x0222, + 0x0220, 0x021f, 0x021e, 0x021d, 0x021c, 0x021b, 0x021a, 0x0219, 0x0218, 0x0216, 0x0215, 0x0214, 0x0213, 0x0212, 0x0211, 0x0210, + 0x020f, 0x020e, 0x020d, 0x020c, 0x020b, 0x020a, 0x0209, 0x0208, 0x0207, 0x0206, 0x0205, 0x0204, 0x0203, 0x0202, 0x0201, 0x0200, + 0x01ff, 0x01fe, 0x01fd, 0x01fc, 0x01fb, 0x01fa, 0x01f9, 0x01f8, 0x01f7, 0x01f6, 0x01f5, 0x01f4, 0x01f3, 0x01f2, 0x01f1, 0x01f0, + 0x01ef, 0x01ee, 0x01ed, 0x01ec, 0x01eb, 0x01ea, 0x01e9, 0x01e9, 0x01e8, 0x01e7, 0x01e6, 0x01e5, 0x01e4, 0x01e3, 0x01e2, 0x01e1, + 0x01e0, 0x01e0, 0x01df, 0x01de, 0x01dd, 0x01dc, 0x01db, 0x01da, 0x01da, 0x01d9, 0x01d8, 0x01d7, 0x01d6, 0x01d5, 0x01d4, 0x01d4, + 0x01d3, 0x01d2, 0x01d1, 0x01d0, 0x01cf, 0x01cf, 0x01ce, 0x01cd, 0x01cc, 0x01cb, 0x01cb, 0x01ca, 0x01c9, 0x01c8, 0x01c7, 0x01c7, + 0x01c6, 0x01c5, 0x01c4, 0x01c3, 0x01c3, 0x01c2, 0x01c1, 0x01c0, 0x01c0, 0x01bf, 0x01be, 0x01bd, 0x01bd, 0x01bc, 0x01bb, 0x01ba, + 0x01ba, 0x01b9, 0x01b8, 0x01b7, 0x01b7, 0x01b6, 0x01b5, 0x01b4, 0x01b4, 0x01b3, 0x01b2, 0x01b2, 0x01b1, 0x01b0, 0x01af, 0x01af, + 0x01ae, 0x01ad, 0x01ad, 0x01ac, 0x01ab, 0x01aa, 0x01aa, 0x01a9, 0x01a8, 0x01a8, 0x01a7, 0x01a6, 0x01a6, 0x01a5, 0x01a4, 0x01a4, + 0x01a3, 0x01a2, 0x01a2, 0x01a1, 0x01a0, 0x01a0, 0x019f, 0x019e, 0x019e, 0x019d, 0x019c, 0x019c, 0x019b, 0x019a, 0x019a, 0x0199, + 0x0198, 0x0198, 0x0197, 0x0197, 0x0196, 0x0195, 0x0195, 0x0194, 0x0193, 0x0193, 0x0192, 0x0192, 0x0191, 0x0190, 0x0190, 0x018f, + 0x018f, 0x018e, 0x018d, 0x018d, 0x018c, 0x018b, 0x018b, 0x018a, 0x018a, 0x0189, 0x0189, 0x0188, 0x0187, 0x0187, 0x0186, 0x0186, + 0x0185, 0x0184, 0x0184, 0x0183, 0x0183, 0x0182, 0x0182, 0x0181, 0x0180, 0x0180, 0x017f, 0x017f, 0x017e, 0x017e, 0x017d, 0x017d, + 0x017c, 0x017b, 0x017b, 0x017a, 0x017a, 0x0179, 0x0179, 0x0178, 0x0178, 0x0177, 0x0177, 0x0176, 0x0175, 0x0175, 0x0174, 0x0174, + 0x0173, 0x0173, 0x0172, 0x0172, 0x0171, 0x0171, 0x0170, 0x0170, 0x016f, 0x016f, 0x016e, 0x016e, 0x016d, 0x016d, 0x016c, 0x016c, + 0x016b, 0x016b, 0x016a, 0x016a, 0x0169, 0x0169, 0x0168, 0x0168, 0x0167, 0x0167, 0x0166, 0x0166, 0x0165, 0x0165, 0x0164, 0x0164, + 0x0163, 0x0163, 0x0162, 0x0162, 0x0161, 0x0161, 0x0160, 0x0160, 0x015f, 0x015f, 0x015e, 0x015e, 0x015d, 0x015d, 0x015d, 0x015c, + 0x015c, 0x015b, 0x015b, 0x015a, 0x015a, 0x0159, 0x0159, 0x0158, 0x0158, 0x0158, 0x0157, 0x0157, 0x0156, 0x0156 +}; +static const uint16_t DivTableNEON[255*3+1] = { + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x1c71, 0x1af2, 0x1999, 0x1861, 0x1745, 0x1642, 0x1555, 0x147a, 0x13b1, 0x12f6, 0x1249, 0x11a7, 0x1111, 0x1084, 0x1000, + 0x0f83, 0x0f0f, 0x0ea0, 0x0e38, 0x0dd6, 0x0d79, 0x0d20, 0x0ccc, 0x0c7c, 0x0c30, 0x0be8, 0x0ba2, 0x0b60, 0x0b21, 0x0ae4, 0x0aaa, + 0x0a72, 0x0a3d, 0x0a0a, 0x09d8, 0x09a9, 0x097b, 0x094f, 0x0924, 0x08fb, 0x08d3, 0x08ad, 0x0888, 0x0864, 0x0842, 0x0820, 0x0800, + 0x07e0, 0x07c1, 0x07a4, 0x0787, 0x076b, 0x0750, 0x0736, 0x071c, 0x0703, 0x06eb, 0x06d3, 0x06bc, 0x06a6, 0x0690, 0x067b, 0x0666, + 0x0652, 0x063e, 0x062b, 0x0618, 0x0606, 0x05f4, 0x05e2, 0x05d1, 0x05c0, 0x05b0, 0x05a0, 0x0590, 0x0581, 0x0572, 0x0563, 0x0555, + 0x0547, 0x0539, 0x052b, 0x051e, 0x0511, 0x0505, 0x04f8, 0x04ec, 0x04e0, 0x04d4, 0x04c8, 0x04bd, 0x04b2, 0x04a7, 0x049c, 0x0492, + 0x0487, 0x047d, 0x0473, 0x0469, 0x0460, 0x0456, 0x044d, 0x0444, 0x043b, 0x0432, 0x0429, 0x0421, 0x0418, 0x0410, 0x0408, 0x0400, + 0x03f8, 0x03f0, 0x03e8, 0x03e0, 0x03d9, 0x03d2, 0x03ca, 0x03c3, 0x03bc, 0x03b5, 0x03ae, 0x03a8, 0x03a1, 0x039b, 0x0394, 0x038e, + 0x0387, 0x0381, 0x037b, 0x0375, 0x036f, 0x0369, 0x0364, 0x035e, 0x0358, 0x0353, 0x034d, 0x0348, 0x0342, 0x033d, 0x0338, 0x0333, + 0x032e, 0x0329, 0x0324, 0x031f, 0x031a, 0x0315, 0x0310, 0x030c, 0x0307, 0x0303, 0x02fe, 0x02fa, 0x02f5, 0x02f1, 0x02ec, 0x02e8, + 0x02e4, 0x02e0, 0x02dc, 0x02d8, 0x02d4, 0x02d0, 0x02cc, 0x02c8, 0x02c4, 0x02c0, 0x02bc, 0x02b9, 0x02b5, 0x02b1, 0x02ae, 0x02aa, + 0x02a7, 0x02a3, 0x02a0, 0x029c, 0x0299, 0x0295, 0x0292, 0x028f, 0x028c, 0x0288, 0x0285, 0x0282, 0x027f, 0x027c, 0x0279, 0x0276, + 0x0273, 0x0270, 0x026d, 0x026a, 0x0267, 0x0264, 0x0261, 0x025e, 0x025c, 0x0259, 0x0256, 0x0253, 0x0251, 0x024e, 0x024b, 0x0249, + 0x0246, 0x0243, 0x0241, 0x023e, 0x023c, 0x0239, 0x0237, 0x0234, 0x0232, 0x0230, 0x022d, 0x022b, 0x0229, 0x0226, 0x0224, 0x0222, + 0x021f, 0x021d, 0x021b, 0x0219, 0x0216, 0x0214, 0x0212, 0x0210, 0x020e, 0x020c, 0x020a, 0x0208, 0x0206, 0x0204, 0x0202, 0x0200, + 0x01fe, 0x01fc, 0x01fa, 0x01f8, 0x01f6, 0x01f4, 0x01f2, 0x01f0, 0x01ee, 0x01ec, 0x01ea, 0x01e9, 0x01e7, 0x01e5, 0x01e3, 0x01e1, + 0x01e0, 0x01de, 0x01dc, 0x01da, 0x01d9, 0x01d7, 0x01d5, 0x01d4, 0x01d2, 0x01d0, 0x01cf, 0x01cd, 0x01cb, 0x01ca, 0x01c8, 0x01c7, + 0x01c5, 0x01c3, 0x01c2, 0x01c0, 0x01bf, 0x01bd, 0x01bc, 0x01ba, 0x01b9, 0x01b7, 0x01b6, 0x01b4, 0x01b3, 0x01b2, 0x01b0, 0x01af, + 0x01ad, 0x01ac, 0x01aa, 0x01a9, 0x01a8, 0x01a6, 0x01a5, 0x01a4, 0x01a2, 0x01a1, 0x01a0, 0x019e, 0x019d, 0x019c, 0x019a, 0x0199, + 0x0198, 0x0197, 0x0195, 0x0194, 0x0193, 0x0192, 0x0190, 0x018f, 0x018e, 0x018d, 0x018b, 0x018a, 0x0189, 0x0188, 0x0187, 0x0186, + 0x0184, 0x0183, 0x0182, 0x0181, 0x0180, 0x017f, 0x017e, 0x017d, 0x017b, 0x017a, 0x0179, 0x0178, 0x0177, 0x0176, 0x0175, 0x0174, + 0x0173, 0x0172, 0x0171, 0x0170, 0x016f, 0x016e, 0x016d, 0x016c, 0x016b, 0x016a, 0x0169, 0x0168, 0x0167, 0x0166, 0x0165, 0x0164, + 0x0163, 0x0162, 0x0161, 0x0160, 0x015f, 0x015e, 0x015d, 0x015c, 0x015b, 0x015a, 0x0159, 0x0158, 0x0158, 0x0157, 0x0156, 0x0155, + 0x0154, 0x0153, 0x0152, 0x0151, 0x0150, 0x0150, 0x014f, 0x014e, 0x014d, 0x014c, 0x014b, 0x014a, 0x014a, 0x0149, 0x0148, 0x0147, + 0x0146, 0x0146, 0x0145, 0x0144, 0x0143, 0x0142, 0x0142, 0x0141, 0x0140, 0x013f, 0x013e, 0x013e, 0x013d, 0x013c, 0x013b, 0x013b, + 0x013a, 0x0139, 0x0138, 0x0138, 0x0137, 0x0136, 0x0135, 0x0135, 0x0134, 0x0133, 0x0132, 0x0132, 0x0131, 0x0130, 0x0130, 0x012f, + 0x012e, 0x012e, 0x012d, 0x012c, 0x012b, 0x012b, 0x012a, 0x0129, 0x0129, 0x0128, 0x0127, 0x0127, 0x0126, 0x0125, 0x0125, 0x0124, + 0x0123, 0x0123, 0x0122, 0x0121, 0x0121, 0x0120, 0x0120, 0x011f, 0x011e, 0x011e, 0x011d, 0x011c, 0x011c, 0x011b, 0x011b, 0x011a, + 0x0119, 0x0119, 0x0118, 0x0118, 0x0117, 0x0116, 0x0116, 0x0115, 0x0115, 0x0114, 0x0113, 0x0113, 0x0112, 0x0112, 0x0111, 0x0111, + 0x0110, 0x010f, 0x010f, 0x010e, 0x010e, 0x010d, 0x010d, 0x010c, 0x010c, 0x010b, 0x010a, 0x010a, 0x0109, 0x0109, 0x0108, 0x0108, + 0x0107, 0x0107, 0x0106, 0x0106, 0x0105, 0x0105, 0x0104, 0x0104, 0x0103, 0x0103, 0x0102, 0x0102, 0x0101, 0x0101, 0x0100, 0x0100, + 0x00ff, 0x00ff, 0x00fe, 0x00fe, 0x00fd, 0x00fd, 0x00fc, 0x00fc, 0x00fb, 0x00fb, 0x00fa, 0x00fa, 0x00f9, 0x00f9, 0x00f8, 0x00f8, + 0x00f7, 0x00f7, 0x00f6, 0x00f6, 0x00f5, 0x00f5, 0x00f4, 0x00f4, 0x00f4, 0x00f3, 0x00f3, 0x00f2, 0x00f2, 0x00f1, 0x00f1, 0x00f0, + 0x00f0, 0x00f0, 0x00ef, 0x00ef, 0x00ee, 0x00ee, 0x00ed, 0x00ed, 0x00ed, 0x00ec, 0x00ec, 0x00eb, 0x00eb, 0x00ea, 0x00ea, 0x00ea, + 0x00e9, 0x00e9, 0x00e8, 0x00e8, 0x00e7, 0x00e7, 0x00e7, 0x00e6, 0x00e6, 0x00e5, 0x00e5, 0x00e5, 0x00e4, 0x00e4, 0x00e3, 0x00e3, + 0x00e3, 0x00e2, 0x00e2, 0x00e1, 0x00e1, 0x00e1, 0x00e0, 0x00e0, 0x00e0, 0x00df, 0x00df, 0x00de, 0x00de, 0x00de, 0x00dd, 0x00dd, + 0x00dd, 0x00dc, 0x00dc, 0x00db, 0x00db, 0x00db, 0x00da, 0x00da, 0x00da, 0x00d9, 0x00d9, 0x00d9, 0x00d8, 0x00d8, 0x00d7, 0x00d7, + 0x00d7, 0x00d6, 0x00d6, 0x00d6, 0x00d5, 0x00d5, 0x00d5, 0x00d4, 0x00d4, 0x00d4, 0x00d3, 0x00d3, 0x00d3, 0x00d2, 0x00d2, 0x00d2, + 0x00d1, 0x00d1, 0x00d1, 0x00d0, 0x00d0, 0x00d0, 0x00cf, 0x00cf, 0x00cf, 0x00ce, 0x00ce, 0x00ce, 0x00cd, 0x00cd, 0x00cd, 0x00cc, + 0x00cc, 0x00cc, 0x00cb, 0x00cb, 0x00cb, 0x00ca, 0x00ca, 0x00ca, 0x00c9, 0x00c9, 0x00c9, 0x00c9, 0x00c8, 0x00c8, 0x00c8, 0x00c7, + 0x00c7, 0x00c7, 0x00c6, 0x00c6, 0x00c6, 0x00c5, 0x00c5, 0x00c5, 0x00c5, 0x00c4, 0x00c4, 0x00c4, 0x00c3, 0x00c3, 0x00c3, 0x00c3, + 0x00c2, 0x00c2, 0x00c2, 0x00c1, 0x00c1, 0x00c1, 0x00c1, 0x00c0, 0x00c0, 0x00c0, 0x00bf, 0x00bf, 0x00bf, 0x00bf, 0x00be, 0x00be, + 0x00be, 0x00bd, 0x00bd, 0x00bd, 0x00bd, 0x00bc, 0x00bc, 0x00bc, 0x00bc, 0x00bb, 0x00bb, 0x00bb, 0x00ba, 0x00ba, 0x00ba, 0x00ba, + 0x00b9, 0x00b9, 0x00b9, 0x00b9, 0x00b8, 0x00b8, 0x00b8, 0x00b8, 0x00b7, 0x00b7, 0x00b7, 0x00b7, 0x00b6, 0x00b6, 0x00b6, 0x00b6, + 0x00b5, 0x00b5, 0x00b5, 0x00b5, 0x00b4, 0x00b4, 0x00b4, 0x00b4, 0x00b3, 0x00b3, 0x00b3, 0x00b3, 0x00b2, 0x00b2, 0x00b2, 0x00b2, + 0x00b1, 0x00b1, 0x00b1, 0x00b1, 0x00b0, 0x00b0, 0x00b0, 0x00b0, 0x00af, 0x00af, 0x00af, 0x00af, 0x00ae, 0x00ae, 0x00ae, 0x00ae, + 0x00ae, 0x00ad, 0x00ad, 0x00ad, 0x00ad, 0x00ac, 0x00ac, 0x00ac, 0x00ac, 0x00ac, 0x00ab, 0x00ab, 0x00ab, 0x00ab, +}; + +static const uint16_t DivTableAlpha[256] = { + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xe38e, 0xcccc, 0xba2e, 0xaaaa, 0x9d89, 0x9249, 0x8888, 0x8000, + 0x7878, 0x71c7, 0x6bca, 0x6666, 0x6186, 0x5d17, 0x590b, 0x5555, 0x51eb, 0x4ec4, 0x4bda, 0x4924, 0x469e, 0x4444, 0x4210, 0x4000, + 0x3e0f, 0x3c3c, 0x3a83, 0x38e3, 0x3759, 0x35e5, 0x3483, 0x3333, 0x31f3, 0x30c3, 0x2fa0, 0x2e8b, 0x2d82, 0x2c85, 0x2b93, 0x2aaa, + 0x29cb, 0x28f5, 0x2828, 0x2762, 0x26a4, 0x25ed, 0x253c, 0x2492, 0x23ee, 0x234f, 0x22b6, 0x2222, 0x2192, 0x2108, 0x2082, 0x2000, + 0x1f81, 0x1f07, 0x1e91, 0x1e1e, 0x1dae, 0x1d41, 0x1cd8, 0x1c71, 0x1c0e, 0x1bac, 0x1b4e, 0x1af2, 0x1a98, 0x1a41, 0x19ec, 0x1999, + 0x1948, 0x18f9, 0x18ac, 0x1861, 0x1818, 0x17d0, 0x178a, 0x1745, 0x1702, 0x16c1, 0x1681, 0x1642, 0x1605, 0x15c9, 0x158e, 0x1555, + 0x151d, 0x14e5, 0x14af, 0x147a, 0x1446, 0x1414, 0x13e2, 0x13b1, 0x1381, 0x1352, 0x1323, 0x12f6, 0x12c9, 0x129e, 0x1273, 0x1249, + 0x121f, 0x11f7, 0x11cf, 0x11a7, 0x1181, 0x115b, 0x1135, 0x1111, 0x10ec, 0x10c9, 0x10a6, 0x1084, 0x1062, 0x1041, 0x1020, 0x1000, + 0x0fe0, 0x0fc0, 0x0fa2, 0x0f83, 0x0f66, 0x0f48, 0x0f2b, 0x0f0f, 0x0ef2, 0x0ed7, 0x0ebb, 0x0ea0, 0x0e86, 0x0e6c, 0x0e52, 0x0e38, + 0x0e1f, 0x0e07, 0x0dee, 0x0dd6, 0x0dbe, 0x0da7, 0x0d90, 0x0d79, 0x0d62, 0x0d4c, 0x0d36, 0x0d20, 0x0d0b, 0x0cf6, 0x0ce1, 0x0ccc, + 0x0cb8, 0x0ca4, 0x0c90, 0x0c7c, 0x0c69, 0x0c56, 0x0c43, 0x0c30, 0x0c1e, 0x0c0c, 0x0bfa, 0x0be8, 0x0bd6, 0x0bc5, 0x0bb3, 0x0ba2, + 0x0b92, 0x0b81, 0x0b70, 0x0b60, 0x0b50, 0x0b40, 0x0b30, 0x0b21, 0x0b11, 0x0b02, 0x0af3, 0x0ae4, 0x0ad6, 0x0ac7, 0x0ab8, 0x0aaa, + 0x0a9c, 0x0a8e, 0x0a80, 0x0a72, 0x0a65, 0x0a57, 0x0a4a, 0x0a3d, 0x0a30, 0x0a23, 0x0a16, 0x0a0a, 0x09fd, 0x09f1, 0x09e4, 0x09d8, + 0x09cc, 0x09c0, 0x09b4, 0x09a9, 0x099d, 0x0991, 0x0986, 0x097b, 0x0970, 0x0964, 0x095a, 0x094f, 0x0944, 0x0939, 0x092f, 0x0924, + 0x091a, 0x090f, 0x0905, 0x08fb, 0x08f1, 0x08e7, 0x08dd, 0x08d3, 0x08ca, 0x08c0, 0x08b7, 0x08ad, 0x08a4, 0x089a, 0x0891, 0x0888, + 0x087f, 0x0876, 0x086d, 0x0864, 0x085b, 0x0853, 0x084a, 0x0842, 0x0839, 0x0831, 0x0828, 0x0820, 0x0818, 0x0810, 0x0808, 0x0800, +}; + +static etcpak_force_inline uint64_t ProcessRGB( const uint8_t* src ) +{ +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128(((__m128i*)src) + 0); + __m128i px1 = _mm_loadu_si128(((__m128i*)src) + 1); + __m128i px2 = _mm_loadu_si128(((__m128i*)src) + 2); + __m128i px3 = _mm_loadu_si128(((__m128i*)src) + 3); + + __m128i smask = _mm_set1_epi32( 0xF8FCF8 ); + __m128i sd0 = _mm_and_si128( px0, smask ); + __m128i sd1 = _mm_and_si128( px1, smask ); + __m128i sd2 = _mm_and_si128( px2, smask ); + __m128i sd3 = _mm_and_si128( px3, smask ); + + __m128i sc = _mm_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m128i sc0 = _mm_cmpeq_epi8(sd0, sc); + __m128i sc1 = _mm_cmpeq_epi8(sd1, sc); + __m128i sc2 = _mm_cmpeq_epi8(sd2, sc); + __m128i sc3 = _mm_cmpeq_epi8(sd3, sc); + + __m128i sm0 = _mm_and_si128(sc0, sc1); + __m128i sm1 = _mm_and_si128(sc2, sc3); + __m128i sm = _mm_and_si128(sm0, sm1); + + if( _mm_testc_si128(sm, _mm_set1_epi32(-1)) ) + { + uint32_t c; + memcpy( &c, src, 4 ); + return uint64_t( to565( c ) ) << 16; + } + + __m128i min0 = _mm_min_epu8( px0, px1 ); + __m128i min1 = _mm_min_epu8( px2, px3 ); + __m128i min2 = _mm_min_epu8( min0, min1 ); + + __m128i max0 = _mm_max_epu8( px0, px1 ); + __m128i max1 = _mm_max_epu8( px2, px3 ); + __m128i max2 = _mm_max_epu8( max0, max1 ); + + __m128i min3 = _mm_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i max3 = _mm_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i min4 = _mm_min_epu8( min2, min3 ); + __m128i max4 = _mm_max_epu8( max2, max3 ); + + __m128i min5 = _mm_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i max5 = _mm_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i rmin = _mm_min_epu8( min4, min5 ); + __m128i rmax = _mm_max_epu8( max4, max5 ); + + __m128i range1 = _mm_subs_epu8( rmax, rmin ); + __m128i range2 = _mm_sad_epu8( rmax, rmin ); + + uint32_t vrange = _mm_cvtsi128_si32( range2 ) >> 1; + __m128i range = _mm_set1_epi16( DivTable[vrange] ); + + __m128i inset1 = _mm_srli_epi16( range1, 4 ); + __m128i inset = _mm_and_si128( inset1, _mm_set1_epi8( 0xF ) ); + __m128i min = _mm_adds_epu8( rmin, inset ); + __m128i max = _mm_subs_epu8( rmax, inset ); + + __m128i c0 = _mm_subs_epu8( px0, rmin ); + __m128i c1 = _mm_subs_epu8( px1, rmin ); + __m128i c2 = _mm_subs_epu8( px2, rmin ); + __m128i c3 = _mm_subs_epu8( px3, rmin ); + + __m128i is0 = _mm_maddubs_epi16( c0, _mm_set1_epi8( 1 ) ); + __m128i is1 = _mm_maddubs_epi16( c1, _mm_set1_epi8( 1 ) ); + __m128i is2 = _mm_maddubs_epi16( c2, _mm_set1_epi8( 1 ) ); + __m128i is3 = _mm_maddubs_epi16( c3, _mm_set1_epi8( 1 ) ); + + __m128i s0 = _mm_hadd_epi16( is0, is1 ); + __m128i s1 = _mm_hadd_epi16( is2, is3 ); + + __m128i m0 = _mm_mulhi_epu16( s0, range ); + __m128i m1 = _mm_mulhi_epu16( s1, range ); + + __m128i p0 = _mm_packus_epi16( m0, m1 ); + + __m128i p1 = _mm_or_si128( _mm_srai_epi32( p0, 6 ), _mm_srai_epi32( p0, 12 ) ); + __m128i p2 = _mm_or_si128( _mm_srai_epi32( p0, 18 ), p0 ); + __m128i p3 = _mm_or_si128( p1, p2 ); + __m128i p =_mm_shuffle_epi8( p3, _mm_set1_epi32( 0x0C080400 ) ); + + uint32_t vmin = _mm_cvtsi128_si32( min ); + uint32_t vmax = _mm_cvtsi128_si32( max ); + uint32_t vp = _mm_cvtsi128_si32( p ); + + return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); +#elif defined __ARM_NEON +# ifdef __aarch64__ + uint8x16x4_t px = vld4q_u8( src ); + + uint8x16_t lr = px.val[0]; + uint8x16_t lg = px.val[1]; + uint8x16_t lb = px.val[2]; + + uint8_t rmaxr = vmaxvq_u8( lr ); + uint8_t rmaxg = vmaxvq_u8( lg ); + uint8_t rmaxb = vmaxvq_u8( lb ); + + uint8_t rminr = vminvq_u8( lr ); + uint8_t rming = vminvq_u8( lg ); + uint8_t rminb = vminvq_u8( lb ); + + int rr = rmaxr - rminr; + int rg = rmaxg - rming; + int rb = rmaxb - rminb; + + int vrange1 = rr + rg + rb; + uint16_t vrange2 = DivTableNEON[vrange1]; + + uint8_t insetr = rr >> 4; + uint8_t insetg = rg >> 4; + uint8_t insetb = rb >> 4; + + uint8_t minr = rminr + insetr; + uint8_t ming = rming + insetg; + uint8_t minb = rminb + insetb; + + uint8_t maxr = rmaxr - insetr; + uint8_t maxg = rmaxg - insetg; + uint8_t maxb = rmaxb - insetb; + + uint8x16_t cr = vsubq_u8( lr, vdupq_n_u8( rminr ) ); + uint8x16_t cg = vsubq_u8( lg, vdupq_n_u8( rming ) ); + uint8x16_t cb = vsubq_u8( lb, vdupq_n_u8( rminb ) ); + + uint16x8_t is0l = vaddl_u8( vget_low_u8( cr ), vget_low_u8( cg ) ); + uint16x8_t is0h = vaddl_u8( vget_high_u8( cr ), vget_high_u8( cg ) ); + uint16x8_t is1l = vaddw_u8( is0l, vget_low_u8( cb ) ); + uint16x8_t is1h = vaddw_u8( is0h, vget_high_u8( cb ) ); + + int16x8_t range = vdupq_n_s16( vrange2 ); + uint16x8_t m0 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( is1l ), range ) ); + uint16x8_t m1 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( is1h ), range ) ); + + uint8x8_t p00 = vmovn_u16( m0 ); + uint8x8_t p01 = vmovn_u16( m1 ); + uint8x16_t p0 = vcombine_u8( p00, p01 ); + + uint32x4_t p1 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 6 ), vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 12 ) ); + uint32x4_t p2 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 18 ), vreinterpretq_u32_u8( p0 ) ); + uint32x4_t p3 = vaddq_u32( p1, p2 ); + + uint16x4x2_t p4 = vuzp_u16( vget_low_u16( vreinterpretq_u16_u32( p3 ) ), vget_high_u16( vreinterpretq_u16_u32( p3 ) ) ); + uint8x8x2_t p = vuzp_u8( vreinterpret_u8_u16( p4.val[0] ), vreinterpret_u8_u16( p4.val[0] ) ); + + uint32_t vp; + vst1_lane_u32( &vp, vreinterpret_u32_u8( p.val[0] ), 0 ); + + return uint64_t( ( uint64_t( to565( minr, ming, minb ) ) << 16 ) | to565( maxr, maxg, maxb ) | ( uint64_t( vp ) << 32 ) ); +# else + uint32x4_t px0 = vld1q_u32( (uint32_t*)src ); + uint32x4_t px1 = vld1q_u32( (uint32_t*)src + 4 ); + uint32x4_t px2 = vld1q_u32( (uint32_t*)src + 8 ); + uint32x4_t px3 = vld1q_u32( (uint32_t*)src + 12 ); + + uint32x4_t smask = vdupq_n_u32( 0xF8FCF8 ); + uint32x4_t sd0 = vandq_u32( smask, px0 ); + uint32x4_t sd1 = vandq_u32( smask, px1 ); + uint32x4_t sd2 = vandq_u32( smask, px2 ); + uint32x4_t sd3 = vandq_u32( smask, px3 ); + + uint32x4_t sc = vdupq_n_u32( sd0[0] ); + + uint32x4_t sc0 = vceqq_u32( sd0, sc ); + uint32x4_t sc1 = vceqq_u32( sd1, sc ); + uint32x4_t sc2 = vceqq_u32( sd2, sc ); + uint32x4_t sc3 = vceqq_u32( sd3, sc ); + + uint32x4_t sm0 = vandq_u32( sc0, sc1 ); + uint32x4_t sm1 = vandq_u32( sc2, sc3 ); + int64x2_t sm = vreinterpretq_s64_u32( vandq_u32( sm0, sm1 ) ); + + if( sm[0] == -1 && sm[1] == -1 ) + { + return uint64_t( to565( src[0], src[1], src[2] ) ) << 16; + } + + uint32x4_t mask = vdupq_n_u32( 0xFFFFFF ); + uint8x16_t l0 = vreinterpretq_u8_u32( vandq_u32( mask, px0 ) ); + uint8x16_t l1 = vreinterpretq_u8_u32( vandq_u32( mask, px1 ) ); + uint8x16_t l2 = vreinterpretq_u8_u32( vandq_u32( mask, px2 ) ); + uint8x16_t l3 = vreinterpretq_u8_u32( vandq_u32( mask, px3 ) ); + + uint8x16_t min0 = vminq_u8( l0, l1 ); + uint8x16_t min1 = vminq_u8( l2, l3 ); + uint8x16_t min2 = vminq_u8( min0, min1 ); + + uint8x16_t max0 = vmaxq_u8( l0, l1 ); + uint8x16_t max1 = vmaxq_u8( l2, l3 ); + uint8x16_t max2 = vmaxq_u8( max0, max1 ); + + uint8x16_t min3 = vreinterpretq_u8_u32( vrev64q_u32( vreinterpretq_u32_u8( min2 ) ) ); + uint8x16_t max3 = vreinterpretq_u8_u32( vrev64q_u32( vreinterpretq_u32_u8( max2 ) ) ); + + uint8x16_t min4 = vminq_u8( min2, min3 ); + uint8x16_t max4 = vmaxq_u8( max2, max3 ); + + uint8x16_t min5 = vcombine_u8( vget_high_u8( min4 ), vget_low_u8( min4 ) ); + uint8x16_t max5 = vcombine_u8( vget_high_u8( max4 ), vget_low_u8( max4 ) ); + + uint8x16_t rmin = vminq_u8( min4, min5 ); + uint8x16_t rmax = vmaxq_u8( max4, max5 ); + + uint8x16_t range1 = vsubq_u8( rmax, rmin ); + uint8x8_t range2 = vget_low_u8( range1 ); + uint8x8x2_t range3 = vzip_u8( range2, vdup_n_u8( 0 ) ); + uint16x4_t range4 = vreinterpret_u16_u8( range3.val[0] ); + + uint16_t vrange1; + uint16x4_t range5 = vpadd_u16( range4, range4 ); + uint16x4_t range6 = vpadd_u16( range5, range5 ); + vst1_lane_u16( &vrange1, range6, 0 ); + + uint32_t vrange2 = ( 2 << 16 ) / uint32_t( vrange1 + 1 ); + uint16x8_t range = vdupq_n_u16( vrange2 ); + + uint8x16_t inset = vshrq_n_u8( range1, 4 ); + uint8x16_t min = vaddq_u8( rmin, inset ); + uint8x16_t max = vsubq_u8( rmax, inset ); + + uint8x16_t c0 = vsubq_u8( l0, rmin ); + uint8x16_t c1 = vsubq_u8( l1, rmin ); + uint8x16_t c2 = vsubq_u8( l2, rmin ); + uint8x16_t c3 = vsubq_u8( l3, rmin ); + + uint16x8_t is0 = vpaddlq_u8( c0 ); + uint16x8_t is1 = vpaddlq_u8( c1 ); + uint16x8_t is2 = vpaddlq_u8( c2 ); + uint16x8_t is3 = vpaddlq_u8( c3 ); + + uint16x4_t is4 = vpadd_u16( vget_low_u16( is0 ), vget_high_u16( is0 ) ); + uint16x4_t is5 = vpadd_u16( vget_low_u16( is1 ), vget_high_u16( is1 ) ); + uint16x4_t is6 = vpadd_u16( vget_low_u16( is2 ), vget_high_u16( is2 ) ); + uint16x4_t is7 = vpadd_u16( vget_low_u16( is3 ), vget_high_u16( is3 ) ); + + uint16x8_t s0 = vcombine_u16( is4, is5 ); + uint16x8_t s1 = vcombine_u16( is6, is7 ); + + uint16x8_t m0 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( s0 ), vreinterpretq_s16_u16( range ) ) ); + uint16x8_t m1 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( s1 ), vreinterpretq_s16_u16( range ) ) ); + + uint8x8_t p00 = vmovn_u16( m0 ); + uint8x8_t p01 = vmovn_u16( m1 ); + uint8x16_t p0 = vcombine_u8( p00, p01 ); + + uint32x4_t p1 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 6 ), vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 12 ) ); + uint32x4_t p2 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 18 ), vreinterpretq_u32_u8( p0 ) ); + uint32x4_t p3 = vaddq_u32( p1, p2 ); + + uint16x4x2_t p4 = vuzp_u16( vget_low_u16( vreinterpretq_u16_u32( p3 ) ), vget_high_u16( vreinterpretq_u16_u32( p3 ) ) ); + uint8x8x2_t p = vuzp_u8( vreinterpret_u8_u16( p4.val[0] ), vreinterpret_u8_u16( p4.val[0] ) ); + + uint32_t vmin, vmax, vp; + vst1q_lane_u32( &vmin, vreinterpretq_u32_u8( min ), 0 ); + vst1q_lane_u32( &vmax, vreinterpretq_u32_u8( max ), 0 ); + vst1_lane_u32( &vp, vreinterpret_u32_u8( p.val[0] ), 0 ); + + return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); +# endif +#else + uint32_t ref; + memcpy( &ref, src, 4 ); + uint32_t refMask = ref & 0xF8FCF8; + auto stmp = src + 4; + for( int i=1; i<16; i++ ) + { + uint32_t px; + memcpy( &px, stmp, 4 ); + if( ( px & 0xF8FCF8 ) != refMask ) break; + stmp += 4; + } + if( stmp == src + 64 ) + { + return uint64_t( to565( ref ) ) << 16; + } + + uint8_t min[3] = { src[0], src[1], src[2] }; + uint8_t max[3] = { src[0], src[1], src[2] }; + auto tmp = src + 4; + for( int i=1; i<16; i++ ) + { + for( int j=0; j<3; j++ ) + { + if( tmp[j] < min[j] ) min[j] = tmp[j]; + else if( tmp[j] > max[j] ) max[j] = tmp[j]; + } + tmp += 4; + } + + const uint32_t range = DivTable[max[0] - min[0] + max[1] - min[1] + max[2] - min[2]]; + const uint32_t rmin = min[0] + min[1] + min[2]; + for( int i=0; i<3; i++ ) + { + const uint8_t inset = ( max[i] - min[i] ) >> 4; + min[i] += inset; + max[i] -= inset; + } + + uint32_t data = 0; + for( int i=0; i<16; i++ ) + { + const uint32_t c = src[0] + src[1] + src[2] - rmin; + const uint8_t idx = ( c * range ) >> 16; + data |= idx << (i*2); + src += 4; + } + + return uint64_t( ( uint64_t( to565( min[0], min[1], min[2] ) ) << 16 ) | to565( max[0], max[1], max[2] ) | ( uint64_t( data ) << 32 ) ); +#endif +} + +#ifdef __AVX2__ +static etcpak_force_inline void ProcessRGB_AVX( const uint8_t* src, char*& dst ) +{ + __m256i px0 = _mm256_loadu_si256(((__m256i*)src) + 0); + __m256i px1 = _mm256_loadu_si256(((__m256i*)src) + 1); + __m256i px2 = _mm256_loadu_si256(((__m256i*)src) + 2); + __m256i px3 = _mm256_loadu_si256(((__m256i*)src) + 3); + + __m256i smask = _mm256_set1_epi32( 0xF8FCF8 ); + __m256i sd0 = _mm256_and_si256( px0, smask ); + __m256i sd1 = _mm256_and_si256( px1, smask ); + __m256i sd2 = _mm256_and_si256( px2, smask ); + __m256i sd3 = _mm256_and_si256( px3, smask ); + + __m256i sc = _mm256_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m256i sc0 = _mm256_cmpeq_epi8(sd0, sc); + __m256i sc1 = _mm256_cmpeq_epi8(sd1, sc); + __m256i sc2 = _mm256_cmpeq_epi8(sd2, sc); + __m256i sc3 = _mm256_cmpeq_epi8(sd3, sc); + + __m256i sm0 = _mm256_and_si256(sc0, sc1); + __m256i sm1 = _mm256_and_si256(sc2, sc3); + __m256i sm = _mm256_and_si256(sm0, sm1); + + const int64_t solid0 = 1 - _mm_testc_si128( _mm256_castsi256_si128( sm ), _mm_set1_epi32( -1 ) ); + const int64_t solid1 = 1 - _mm_testc_si128( _mm256_extracti128_si256( sm, 1 ), _mm_set1_epi32( -1 ) ); + + if( solid0 + solid1 == 0 ) + { + const auto c0 = uint64_t( to565( src[0], src[1], src[2] ) ); + const auto c1 = uint64_t( to565( src[16], src[17], src[18] ) ); + memcpy( dst, &c0, 8 ); + memcpy( dst+8, &c1, 8 ); + dst += 16; + return; + } + + __m256i min0 = _mm256_min_epu8( px0, px1 ); + __m256i min1 = _mm256_min_epu8( px2, px3 ); + __m256i min2 = _mm256_min_epu8( min0, min1 ); + + __m256i max0 = _mm256_max_epu8( px0, px1 ); + __m256i max1 = _mm256_max_epu8( px2, px3 ); + __m256i max2 = _mm256_max_epu8( max0, max1 ); + + __m256i min3 = _mm256_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m256i max3 = _mm256_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m256i min4 = _mm256_min_epu8( min2, min3 ); + __m256i max4 = _mm256_max_epu8( max2, max3 ); + + __m256i min5 = _mm256_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m256i max5 = _mm256_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m256i rmin = _mm256_min_epu8( min4, min5 ); + __m256i rmax = _mm256_max_epu8( max4, max5 ); + + __m256i range1 = _mm256_subs_epu8( rmax, rmin ); + __m256i range2 = _mm256_sad_epu8( rmax, rmin ); + + uint16_t vrange0 = DivTable[_mm256_cvtsi256_si32( range2 ) >> 1]; + uint16_t vrange1 = DivTable[_mm256_extract_epi16( range2, 8 ) >> 1]; + __m256i range00 = _mm256_set1_epi16( vrange0 ); + __m256i range = _mm256_inserti128_si256( range00, _mm_set1_epi16( vrange1 ), 1 ); + + __m256i inset1 = _mm256_srli_epi16( range1, 4 ); + __m256i inset = _mm256_and_si256( inset1, _mm256_set1_epi8( 0xF ) ); + __m256i min = _mm256_adds_epu8( rmin, inset ); + __m256i max = _mm256_subs_epu8( rmax, inset ); + + __m256i c0 = _mm256_subs_epu8( px0, rmin ); + __m256i c1 = _mm256_subs_epu8( px1, rmin ); + __m256i c2 = _mm256_subs_epu8( px2, rmin ); + __m256i c3 = _mm256_subs_epu8( px3, rmin ); + + __m256i is0 = _mm256_maddubs_epi16( c0, _mm256_set1_epi8( 1 ) ); + __m256i is1 = _mm256_maddubs_epi16( c1, _mm256_set1_epi8( 1 ) ); + __m256i is2 = _mm256_maddubs_epi16( c2, _mm256_set1_epi8( 1 ) ); + __m256i is3 = _mm256_maddubs_epi16( c3, _mm256_set1_epi8( 1 ) ); + + __m256i s0 = _mm256_hadd_epi16( is0, is1 ); + __m256i s1 = _mm256_hadd_epi16( is2, is3 ); + + __m256i m0 = _mm256_mulhi_epu16( s0, range ); + __m256i m1 = _mm256_mulhi_epu16( s1, range ); + + __m256i p0 = _mm256_packus_epi16( m0, m1 ); + + __m256i p1 = _mm256_or_si256( _mm256_srai_epi32( p0, 6 ), _mm256_srai_epi32( p0, 12 ) ); + __m256i p2 = _mm256_or_si256( _mm256_srai_epi32( p0, 18 ), p0 ); + __m256i p3 = _mm256_or_si256( p1, p2 ); + __m256i p =_mm256_shuffle_epi8( p3, _mm256_set1_epi32( 0x0C080400 ) ); + + __m256i mm0 = _mm256_unpacklo_epi8( _mm256_setzero_si256(), min ); + __m256i mm1 = _mm256_unpacklo_epi8( _mm256_setzero_si256(), max ); + __m256i mm2 = _mm256_unpacklo_epi64( mm1, mm0 ); + __m256i mmr = _mm256_slli_epi64( _mm256_srli_epi64( mm2, 11 ), 11 ); + __m256i mmg = _mm256_slli_epi64( _mm256_srli_epi64( mm2, 26 ), 5 ); + __m256i mmb = _mm256_srli_epi64( _mm256_slli_epi64( mm2, 16 ), 59 ); + __m256i mm3 = _mm256_or_si256( mmr, mmg ); + __m256i mm4 = _mm256_or_si256( mm3, mmb ); + __m256i mm5 = _mm256_shuffle_epi8( mm4, _mm256_set1_epi32( 0x09080100 ) ); + + __m256i d0 = _mm256_unpacklo_epi32( mm5, p ); + __m256i d1 = _mm256_permute4x64_epi64( d0, _MM_SHUFFLE( 3, 2, 2, 0 ) ); + __m128i d2 = _mm256_castsi256_si128( d1 ); + + __m128i mask = _mm_set_epi64x( 0xFFFF0000 | -solid1, 0xFFFF0000 | -solid0 ); + __m128i d3 = _mm_and_si128( d2, mask ); + + __m128i x0 = _mm_andnot_si128( d3, _mm_set1_epi32( 0x55555555 ) ); + __m128i x1 = _mm_andnot_si128( d3, _mm_set1_epi32( 0xAAAAAAAA ) ); + __m128i x2 = _mm_slli_epi32( x0, 1 ); + __m128i x3 = _mm_srli_epi32( x1, 1 ); + __m128i x4 = _mm_xor_si128( x1, x2 ); + __m128i x5 = _mm_or_si128( x3, x4 ); + __m128i x6 = _mm_and_si128( d3, _mm_set1_epi64x( 0xFFFFFFFF ) ); + __m128i x7 = _mm_and_si128( x5, _mm_set1_epi64x( 0xFFFFFFFF00000000 ) ); + __m128i x8 = _mm_or_si128( x6, x7 ); + + _mm_storeu_si128( (__m128i*)dst, x8 ); + dst += 16; +} +#endif + +static const uint8_t AlphaIndexTable[8] = { 1, 7, 6, 5, 4, 3, 2, 0 }; + +static etcpak_force_inline uint64_t ProcessAlpha( const uint8_t* src ) +{ + uint8_t solid8 = *src; + uint16_t solid16 = uint16_t( solid8 ) | ( uint16_t( solid8 ) << 8 ); + uint32_t solid32 = uint32_t( solid16 ) | ( uint32_t( solid16 ) << 16 ); + uint64_t solid64 = uint64_t( solid32 ) | ( uint64_t( solid32 ) << 32 ); + if( memcmp( src, &solid64, 8 ) == 0 && memcmp( src+8, &solid64, 8 ) == 0 ) + { + return solid8; + } + + uint8_t min = src[0]; + uint8_t max = min; + for( int i=1; i<16; i++ ) + { + const auto v = src[i]; + if( v > max ) max = v; + else if( v < min ) min = v; + } + + uint32_t range = ( 8 << 13 ) / ( 1 + max - min ); + uint64_t data = 0; + for( int i=0; i<16; i++ ) + { + uint8_t a = src[i] - min; + uint64_t idx = AlphaIndexTable[( a * range ) >> 13]; + data |= idx << (i*3); + } + + return max | ( min << 8 ) | ( data << 16 ); +} + +#ifdef __SSE4_1__ +static etcpak_force_inline uint64_t ProcessRGB_SSE( __m128i px0, __m128i px1, __m128i px2, __m128i px3 ) +{ + __m128i smask = _mm_set1_epi32( 0xF8FCF8 ); + __m128i sd0 = _mm_and_si128( px0, smask ); + __m128i sd1 = _mm_and_si128( px1, smask ); + __m128i sd2 = _mm_and_si128( px2, smask ); + __m128i sd3 = _mm_and_si128( px3, smask ); + + __m128i sc = _mm_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m128i sc0 = _mm_cmpeq_epi8(sd0, sc); + __m128i sc1 = _mm_cmpeq_epi8(sd1, sc); + __m128i sc2 = _mm_cmpeq_epi8(sd2, sc); + __m128i sc3 = _mm_cmpeq_epi8(sd3, sc); + + __m128i sm0 = _mm_and_si128(sc0, sc1); + __m128i sm1 = _mm_and_si128(sc2, sc3); + __m128i sm = _mm_and_si128(sm0, sm1); + + if( _mm_testc_si128(sm, _mm_set1_epi32(-1)) ) + { + return uint64_t( to565( _mm_cvtsi128_si32( px0 ) ) ) << 16; + } + + px0 = _mm_and_si128( px0, _mm_set1_epi32( 0xFFFFFF ) ); + px1 = _mm_and_si128( px1, _mm_set1_epi32( 0xFFFFFF ) ); + px2 = _mm_and_si128( px2, _mm_set1_epi32( 0xFFFFFF ) ); + px3 = _mm_and_si128( px3, _mm_set1_epi32( 0xFFFFFF ) ); + + __m128i min0 = _mm_min_epu8( px0, px1 ); + __m128i min1 = _mm_min_epu8( px2, px3 ); + __m128i min2 = _mm_min_epu8( min0, min1 ); + + __m128i max0 = _mm_max_epu8( px0, px1 ); + __m128i max1 = _mm_max_epu8( px2, px3 ); + __m128i max2 = _mm_max_epu8( max0, max1 ); + + __m128i min3 = _mm_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i max3 = _mm_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i min4 = _mm_min_epu8( min2, min3 ); + __m128i max4 = _mm_max_epu8( max2, max3 ); + + __m128i min5 = _mm_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i max5 = _mm_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i rmin = _mm_min_epu8( min4, min5 ); + __m128i rmax = _mm_max_epu8( max4, max5 ); + + __m128i range1 = _mm_subs_epu8( rmax, rmin ); + __m128i range2 = _mm_sad_epu8( rmax, rmin ); + + uint32_t vrange = _mm_cvtsi128_si32( range2 ) >> 1; + __m128i range = _mm_set1_epi16( DivTable[vrange] ); + + __m128i inset1 = _mm_srli_epi16( range1, 4 ); + __m128i inset = _mm_and_si128( inset1, _mm_set1_epi8( 0xF ) ); + __m128i min = _mm_adds_epu8( rmin, inset ); + __m128i max = _mm_subs_epu8( rmax, inset ); + + __m128i c0 = _mm_subs_epu8( px0, rmin ); + __m128i c1 = _mm_subs_epu8( px1, rmin ); + __m128i c2 = _mm_subs_epu8( px2, rmin ); + __m128i c3 = _mm_subs_epu8( px3, rmin ); + + __m128i is0 = _mm_maddubs_epi16( c0, _mm_set1_epi8( 1 ) ); + __m128i is1 = _mm_maddubs_epi16( c1, _mm_set1_epi8( 1 ) ); + __m128i is2 = _mm_maddubs_epi16( c2, _mm_set1_epi8( 1 ) ); + __m128i is3 = _mm_maddubs_epi16( c3, _mm_set1_epi8( 1 ) ); + + __m128i s0 = _mm_hadd_epi16( is0, is1 ); + __m128i s1 = _mm_hadd_epi16( is2, is3 ); + + __m128i m0 = _mm_mulhi_epu16( s0, range ); + __m128i m1 = _mm_mulhi_epu16( s1, range ); + + __m128i p0 = _mm_packus_epi16( m0, m1 ); + + __m128i p1 = _mm_or_si128( _mm_srai_epi32( p0, 6 ), _mm_srai_epi32( p0, 12 ) ); + __m128i p2 = _mm_or_si128( _mm_srai_epi32( p0, 18 ), p0 ); + __m128i p3 = _mm_or_si128( p1, p2 ); + __m128i p =_mm_shuffle_epi8( p3, _mm_set1_epi32( 0x0C080400 ) ); + + uint32_t vmin = _mm_cvtsi128_si32( min ); + uint32_t vmax = _mm_cvtsi128_si32( max ); + uint32_t vp = _mm_cvtsi128_si32( p ); + + return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); +} + +static etcpak_force_inline uint64_t ProcessOneChannel_SSE( __m128i a ) +{ + __m128i solidCmp = _mm_shuffle_epi8( a, _mm_setzero_si128() ); + __m128i cmpRes = _mm_cmpeq_epi8( a, solidCmp ); + if( _mm_testc_si128( cmpRes, _mm_set1_epi32( -1 ) ) ) + { + return _mm_cvtsi128_si32( a ) & 0xFF; + } + + __m128i a1 = _mm_shuffle_epi32( a, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i max1 = _mm_max_epu8( a, a1 ); + __m128i min1 = _mm_min_epu8( a, a1 ); + __m128i amax2 = _mm_shuffle_epi32( max1, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i amin2 = _mm_shuffle_epi32( min1, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i max2 = _mm_max_epu8( max1, amax2 ); + __m128i min2 = _mm_min_epu8( min1, amin2 ); + __m128i amax3 = _mm_alignr_epi8( max2, max2, 2 ); + __m128i amin3 = _mm_alignr_epi8( min2, min2, 2 ); + __m128i max3 = _mm_max_epu8( max2, amax3 ); + __m128i min3 = _mm_min_epu8( min2, amin3 ); + __m128i amax4 = _mm_alignr_epi8( max3, max3, 1 ); + __m128i amin4 = _mm_alignr_epi8( min3, min3, 1 ); + __m128i max = _mm_max_epu8( max3, amax4 ); + __m128i min = _mm_min_epu8( min3, amin4 ); + __m128i minmax = _mm_unpacklo_epi8( max, min ); + + __m128i r = _mm_sub_epi8( max, min ); + int range = _mm_cvtsi128_si32( r ) & 0xFF; + __m128i rv = _mm_set1_epi16( DivTableAlpha[range] ); + + __m128i v = _mm_sub_epi8( a, min ); + + __m128i lo16 = _mm_unpacklo_epi8( v, _mm_setzero_si128() ); + __m128i hi16 = _mm_unpackhi_epi8( v, _mm_setzero_si128() ); + + __m128i lomul = _mm_mulhi_epu16( lo16, rv ); + __m128i himul = _mm_mulhi_epu16( hi16, rv ); + + __m128i p0 = _mm_packus_epi16( lomul, himul ); + __m128i p1 = _mm_or_si128( _mm_and_si128( p0, _mm_set1_epi16( 0x3F ) ), _mm_srai_epi16( _mm_and_si128( p0, _mm_set1_epi16( 0x3F00 ) ), 5 ) ); + __m128i p2 = _mm_packus_epi16( p1, p1 ); + + uint64_t pi = _mm_cvtsi128_si64( p2 ); + uint64_t data = 0; + for( int i=0; i<8; i++ ) + { + uint64_t idx = AlphaIndexTable_SSE[(pi>>(i*8)) & 0x3F]; + data |= idx << (i*6); + } + return (uint64_t)(uint16_t)_mm_cvtsi128_si32( minmax ) | ( data << 16 ); +} + +static etcpak_force_inline uint64_t ProcessAlpha_SSE( __m128i px0, __m128i px1, __m128i px2, __m128i px3 ) +{ + __m128i mask = _mm_setr_epi32( 0x0f0b0703, -1, -1, -1 ); + + __m128i m0 = _mm_shuffle_epi8( px0, mask ); + __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + __m128i m4 = _mm_or_si128( m0, m1 ); + __m128i m5 = _mm_or_si128( m2, m3 ); + __m128i a = _mm_or_si128( m4, m5 ); + + return ProcessOneChannel_SSE( a ); +} +#endif + +void CompressBc1( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ +#ifdef __AVX2__ + if( width%8 == 0 ) + { + blocks /= 2; + uint32_t buf[8*4]; + int i = 0; + char* dst8 = (char*)dst; + + do + { + auto tmp = (char*)buf; + memcpy( tmp, src + width * 0, 8*4 ); + memcpy( tmp + 8*4, src + width * 1, 8*4 ); + memcpy( tmp + 16*4, src + width * 2, 8*4 ); + memcpy( tmp + 24*4, src + width * 3, 8*4 ); + src += 8; + if( ++i == width/8 ) + { + src += width * 3; + i = 0; + } + + ProcessRGB_AVX( (uint8_t*)buf, dst8 ); + } + while( --blocks ); + } + else +#endif + { + uint32_t buf[4*4]; + int i = 0; + + auto ptr = dst; + do + { + auto tmp = (char*)buf; + memcpy( tmp, src + width * 0, 4*4 ); + memcpy( tmp + 4*4, src + width * 1, 4*4 ); + memcpy( tmp + 8*4, src + width * 2, 4*4 ); + memcpy( tmp + 12*4, src + width * 3, 4*4 ); + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + const auto c = ProcessRGB( (uint8_t*)buf ); + uint8_t fix[8]; + memcpy( fix, &c, 8 ); + for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; + memcpy( ptr, fix, sizeof( uint64_t ) ); + ptr++; + } + while( --blocks ); + } +} + +void CompressBc1Dither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + uint32_t buf[4*4]; + int i = 0; + + auto ptr = dst; + do + { + auto tmp = (char*)buf; + memcpy( tmp, src + width * 0, 4*4 ); + memcpy( tmp + 4*4, src + width * 1, 4*4 ); + memcpy( tmp + 8*4, src + width * 2, 4*4 ); + memcpy( tmp + 12*4, src + width * 3, 4*4 ); + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + Dither( (uint8_t*)buf ); + + const auto c = ProcessRGB( (uint8_t*)buf ); + uint8_t fix[8]; + memcpy( fix, &c, 8 ); + for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; + memcpy( ptr, fix, sizeof( uint64_t ) ); + ptr++; + } + while( --blocks ); +} + +void CompressBc3( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int i = 0; + auto ptr = dst; + do + { +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); + __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); + __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); + __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); + + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + *ptr++ = ProcessAlpha_SSE( px0, px1, px2, px3 ); + + const auto c = ProcessRGB_SSE( px0, px1, px2, px3 ); + uint8_t fix[8]; + memcpy( fix, &c, 8 ); + for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; + memcpy( ptr, fix, sizeof( uint64_t ) ); + ptr++; +#else + uint32_t rgba[4*4]; + uint8_t alpha[4*4]; + + auto tmp = (char*)rgba; + memcpy( tmp, src + width * 0, 4*4 ); + memcpy( tmp + 4*4, src + width * 1, 4*4 ); + memcpy( tmp + 8*4, src + width * 2, 4*4 ); + memcpy( tmp + 12*4, src + width * 3, 4*4 ); + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + for( int i=0; i<16; i++ ) + { + alpha[i] = rgba[i] >> 24; + rgba[i] &= 0xFFFFFF; + } + *ptr++ = ProcessAlpha( alpha ); + + const auto c = ProcessRGB( (uint8_t*)rgba ); + uint8_t fix[8]; + memcpy( fix, &c, 8 ); + for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; + memcpy( ptr, fix, sizeof( uint64_t ) ); + ptr++; +#endif + } + while( --blocks ); +} + +void CompressBc4( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int i = 0; + auto ptr = dst; + do + { +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); + __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); + __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); + __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); + + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + __m128i mask = _mm_setr_epi32( 0x0c080400, -1, -1, -1 ); + + __m128i m0 = _mm_shuffle_epi8( px0, mask ); + __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + __m128i m4 = _mm_or_si128( m0, m1 ); + __m128i m5 = _mm_or_si128( m2, m3 ); + + *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); +#else + uint8_t r[4*4]; + auto rgba = src; + for( int i=0; i<4; i++ ) + { + r[i*4] = rgba[0] & 0xff; + r[i*4+1] = rgba[1] & 0xff; + r[i*4+2] = rgba[2] & 0xff; + r[i*4+3] = rgba[3] & 0xff; + + rgba += width; + } + + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + *ptr++ = ProcessAlpha( r ); +#endif + } while( --blocks ); +} + +void CompressBc5( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int i = 0; + auto ptr = dst; + do + { +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); + __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); + __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); + __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); + + src += 4; + if( ++i == width/4 ) + { + src += width*3; + i = 0; + } + + __m128i mask = _mm_setr_epi32( 0x0c080400, -1, -1, -1 ); + + __m128i m0 = _mm_shuffle_epi8( px0, mask ); + __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + __m128i m4 = _mm_or_si128( m0, m1 ); + __m128i m5 = _mm_or_si128( m2, m3 ); + + *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); + + mask = _mm_setr_epi32( 0x0d090501, -1, -1, -1 ); + + m0 = _mm_shuffle_epi8( px0, mask ); + m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + m4 = _mm_or_si128( m0, m1 ); + m5 = _mm_or_si128( m2, m3 ); + + *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); +#else + uint8_t rg[4*4*2]; + auto rgba = src; + for( int i=0; i<4; i++ ) + { + rg[i*4] = rgba[0] & 0xff; + rg[i*4+1] = rgba[1] & 0xff; + rg[i*4+2] = rgba[2] & 0xff; + rg[i*4+3] = rgba[3] & 0xff; + + rg[16+i*4] = (rgba[0] & 0xff00) >> 8; + rg[16+i*4+1] = (rgba[1] & 0xff00) >> 8; + rg[16+i*4+2] = (rgba[2] & 0xff00) >> 8; + rg[16+i*4+3] = (rgba[3] & 0xff00) >> 8; + + rgba += width; + } + + src += 4; + if( ++i == width/4 ) + { + src += width*3; + i = 0; + } + + *ptr++ = ProcessAlpha( rg ); + *ptr++ = ProcessAlpha( &rg[16] ); +#endif + } while( --blocks ); +} + +void CompressBc7( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, const bc7enc_compress_block_params* params ) +{ + int i = 0; + auto ptr = dst; + do + { + uint32_t rgba[4*4]; + + auto tmp = (char*)rgba; + memcpy( tmp, src + width * 0, 4*4 ); + memcpy( tmp + 4*4, src + width * 1, 4*4 ); + memcpy( tmp + 8*4, src + width * 2, 4*4 ); + memcpy( tmp + 12*4, src + width * 3, 4*4 ); + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + bc7enc_compress_block( ptr, rgba, params ); + ptr += 2; + } + while( --blocks ); +} diff --git a/lib/etcpak/etcpak/ProcessDxtc.hpp b/lib/etcpak/etcpak/ProcessDxtc.hpp new file mode 100644 index 00000000000..7655bb33bea --- /dev/null +++ b/lib/etcpak/etcpak/ProcessDxtc.hpp @@ -0,0 +1,18 @@ +#ifndef __PROCESSDXT1_HPP__ +#define __PROCESSDXT1_HPP__ + +#include +#include + +void CompressBc1( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressBc1Dither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressBc3( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); + +void CompressBc4( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressBc5( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); + +struct bc7enc_compress_block_params; + +void CompressBc7( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, const bc7enc_compress_block_params* params ); + +#endif diff --git a/lib/etcpak/etcpak/ProcessRGB.cpp b/lib/etcpak/etcpak/ProcessRGB.cpp new file mode 100644 index 00000000000..84d925771bb --- /dev/null +++ b/lib/etcpak/etcpak/ProcessRGB.cpp @@ -0,0 +1,4215 @@ +#include +#include +#include +#ifdef __ARM_NEON +# include +#endif + +#include "Dither.hpp" +#include "ForceInline.hpp" +#include "Math.hpp" +#include "ProcessCommon.hpp" +#include "ProcessRGB.hpp" +#include "Tables.hpp" +#include "Vector.hpp" + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER +# ifdef _MSC_VER +# include +# include +# define _bswap(x) _byteswap_ulong(x) +# define _bswap64(x) _byteswap_uint64(x) +# else +# include +# endif +#endif + +#ifndef _bswap +# define _bswap(x) __builtin_bswap32(x) +# define _bswap64(x) __builtin_bswap64(x) +#endif + +static const uint32_t MaxError = 1065369600; // ((38+76+14) * 255)^2 +// common T-/H-mode table +static uint8_t tableTH[8] = { 3, 6, 11, 16, 23, 32, 41, 64 }; + +// thresholds for the early compression-mode decision scheme +// default: 0.03, 0.09, and 0.38 +float ecmd_threshold[3] = { 0.03f, 0.09f, 0.38f }; + +static const uint8_t ModeUndecided = 0; +static const uint8_t ModePlanar = 0x1; +static const uint8_t ModeTH = 0x2; + +const unsigned int R = 2; +const unsigned int G = 1; +const unsigned int B = 0; + +struct Luma +{ +#ifdef __AVX2__ + float max, min; + uint8_t minIdx = 255, maxIdx = 255; + __m128i luma8; +#elif defined __ARM_NEON && defined __aarch64__ + float max, min; + uint8_t minIdx = 255, maxIdx = 255; + uint8x16_t luma8; +#else + uint8_t max = 0, min = 255, maxIdx = 0, minIdx = 0; + uint8_t val[16]; +#endif +}; + +#ifdef __AVX2__ +struct Plane +{ + uint64_t plane; + uint64_t error; + __m256i sum4; +}; +#endif + +#if defined __AVX2__ || (defined __ARM_NEON && defined __aarch64__) +struct Channels +{ +#ifdef __AVX2__ + __m128i r8, g8, b8; +#elif defined __ARM_NEON && defined __aarch64__ + uint8x16x2_t r, g, b; +#endif +}; +#endif + +namespace +{ +static etcpak_force_inline uint8_t clamp( uint8_t min, int16_t val, uint8_t max ) +{ + return val < min ? min : ( val > max ? max : val ); +} + +static etcpak_force_inline uint8_t clampMin( uint8_t min, int16_t val ) +{ + return val < min ? min : val; +} + +static etcpak_force_inline uint8_t clampMax( int16_t val, uint8_t max ) +{ + return val > max ? max : val; +} + +// slightly faster than std::sort +static void insertionSort( uint8_t* arr1, uint8_t* arr2 ) +{ + for( uint8_t i = 1; i < 16; ++i ) + { + uint8_t value = arr1[i]; + uint8_t hole = i; + + for( ; hole > 0 && value < arr1[hole - 1]; --hole ) + { + arr1[hole] = arr1[hole - 1]; + arr2[hole] = arr2[hole - 1]; + } + arr1[hole] = value; + arr2[hole] = i; + } +} + +//converts indices from |a0|a1|e0|e1|i0|i1|m0|m1|b0|b1|f0|f1|j0|j1|n0|n1|c0|c1|g0|g1|k0|k1|o0|o1|d0|d1|h0|h1|l0|l1|p0|p1| previously used by T- and H-modes +// into |p0|o0|n0|m0|l0|k0|j0|i0|h0|g0|f0|e0|d0|c0|b0|a0|p1|o1|n1|m1|l1|k1|j1|i1|h1|g1|f1|e1|d1|c1|b1|a1| which should be used for all modes. +// NO WARRANTY --- SEE STATEMENT IN TOP OF FILE (C) Ericsson AB 2005-2013. All Rights Reserved. +static etcpak_force_inline int indexConversion( int pixelIndices ) +{ + int correctIndices = 0; + int LSB[4][4]; + int MSB[4][4]; + int shift = 0; + for( int y = 3; y >= 0; y-- ) + { + for( int x = 3; x >= 0; x-- ) + { + LSB[x][y] = ( pixelIndices >> shift ) & 1; + shift++; + MSB[x][y] = ( pixelIndices >> shift ) & 1; + shift++; + } + } + shift = 0; + for( int x = 0; x < 4; x++ ) + { + for( int y = 0; y < 4; y++ ) + { + correctIndices |= ( LSB[x][y] << shift ); + correctIndices |= ( MSB[x][y] << ( 16 + shift ) ); + shift++; + } + } + return correctIndices; +} + +// Swapping two RGB-colors +// NO WARRANTY --- SEE STATEMENT IN TOP OF FILE (C) Ericsson AB 2005-2013. All Rights Reserved. +static etcpak_force_inline void swapColors( uint8_t( colors )[2][3] ) +{ + uint8_t temp = colors[0][R]; + colors[0][R] = colors[1][R]; + colors[1][R] = temp; + + temp = colors[0][G]; + colors[0][G] = colors[1][G]; + colors[1][G] = temp; + + temp = colors[0][B]; + colors[0][B] = colors[1][B]; + colors[1][B] = temp; +} + + +// calculates quantized colors for T or H modes +void compressColor( uint8_t( currColor )[2][3], uint8_t( quantColor )[2][3], bool t_mode ) +{ + if( t_mode ) + { + quantColor[0][R] = clampMax( 15 * ( currColor[0][R] + 8 ) / 255, 15 ); + quantColor[0][G] = clampMax( 15 * ( currColor[0][G] + 8 ) / 255, 15 ); + quantColor[0][B] = clampMax( 15 * ( currColor[0][B] + 8 ) / 255, 15 ); + } + else // clamped to [1,14] to get a wider range + { + quantColor[0][R] = clamp( 1, 15 * ( currColor[0][R] + 8 ) / 255, 14 ); + quantColor[0][G] = clamp( 1, 15 * ( currColor[0][G] + 8 ) / 255, 14 ); + quantColor[0][B] = clamp( 1, 15 * ( currColor[0][B] + 8 ) / 255, 14 ); + } + + // clamped to [1,14] to get a wider range + quantColor[1][R] = clamp( 1, 15 * ( currColor[1][R] + 8 ) / 255, 14 ); + quantColor[1][G] = clamp( 1, 15 * ( currColor[1][G] + 8 ) / 255, 14 ); + quantColor[1][B] = clamp( 1, 15 * ( currColor[1][B] + 8 ) / 255, 14 ); +} + +// three decoding functions come from ETCPACK v2.74 and are slightly changed. +static etcpak_force_inline void decompressColor( uint8_t( colorsRGB444 )[2][3], uint8_t( colors )[2][3] ) +{ + // The color should be retrieved as: + // + // c = round(255/(r_bits^2-1))*comp_color + // + // This is similar to bit replication + // + // Note -- this code only work for bit replication from 4 bits and up --- 3 bits needs + // two copy operations. + colors[0][R] = ( colorsRGB444[0][R] << 4 ) | colorsRGB444[0][R]; + colors[0][G] = ( colorsRGB444[0][G] << 4 ) | colorsRGB444[0][G]; + colors[0][B] = ( colorsRGB444[0][B] << 4 ) | colorsRGB444[0][B]; + colors[1][R] = ( colorsRGB444[1][R] << 4 ) | colorsRGB444[1][R]; + colors[1][G] = ( colorsRGB444[1][G] << 4 ) | colorsRGB444[1][G]; + colors[1][B] = ( colorsRGB444[1][B] << 4 ) | colorsRGB444[1][B]; +} + +// calculates the paint colors from the block colors +// using a distance d and one of the H- or T-patterns. +static void calculatePaintColors59T( uint8_t d, uint8_t( colors )[2][3], uint8_t( pColors )[4][3] ) +{ + ////////////////////////////////////////////// + // + // C3 C1 C4----C1---C2 + // | | | + // | | | + // |-------| | + // | | | + // | | | + // C4 C2 C3 + // + ////////////////////////////////////////////// + + // C4 + pColors[3][R] = clampMin( 0, colors[1][R] - tableTH[d] ); + pColors[3][G] = clampMin( 0, colors[1][G] - tableTH[d] ); + pColors[3][B] = clampMin( 0, colors[1][B] - tableTH[d] ); + + // C3 + pColors[0][R] = colors[0][R]; + pColors[0][G] = colors[0][G]; + pColors[0][B] = colors[0][B]; + // C2 + pColors[1][R] = clampMax( colors[1][R] + tableTH[d], 255 ); + pColors[1][G] = clampMax( colors[1][G] + tableTH[d], 255 ); + pColors[1][B] = clampMax( colors[1][B] + tableTH[d], 255 ); + // C1 + pColors[2][R] = colors[1][R]; + pColors[2][G] = colors[1][G]; + pColors[2][B] = colors[1][B]; +} + +static void calculatePaintColors58H( uint8_t d, uint8_t( colors )[2][3], uint8_t( pColors )[4][3] ) +{ + pColors[3][R] = clampMin( 0, colors[1][R] - tableTH[d] ); + pColors[3][G] = clampMin( 0, colors[1][G] - tableTH[d] ); + pColors[3][B] = clampMin( 0, colors[1][B] - tableTH[d] ); + + // C1 + pColors[0][R] = clampMax( colors[0][R] + tableTH[d], 255 ); + pColors[0][G] = clampMax( colors[0][G] + tableTH[d], 255 ); + pColors[0][B] = clampMax( colors[0][B] + tableTH[d], 255 ); + // C2 + pColors[1][R] = clampMin( 0, colors[0][R] - tableTH[d] ); + pColors[1][G] = clampMin( 0, colors[0][G] - tableTH[d] ); + pColors[1][B] = clampMin( 0, colors[0][B] - tableTH[d] ); + // C3 + pColors[2][R] = clampMax( colors[1][R] + tableTH[d], 255 ); + pColors[2][G] = clampMax( colors[1][G] + tableTH[d], 255 ); + pColors[2][B] = clampMax( colors[1][B] + tableTH[d], 255 ); +} + +#if defined _MSC_VER && !defined __clang__ +static etcpak_force_inline unsigned long _bit_scan_forward( unsigned long mask ) +{ + unsigned long ret; + _BitScanForward( &ret, mask ); + return ret; +} +#endif + +typedef std::array v4i; + +#ifdef __AVX2__ +static etcpak_force_inline __m256i Sum4_AVX2( const uint8_t* data) noexcept +{ + __m128i d0 = _mm_loadu_si128(((__m128i*)data) + 0); + __m128i d1 = _mm_loadu_si128(((__m128i*)data) + 1); + __m128i d2 = _mm_loadu_si128(((__m128i*)data) + 2); + __m128i d3 = _mm_loadu_si128(((__m128i*)data) + 3); + + __m128i dm0 = _mm_and_si128(d0, _mm_set1_epi32(0x00FFFFFF)); + __m128i dm1 = _mm_and_si128(d1, _mm_set1_epi32(0x00FFFFFF)); + __m128i dm2 = _mm_and_si128(d2, _mm_set1_epi32(0x00FFFFFF)); + __m128i dm3 = _mm_and_si128(d3, _mm_set1_epi32(0x00FFFFFF)); + + __m256i t0 = _mm256_cvtepu8_epi16(dm0); + __m256i t1 = _mm256_cvtepu8_epi16(dm1); + __m256i t2 = _mm256_cvtepu8_epi16(dm2); + __m256i t3 = _mm256_cvtepu8_epi16(dm3); + + __m256i sum0 = _mm256_add_epi16(t0, t1); + __m256i sum1 = _mm256_add_epi16(t2, t3); + + __m256i s0 = _mm256_permute2x128_si256(sum0, sum1, (0) | (3 << 4)); // 0, 0, 3, 3 + __m256i s1 = _mm256_permute2x128_si256(sum0, sum1, (1) | (2 << 4)); // 1, 1, 2, 2 + + __m256i s2 = _mm256_permute4x64_epi64(s0, _MM_SHUFFLE(1, 3, 0, 2)); + __m256i s3 = _mm256_permute4x64_epi64(s0, _MM_SHUFFLE(0, 2, 1, 3)); + __m256i s4 = _mm256_permute4x64_epi64(s1, _MM_SHUFFLE(3, 1, 0, 2)); + __m256i s5 = _mm256_permute4x64_epi64(s1, _MM_SHUFFLE(2, 0, 1, 3)); + + __m256i sum5 = _mm256_add_epi16(s2, s3); // 3, 0, 3, 0 + __m256i sum6 = _mm256_add_epi16(s4, s5); // 2, 1, 1, 2 + return _mm256_add_epi16(sum5, sum6); // 3+2, 0+1, 3+1, 3+2 +} + +static etcpak_force_inline __m256i Average_AVX2( const __m256i data) noexcept +{ + __m256i a = _mm256_add_epi16(data, _mm256_set1_epi16(4)); + + return _mm256_srli_epi16(a, 3); +} + +static etcpak_force_inline __m128i CalcErrorBlock_AVX2( const __m256i data, const v4i a[8]) noexcept +{ + // + __m256i a0 = _mm256_load_si256((__m256i*)a[0].data()); + __m256i a1 = _mm256_load_si256((__m256i*)a[4].data()); + + // err = 8 * ( sq( average[0] ) + sq( average[1] ) + sq( average[2] ) ); + __m256i a4 = _mm256_madd_epi16(a0, a0); + __m256i a5 = _mm256_madd_epi16(a1, a1); + + __m256i a6 = _mm256_hadd_epi32(a4, a5); + __m256i a7 = _mm256_slli_epi32(a6, 3); + + __m256i a8 = _mm256_add_epi32(a7, _mm256_set1_epi32(0x3FFFFFFF)); // Big value to prevent negative values, but small enough to prevent overflow + + // average is not swapped + // err -= block[0] * 2 * average[0]; + // err -= block[1] * 2 * average[1]; + // err -= block[2] * 2 * average[2]; + __m256i a2 = _mm256_slli_epi16(a0, 1); + __m256i a3 = _mm256_slli_epi16(a1, 1); + __m256i b0 = _mm256_madd_epi16(a2, data); + __m256i b1 = _mm256_madd_epi16(a3, data); + + __m256i b2 = _mm256_hadd_epi32(b0, b1); + __m256i b3 = _mm256_sub_epi32(a8, b2); + __m256i b4 = _mm256_hadd_epi32(b3, b3); + + __m256i b5 = _mm256_permutevar8x32_epi32(b4, _mm256_set_epi32(0, 0, 0, 0, 5, 1, 4, 0)); + + return _mm256_castsi256_si128(b5); +} + +static etcpak_force_inline void ProcessAverages_AVX2(const __m256i d, v4i a[8] ) noexcept +{ + __m256i t = _mm256_add_epi16(_mm256_mullo_epi16(d, _mm256_set1_epi16(31)), _mm256_set1_epi16(128)); + + __m256i c = _mm256_srli_epi16(_mm256_add_epi16(t, _mm256_srli_epi16(t, 8)), 8); + + __m256i c1 = _mm256_shuffle_epi32(c, _MM_SHUFFLE(3, 2, 3, 2)); + __m256i diff = _mm256_sub_epi16(c, c1); + diff = _mm256_max_epi16(diff, _mm256_set1_epi16(-4)); + diff = _mm256_min_epi16(diff, _mm256_set1_epi16(3)); + + __m256i co = _mm256_add_epi16(c1, diff); + + c = _mm256_blend_epi16(co, c, 0xF0); + + __m256i a0 = _mm256_or_si256(_mm256_slli_epi16(c, 3), _mm256_srli_epi16(c, 2)); + + _mm256_store_si256((__m256i*)a[4].data(), a0); + + __m256i t0 = _mm256_add_epi16(_mm256_mullo_epi16(d, _mm256_set1_epi16(15)), _mm256_set1_epi16(128)); + __m256i t1 = _mm256_srli_epi16(_mm256_add_epi16(t0, _mm256_srli_epi16(t0, 8)), 8); + + __m256i t2 = _mm256_or_si256(t1, _mm256_slli_epi16(t1, 4)); + + _mm256_store_si256((__m256i*)a[0].data(), t2); +} + +static etcpak_force_inline uint64_t EncodeAverages_AVX2( const v4i a[8], size_t idx ) noexcept +{ + uint64_t d = ( idx << 24 ); + size_t base = idx << 1; + + __m128i a0 = _mm_load_si128((const __m128i*)a[base].data()); + + __m128i r0, r1; + + if( ( idx & 0x2 ) == 0 ) + { + r0 = _mm_srli_epi16(a0, 4); + + __m128i a1 = _mm_unpackhi_epi64(r0, r0); + r1 = _mm_slli_epi16(a1, 4); + } + else + { + __m128i a1 = _mm_and_si128(a0, _mm_set1_epi16(-8)); + + r0 = _mm_unpackhi_epi64(a1, a1); + __m128i a2 = _mm_sub_epi16(a1, r0); + __m128i a3 = _mm_srai_epi16(a2, 3); + r1 = _mm_and_si128(a3, _mm_set1_epi16(0x07)); + } + + __m128i r2 = _mm_or_si128(r0, r1); + // do missing swap for average values + __m128i r3 = _mm_shufflelo_epi16(r2, _MM_SHUFFLE(3, 0, 1, 2)); + __m128i r4 = _mm_packus_epi16(r3, _mm_setzero_si128()); + d |= _mm_cvtsi128_si32(r4); + + return d; +} + +static etcpak_force_inline uint64_t CheckSolid_AVX2( const uint8_t* src ) noexcept +{ + __m256i d0 = _mm256_loadu_si256(((__m256i*)src) + 0); + __m256i d1 = _mm256_loadu_si256(((__m256i*)src) + 1); + + __m256i c = _mm256_broadcastd_epi32(_mm256_castsi256_si128(d0)); + + __m256i c0 = _mm256_cmpeq_epi8(d0, c); + __m256i c1 = _mm256_cmpeq_epi8(d1, c); + + __m256i m = _mm256_and_si256(c0, c1); + + if (!_mm256_testc_si256(m, _mm256_set1_epi32(-1))) + { + return 0; + } + + return 0x02000000 | + ( (unsigned int)( src[0] & 0xF8 ) << 16 ) | + ( (unsigned int)( src[1] & 0xF8 ) << 8 ) | + ( (unsigned int)( src[2] & 0xF8 ) ); +} + +static etcpak_force_inline __m128i PrepareAverages_AVX2( v4i a[8], const uint8_t* src) noexcept +{ + __m256i sum4 = Sum4_AVX2( src ); + + ProcessAverages_AVX2(Average_AVX2( sum4 ), a ); + + return CalcErrorBlock_AVX2( sum4, a); +} + +static etcpak_force_inline __m128i PrepareAverages_AVX2( v4i a[8], const __m256i sum4) noexcept +{ + ProcessAverages_AVX2(Average_AVX2( sum4 ), a ); + + return CalcErrorBlock_AVX2( sum4, a); +} + +static etcpak_force_inline void FindBestFit_4x2_AVX2( uint32_t terr[2][8], uint32_t tsel[8], v4i a[8], const uint32_t offset, const uint8_t* data) noexcept +{ + __m256i sel0 = _mm256_setzero_si256(); + __m256i sel1 = _mm256_setzero_si256(); + + for (unsigned int j = 0; j < 2; ++j) + { + unsigned int bid = offset + 1 - j; + + __m256i squareErrorSum = _mm256_setzero_si256(); + + __m128i a0 = _mm_loadl_epi64((const __m128i*)a[bid].data()); + __m256i a1 = _mm256_broadcastq_epi64(a0); + + // Processing one full row each iteration + for (size_t i = 0; i < 8; i += 4) + { + __m128i rgb = _mm_loadu_si128((const __m128i*)(data + i * 4)); + + __m256i rgb16 = _mm256_cvtepu8_epi16(rgb); + __m256i d = _mm256_sub_epi16(a1, rgb16); + + // The scaling values are divided by two and rounded, to allow the differences to be in the range of signed int16 + // This produces slightly different results, but is significant faster + __m256i pixel0 = _mm256_madd_epi16(d, _mm256_set_epi16(0, 38, 76, 14, 0, 38, 76, 14, 0, 38, 76, 14, 0, 38, 76, 14)); + __m256i pixel1 = _mm256_packs_epi32(pixel0, pixel0); + __m256i pixel2 = _mm256_hadd_epi16(pixel1, pixel1); + __m128i pixel3 = _mm256_castsi256_si128(pixel2); + + __m128i pix0 = _mm_broadcastw_epi16(pixel3); + __m128i pix1 = _mm_broadcastw_epi16(_mm_srli_epi32(pixel3, 16)); + __m256i pixel = _mm256_insertf128_si256(_mm256_castsi128_si256(pix0), pix1, 1); + + // Processing first two pixels of the row + { + __m256i pix = _mm256_abs_epi16(pixel); + + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + // Since the selector table is symmetrical, we need to calculate the difference only for half of the entries. + __m256i error0 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[0]))); + __m256i error1 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[1]))); + + __m256i minIndex0 = _mm256_and_si256(_mm256_cmpgt_epi16(error0, error1), _mm256_set1_epi16(1)); + __m256i minError = _mm256_min_epi16(error0, error1); + + // Exploiting symmetry of the selector table and use the sign bit + // This produces slightly different results, but is significant faster + __m256i minIndex1 = _mm256_srli_epi16(pixel, 15); + + // Interleaving values so madd instruction can be used + __m256i minErrorLo = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(1, 1, 0, 0)); + __m256i minErrorHi = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(3, 3, 2, 2)); + + __m256i minError2 = _mm256_unpacklo_epi16(minErrorLo, minErrorHi); + // Squaring the minimum error to produce correct values when adding + __m256i squareError = _mm256_madd_epi16(minError2, minError2); + + squareErrorSum = _mm256_add_epi32(squareErrorSum, squareError); + + // Packing selector bits + __m256i minIndexLo2 = _mm256_sll_epi16(minIndex0, _mm_cvtsi64_si128(i + j * 8)); + __m256i minIndexHi2 = _mm256_sll_epi16(minIndex1, _mm_cvtsi64_si128(i + j * 8)); + + sel0 = _mm256_or_si256(sel0, minIndexLo2); + sel1 = _mm256_or_si256(sel1, minIndexHi2); + } + + pixel3 = _mm256_extracti128_si256(pixel2, 1); + pix0 = _mm_broadcastw_epi16(pixel3); + pix1 = _mm_broadcastw_epi16(_mm_srli_epi32(pixel3, 16)); + pixel = _mm256_insertf128_si256(_mm256_castsi128_si256(pix0), pix1, 1); + + // Processing second two pixels of the row + { + __m256i pix = _mm256_abs_epi16(pixel); + + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + // Since the selector table is symmetrical, we need to calculate the difference only for half of the entries. + __m256i error0 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[0]))); + __m256i error1 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[1]))); + + __m256i minIndex0 = _mm256_and_si256(_mm256_cmpgt_epi16(error0, error1), _mm256_set1_epi16(1)); + __m256i minError = _mm256_min_epi16(error0, error1); + + // Exploiting symmetry of the selector table and use the sign bit + __m256i minIndex1 = _mm256_srli_epi16(pixel, 15); + + // Interleaving values so madd instruction can be used + __m256i minErrorLo = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(1, 1, 0, 0)); + __m256i minErrorHi = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(3, 3, 2, 2)); + + __m256i minError2 = _mm256_unpacklo_epi16(minErrorLo, minErrorHi); + // Squaring the minimum error to produce correct values when adding + __m256i squareError = _mm256_madd_epi16(minError2, minError2); + + squareErrorSum = _mm256_add_epi32(squareErrorSum, squareError); + + // Packing selector bits + __m256i minIndexLo2 = _mm256_sll_epi16(minIndex0, _mm_cvtsi64_si128(i + j * 8)); + __m256i minIndexHi2 = _mm256_sll_epi16(minIndex1, _mm_cvtsi64_si128(i + j * 8)); + __m256i minIndexLo3 = _mm256_slli_epi16(minIndexLo2, 2); + __m256i minIndexHi3 = _mm256_slli_epi16(minIndexHi2, 2); + + sel0 = _mm256_or_si256(sel0, minIndexLo3); + sel1 = _mm256_or_si256(sel1, minIndexHi3); + } + } + + data += 8 * 4; + + _mm256_store_si256((__m256i*)terr[1 - j], squareErrorSum); + } + + // Interleave selector bits + __m256i minIndexLo0 = _mm256_unpacklo_epi16(sel0, sel1); + __m256i minIndexHi0 = _mm256_unpackhi_epi16(sel0, sel1); + + __m256i minIndexLo1 = _mm256_permute2x128_si256(minIndexLo0, minIndexHi0, (0) | (2 << 4)); + __m256i minIndexHi1 = _mm256_permute2x128_si256(minIndexLo0, minIndexHi0, (1) | (3 << 4)); + + __m256i minIndexHi2 = _mm256_slli_epi32(minIndexHi1, 1); + + __m256i sel = _mm256_or_si256(minIndexLo1, minIndexHi2); + + _mm256_store_si256((__m256i*)tsel, sel); +} + +static etcpak_force_inline void FindBestFit_2x4_AVX2( uint32_t terr[2][8], uint32_t tsel[8], v4i a[8], const uint32_t offset, const uint8_t* data) noexcept +{ + __m256i sel0 = _mm256_setzero_si256(); + __m256i sel1 = _mm256_setzero_si256(); + + __m256i squareErrorSum0 = _mm256_setzero_si256(); + __m256i squareErrorSum1 = _mm256_setzero_si256(); + + __m128i a0 = _mm_loadl_epi64((const __m128i*)a[offset + 1].data()); + __m128i a1 = _mm_loadl_epi64((const __m128i*)a[offset + 0].data()); + + __m128i a2 = _mm_broadcastq_epi64(a0); + __m128i a3 = _mm_broadcastq_epi64(a1); + __m256i a4 = _mm256_insertf128_si256(_mm256_castsi128_si256(a2), a3, 1); + + // Processing one full row each iteration + for (size_t i = 0; i < 16; i += 4) + { + __m128i rgb = _mm_loadu_si128((const __m128i*)(data + i * 4)); + + __m256i rgb16 = _mm256_cvtepu8_epi16(rgb); + __m256i d = _mm256_sub_epi16(a4, rgb16); + + // The scaling values are divided by two and rounded, to allow the differences to be in the range of signed int16 + // This produces slightly different results, but is significant faster + __m256i pixel0 = _mm256_madd_epi16(d, _mm256_set_epi16(0, 38, 76, 14, 0, 38, 76, 14, 0, 38, 76, 14, 0, 38, 76, 14)); + __m256i pixel1 = _mm256_packs_epi32(pixel0, pixel0); + __m256i pixel2 = _mm256_hadd_epi16(pixel1, pixel1); + __m128i pixel3 = _mm256_castsi256_si128(pixel2); + + __m128i pix0 = _mm_broadcastw_epi16(pixel3); + __m128i pix1 = _mm_broadcastw_epi16(_mm_srli_epi32(pixel3, 16)); + __m256i pixel = _mm256_insertf128_si256(_mm256_castsi128_si256(pix0), pix1, 1); + + // Processing first two pixels of the row + { + __m256i pix = _mm256_abs_epi16(pixel); + + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + // Since the selector table is symmetrical, we need to calculate the difference only for half of the entries. + __m256i error0 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[0]))); + __m256i error1 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[1]))); + + __m256i minIndex0 = _mm256_and_si256(_mm256_cmpgt_epi16(error0, error1), _mm256_set1_epi16(1)); + __m256i minError = _mm256_min_epi16(error0, error1); + + // Exploiting symmetry of the selector table and use the sign bit + __m256i minIndex1 = _mm256_srli_epi16(pixel, 15); + + // Interleaving values so madd instruction can be used + __m256i minErrorLo = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(1, 1, 0, 0)); + __m256i minErrorHi = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(3, 3, 2, 2)); + + __m256i minError2 = _mm256_unpacklo_epi16(minErrorLo, minErrorHi); + // Squaring the minimum error to produce correct values when adding + __m256i squareError = _mm256_madd_epi16(minError2, minError2); + + squareErrorSum0 = _mm256_add_epi32(squareErrorSum0, squareError); + + // Packing selector bits + __m256i minIndexLo2 = _mm256_sll_epi16(minIndex0, _mm_cvtsi64_si128(i)); + __m256i minIndexHi2 = _mm256_sll_epi16(minIndex1, _mm_cvtsi64_si128(i)); + + sel0 = _mm256_or_si256(sel0, minIndexLo2); + sel1 = _mm256_or_si256(sel1, minIndexHi2); + } + + pixel3 = _mm256_extracti128_si256(pixel2, 1); + pix0 = _mm_broadcastw_epi16(pixel3); + pix1 = _mm_broadcastw_epi16(_mm_srli_epi32(pixel3, 16)); + pixel = _mm256_insertf128_si256(_mm256_castsi128_si256(pix0), pix1, 1); + + // Processing second two pixels of the row + { + __m256i pix = _mm256_abs_epi16(pixel); + + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + // Since the selector table is symmetrical, we need to calculate the difference only for half of the entries. + __m256i error0 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[0]))); + __m256i error1 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[1]))); + + __m256i minIndex0 = _mm256_and_si256(_mm256_cmpgt_epi16(error0, error1), _mm256_set1_epi16(1)); + __m256i minError = _mm256_min_epi16(error0, error1); + + // Exploiting symmetry of the selector table and use the sign bit + __m256i minIndex1 = _mm256_srli_epi16(pixel, 15); + + // Interleaving values so madd instruction can be used + __m256i minErrorLo = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(1, 1, 0, 0)); + __m256i minErrorHi = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(3, 3, 2, 2)); + + __m256i minError2 = _mm256_unpacklo_epi16(minErrorLo, minErrorHi); + // Squaring the minimum error to produce correct values when adding + __m256i squareError = _mm256_madd_epi16(minError2, minError2); + + squareErrorSum1 = _mm256_add_epi32(squareErrorSum1, squareError); + + // Packing selector bits + __m256i minIndexLo2 = _mm256_sll_epi16(minIndex0, _mm_cvtsi64_si128(i)); + __m256i minIndexHi2 = _mm256_sll_epi16(minIndex1, _mm_cvtsi64_si128(i)); + __m256i minIndexLo3 = _mm256_slli_epi16(minIndexLo2, 2); + __m256i minIndexHi3 = _mm256_slli_epi16(minIndexHi2, 2); + + sel0 = _mm256_or_si256(sel0, minIndexLo3); + sel1 = _mm256_or_si256(sel1, minIndexHi3); + } + } + + _mm256_store_si256((__m256i*)terr[1], squareErrorSum0); + _mm256_store_si256((__m256i*)terr[0], squareErrorSum1); + + // Interleave selector bits + __m256i minIndexLo0 = _mm256_unpacklo_epi16(sel0, sel1); + __m256i minIndexHi0 = _mm256_unpackhi_epi16(sel0, sel1); + + __m256i minIndexLo1 = _mm256_permute2x128_si256(minIndexLo0, minIndexHi0, (0) | (2 << 4)); + __m256i minIndexHi1 = _mm256_permute2x128_si256(minIndexLo0, minIndexHi0, (1) | (3 << 4)); + + __m256i minIndexHi2 = _mm256_slli_epi32(minIndexHi1, 1); + + __m256i sel = _mm256_or_si256(minIndexLo1, minIndexHi2); + + _mm256_store_si256((__m256i*)tsel, sel); +} + +static etcpak_force_inline uint64_t EncodeSelectors_AVX2( uint64_t d, const uint32_t terr[2][8], const uint32_t tsel[8], const bool rotate) noexcept +{ + size_t tidx[2]; + + // Get index of minimum error (terr[0] and terr[1]) + __m256i err0 = _mm256_load_si256((const __m256i*)terr[0]); + __m256i err1 = _mm256_load_si256((const __m256i*)terr[1]); + + __m256i errLo = _mm256_permute2x128_si256(err0, err1, (0) | (2 << 4)); + __m256i errHi = _mm256_permute2x128_si256(err0, err1, (1) | (3 << 4)); + + __m256i errMin0 = _mm256_min_epu32(errLo, errHi); + + __m256i errMin1 = _mm256_shuffle_epi32(errMin0, _MM_SHUFFLE(2, 3, 0, 1)); + __m256i errMin2 = _mm256_min_epu32(errMin0, errMin1); + + __m256i errMin3 = _mm256_shuffle_epi32(errMin2, _MM_SHUFFLE(1, 0, 3, 2)); + __m256i errMin4 = _mm256_min_epu32(errMin3, errMin2); + + __m256i errMin5 = _mm256_permute2x128_si256(errMin4, errMin4, (0) | (0 << 4)); + __m256i errMin6 = _mm256_permute2x128_si256(errMin4, errMin4, (1) | (1 << 4)); + + __m256i errMask0 = _mm256_cmpeq_epi32(errMin5, err0); + __m256i errMask1 = _mm256_cmpeq_epi32(errMin6, err1); + + uint32_t mask0 = _mm256_movemask_epi8(errMask0); + uint32_t mask1 = _mm256_movemask_epi8(errMask1); + + tidx[0] = _bit_scan_forward(mask0) >> 2; + tidx[1] = _bit_scan_forward(mask1) >> 2; + + d |= tidx[0] << 26; + d |= tidx[1] << 29; + + unsigned int t0 = tsel[tidx[0]]; + unsigned int t1 = tsel[tidx[1]]; + + if (!rotate) + { + t0 &= 0xFF00FF00; + t1 &= 0x00FF00FF; + } + else + { + t0 &= 0xCCCCCCCC; + t1 &= 0x33333333; + } + + // Flip selectors from sign bit + unsigned int t2 = (t0 | t1) ^ 0xFFFF0000; + + return d | static_cast(_bswap(t2)) << 32; +} + +static etcpak_force_inline __m128i r6g7b6_AVX2(__m128 cof, __m128 chf, __m128 cvf) noexcept +{ + __m128i co = _mm_cvttps_epi32(cof); + __m128i ch = _mm_cvttps_epi32(chf); + __m128i cv = _mm_cvttps_epi32(cvf); + + __m128i coh = _mm_packus_epi32(co, ch); + __m128i cv0 = _mm_packus_epi32(cv, _mm_setzero_si128()); + + __m256i cohv0 = _mm256_inserti128_si256(_mm256_castsi128_si256(coh), cv0, 1); + __m256i cohv1 = _mm256_min_epu16(cohv0, _mm256_set1_epi16(1023)); + + __m256i cohv2 = _mm256_sub_epi16(cohv1, _mm256_set1_epi16(15)); + __m256i cohv3 = _mm256_srai_epi16(cohv2, 1); + + __m256i cohvrb0 = _mm256_add_epi16(cohv3, _mm256_set1_epi16(11)); + __m256i cohvrb1 = _mm256_add_epi16(cohv3, _mm256_set1_epi16(4)); + __m256i cohvg0 = _mm256_add_epi16(cohv3, _mm256_set1_epi16(9)); + __m256i cohvg1 = _mm256_add_epi16(cohv3, _mm256_set1_epi16(6)); + + __m256i cohvrb2 = _mm256_srai_epi16(cohvrb0, 7); + __m256i cohvrb3 = _mm256_srai_epi16(cohvrb1, 7); + __m256i cohvg2 = _mm256_srai_epi16(cohvg0, 8); + __m256i cohvg3 = _mm256_srai_epi16(cohvg1, 8); + + __m256i cohvrb4 = _mm256_sub_epi16(cohvrb0, cohvrb2); + __m256i cohvrb5 = _mm256_sub_epi16(cohvrb4, cohvrb3); + __m256i cohvg4 = _mm256_sub_epi16(cohvg0, cohvg2); + __m256i cohvg5 = _mm256_sub_epi16(cohvg4, cohvg3); + + __m256i cohvrb6 = _mm256_srai_epi16(cohvrb5, 3); + __m256i cohvg6 = _mm256_srai_epi16(cohvg5, 2); + + __m256i cohv4 = _mm256_blend_epi16(cohvg6, cohvrb6, 0x55); + + __m128i cohv5 = _mm_packus_epi16(_mm256_castsi256_si128(cohv4), _mm256_extracti128_si256(cohv4, 1)); + return _mm_shuffle_epi8(cohv5, _mm_setr_epi8(6, 5, 4, -1, 2, 1, 0, -1, 10, 9, 8, -1, -1, -1, -1, -1)); +} + +static etcpak_force_inline Plane Planar_AVX2( const Channels& ch, uint8_t& mode, bool useHeuristics ) +{ + __m128i t0 = _mm_sad_epu8( ch.r8, _mm_setzero_si128() ); + __m128i t1 = _mm_sad_epu8( ch.g8, _mm_setzero_si128() ); + __m128i t2 = _mm_sad_epu8( ch.b8, _mm_setzero_si128() ); + + __m128i r8s = _mm_shuffle_epi8( ch.r8, _mm_set_epi8( 0xF, 0xE, 0xB, 0xA, 0x7, 0x6, 0x3, 0x2, 0xD, 0xC, 0x9, 0x8, 0x5, 0x4, 0x1, 0x0 ) ); + __m128i g8s = _mm_shuffle_epi8( ch.g8, _mm_set_epi8( 0xF, 0xE, 0xB, 0xA, 0x7, 0x6, 0x3, 0x2, 0xD, 0xC, 0x9, 0x8, 0x5, 0x4, 0x1, 0x0 ) ); + __m128i b8s = _mm_shuffle_epi8( ch.b8, _mm_set_epi8( 0xF, 0xE, 0xB, 0xA, 0x7, 0x6, 0x3, 0x2, 0xD, 0xC, 0x9, 0x8, 0x5, 0x4, 0x1, 0x0 ) ); + + __m128i s0 = _mm_sad_epu8( r8s, _mm_setzero_si128() ); + __m128i s1 = _mm_sad_epu8( g8s, _mm_setzero_si128() ); + __m128i s2 = _mm_sad_epu8( b8s, _mm_setzero_si128() ); + + __m256i sr0 = _mm256_insertf128_si256( _mm256_castsi128_si256( t0 ), s0, 1 ); + __m256i sg0 = _mm256_insertf128_si256( _mm256_castsi128_si256( t1 ), s1, 1 ); + __m256i sb0 = _mm256_insertf128_si256( _mm256_castsi128_si256( t2 ), s2, 1 ); + + __m256i sr1 = _mm256_slli_epi64( sr0, 32 ); + __m256i sg1 = _mm256_slli_epi64( sg0, 16 ); + + __m256i srb = _mm256_or_si256( sr1, sb0 ); + __m256i srgb = _mm256_or_si256( srb, sg1 ); + + if( mode != ModePlanar && useHeuristics ) + { + Plane plane; + plane.sum4 = _mm256_permute4x64_epi64( srgb, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + return plane; + } + + __m128i t3 = _mm_castps_si128( _mm_shuffle_ps( _mm_castsi128_ps( t0 ), _mm_castsi128_ps( t1 ), _MM_SHUFFLE( 2, 0, 2, 0 ) ) ); + __m128i t4 = _mm_shuffle_epi32( t2, _MM_SHUFFLE( 3, 1, 2, 0 ) ); + __m128i t5 = _mm_hadd_epi32( t3, t4 ); + __m128i t6 = _mm_shuffle_epi32( t5, _MM_SHUFFLE( 1, 1, 1, 1 ) ); + __m128i t7 = _mm_shuffle_epi32( t5, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + + __m256i sr = _mm256_broadcastw_epi16( t5 ); + __m256i sg = _mm256_broadcastw_epi16( t6 ); + __m256i sb = _mm256_broadcastw_epi16( t7 ); + + __m256i r08 = _mm256_cvtepu8_epi16( ch.r8 ); + __m256i g08 = _mm256_cvtepu8_epi16( ch.g8 ); + __m256i b08 = _mm256_cvtepu8_epi16( ch.b8 ); + + __m256i r16 = _mm256_slli_epi16( r08, 4 ); + __m256i g16 = _mm256_slli_epi16( g08, 4 ); + __m256i b16 = _mm256_slli_epi16( b08, 4 ); + + __m256i difR0 = _mm256_sub_epi16( r16, sr ); + __m256i difG0 = _mm256_sub_epi16( g16, sg ); + __m256i difB0 = _mm256_sub_epi16( b16, sb ); + + __m256i difRyz = _mm256_madd_epi16( difR0, _mm256_set_epi16( 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255 ) ); + __m256i difGyz = _mm256_madd_epi16( difG0, _mm256_set_epi16( 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255 ) ); + __m256i difByz = _mm256_madd_epi16( difB0, _mm256_set_epi16( 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255 ) ); + + __m256i difRxz = _mm256_madd_epi16( difR0, _mm256_set_epi16( 255, 255, 255, 255, 85, 85, 85, 85, -85, -85, -85, -85, -255, -255, -255, -255 ) ); + __m256i difGxz = _mm256_madd_epi16( difG0, _mm256_set_epi16( 255, 255, 255, 255, 85, 85, 85, 85, -85, -85, -85, -85, -255, -255, -255, -255 ) ); + __m256i difBxz = _mm256_madd_epi16( difB0, _mm256_set_epi16( 255, 255, 255, 255, 85, 85, 85, 85, -85, -85, -85, -85, -255, -255, -255, -255 ) ); + + __m256i difRGyz = _mm256_hadd_epi32( difRyz, difGyz ); + __m256i difByzxz = _mm256_hadd_epi32( difByz, difBxz ); + + __m256i difRGxz = _mm256_hadd_epi32( difRxz, difGxz ); + + __m128i sumRGyz = _mm_add_epi32( _mm256_castsi256_si128( difRGyz ), _mm256_extracti128_si256( difRGyz, 1 ) ); + __m128i sumByzxz = _mm_add_epi32( _mm256_castsi256_si128( difByzxz ), _mm256_extracti128_si256( difByzxz, 1 ) ); + __m128i sumRGxz = _mm_add_epi32( _mm256_castsi256_si128( difRGxz ), _mm256_extracti128_si256( difRGxz, 1 ) ); + + __m128i sumRGByz = _mm_hadd_epi32( sumRGyz, sumByzxz ); + __m128i sumRGByzxz = _mm_hadd_epi32( sumRGxz, sumByzxz ); + + __m128i sumRGBxz = _mm_shuffle_epi32( sumRGByzxz, _MM_SHUFFLE( 2, 3, 1, 0 ) ); + + __m128 sumRGByzf = _mm_cvtepi32_ps( sumRGByz ); + __m128 sumRGBxzf = _mm_cvtepi32_ps( sumRGBxz ); + + const float value = ( 255 * 255 * 8.0f + 85 * 85 * 8.0f ) * 16.0f; + + __m128 scale = _mm_set1_ps( -4.0f / value ); + + __m128 af = _mm_mul_ps( sumRGBxzf, scale ); + __m128 bf = _mm_mul_ps( sumRGByzf, scale ); + + __m128 df = _mm_mul_ps( _mm_cvtepi32_ps( t5 ), _mm_set1_ps( 4.0f / 16.0f ) ); + + // calculating the three colors RGBO, RGBH, and RGBV. RGB = df - af * x - bf * y; + __m128 cof0 = _mm_fnmadd_ps( af, _mm_set1_ps( -255.0f ), _mm_fnmadd_ps( bf, _mm_set1_ps( -255.0f ), df ) ); + __m128 chf0 = _mm_fnmadd_ps( af, _mm_set1_ps( 425.0f ), _mm_fnmadd_ps( bf, _mm_set1_ps( -255.0f ), df ) ); + __m128 cvf0 = _mm_fnmadd_ps( af, _mm_set1_ps( -255.0f ), _mm_fnmadd_ps( bf, _mm_set1_ps( 425.0f ), df ) ); + + // convert to r6g7b6 + __m128i cohv = r6g7b6_AVX2( cof0, chf0, cvf0 ); + + uint64_t rgbho = _mm_extract_epi64( cohv, 0 ); + uint32_t rgbv0 = _mm_extract_epi32( cohv, 2 ); + + // Error calculation + uint64_t error = 0; + if( !useHeuristics ) + { + auto ro0 = ( rgbho >> 48 ) & 0x3F; + auto go0 = ( rgbho >> 40 ) & 0x7F; + auto bo0 = ( rgbho >> 32 ) & 0x3F; + auto ro1 = ( ro0 >> 4 ) | ( ro0 << 2 ); + auto go1 = ( go0 >> 6 ) | ( go0 << 1 ); + auto bo1 = ( bo0 >> 4 ) | ( bo0 << 2 ); + auto ro2 = ( ro1 << 2 ) + 2; + auto go2 = ( go1 << 2 ) + 2; + auto bo2 = ( bo1 << 2 ) + 2; + + __m256i ro3 = _mm256_set1_epi16( ro2 ); + __m256i go3 = _mm256_set1_epi16( go2 ); + __m256i bo3 = _mm256_set1_epi16( bo2 ); + + auto rh0 = ( rgbho >> 16 ) & 0x3F; + auto gh0 = ( rgbho >> 8 ) & 0x7F; + auto bh0 = ( rgbho >> 0 ) & 0x3F; + auto rh1 = ( rh0 >> 4 ) | ( rh0 << 2 ); + auto gh1 = ( gh0 >> 6 ) | ( gh0 << 1 ); + auto bh1 = ( bh0 >> 4 ) | ( bh0 << 2 ); + + auto rh2 = rh1 - ro1; + auto gh2 = gh1 - go1; + auto bh2 = bh1 - bo1; + + __m256i rh3 = _mm256_set1_epi16( rh2 ); + __m256i gh3 = _mm256_set1_epi16( gh2 ); + __m256i bh3 = _mm256_set1_epi16( bh2 ); + + auto rv0 = ( rgbv0 >> 16 ) & 0x3F; + auto gv0 = ( rgbv0 >> 8 ) & 0x7F; + auto bv0 = ( rgbv0 >> 0 ) & 0x3F; + auto rv1 = ( rv0 >> 4 ) | ( rv0 << 2 ); + auto gv1 = ( gv0 >> 6 ) | ( gv0 << 1 ); + auto bv1 = ( bv0 >> 4 ) | ( bv0 << 2 ); + + auto rv2 = rv1 - ro1; + auto gv2 = gv1 - go1; + auto bv2 = bv1 - bo1; + + __m256i rv3 = _mm256_set1_epi16( rv2 ); + __m256i gv3 = _mm256_set1_epi16( gv2 ); + __m256i bv3 = _mm256_set1_epi16( bv2 ); + + __m256i x = _mm256_set_epi16( 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0 ); + + __m256i rh4 = _mm256_mullo_epi16( rh3, x ); + __m256i gh4 = _mm256_mullo_epi16( gh3, x ); + __m256i bh4 = _mm256_mullo_epi16( bh3, x ); + + __m256i y = _mm256_set_epi16( 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0 ); + + __m256i rv4 = _mm256_mullo_epi16( rv3, y ); + __m256i gv4 = _mm256_mullo_epi16( gv3, y ); + __m256i bv4 = _mm256_mullo_epi16( bv3, y ); + + __m256i rxy = _mm256_add_epi16( rh4, rv4 ); + __m256i gxy = _mm256_add_epi16( gh4, gv4 ); + __m256i bxy = _mm256_add_epi16( bh4, bv4 ); + + __m256i rp0 = _mm256_add_epi16( rxy, ro3 ); + __m256i gp0 = _mm256_add_epi16( gxy, go3 ); + __m256i bp0 = _mm256_add_epi16( bxy, bo3 ); + + __m256i rp1 = _mm256_srai_epi16( rp0, 2 ); + __m256i gp1 = _mm256_srai_epi16( gp0, 2 ); + __m256i bp1 = _mm256_srai_epi16( bp0, 2 ); + + __m256i rp2 = _mm256_max_epi16( _mm256_min_epi16( rp1, _mm256_set1_epi16( 255 ) ), _mm256_setzero_si256() ); + __m256i gp2 = _mm256_max_epi16( _mm256_min_epi16( gp1, _mm256_set1_epi16( 255 ) ), _mm256_setzero_si256() ); + __m256i bp2 = _mm256_max_epi16( _mm256_min_epi16( bp1, _mm256_set1_epi16( 255 ) ), _mm256_setzero_si256() ); + + __m256i rdif = _mm256_sub_epi16( r08, rp2 ); + __m256i gdif = _mm256_sub_epi16( g08, gp2 ); + __m256i bdif = _mm256_sub_epi16( b08, bp2 ); + + __m256i rerr = _mm256_mullo_epi16( rdif, _mm256_set1_epi16( 38 ) ); + __m256i gerr = _mm256_mullo_epi16( gdif, _mm256_set1_epi16( 76 ) ); + __m256i berr = _mm256_mullo_epi16( bdif, _mm256_set1_epi16( 14 ) ); + + __m256i sum0 = _mm256_add_epi16( rerr, gerr ); + __m256i sum1 = _mm256_add_epi16( sum0, berr ); + + __m256i sum2 = _mm256_madd_epi16( sum1, sum1 ); + + __m128i sum3 = _mm_add_epi32( _mm256_castsi256_si128( sum2 ), _mm256_extracti128_si256( sum2, 1 ) ); + + uint32_t err0 = _mm_extract_epi32( sum3, 0 ); + uint32_t err1 = _mm_extract_epi32( sum3, 1 ); + uint32_t err2 = _mm_extract_epi32( sum3, 2 ); + uint32_t err3 = _mm_extract_epi32( sum3, 3 ); + + error = err0 + err1 + err2 + err3; + } + /**/ + + uint32_t rgbv = ( rgbv0 & 0x3F ) | ( ( rgbv0 >> 2 ) & 0x1FC0 ) | ( ( rgbv0 >> 3 ) & 0x7E000 ); + uint64_t rgbho0_ = ( rgbho & 0x3F0000003F ) | ( ( rgbho >> 2 ) & 0x1FC000001FC0 ) | ( ( rgbho >> 3 ) & 0x7E0000007E000 ); + uint64_t rgbho0 = ( rgbho0_ & 0x7FFFF ) | ( ( rgbho0_ >> 13 ) & 0x3FFFF80000 ); + + uint32_t hi = rgbv | ((rgbho0 & 0x1FFF) << 19); + rgbho0 >>= 13; + uint32_t lo = ( rgbho0 & 0x1 ) | ( ( rgbho0 & 0x1FE ) << 1 ) | ( ( rgbho0 & 0x600 ) << 2 ) | ( ( rgbho0 & 0x3F800 ) << 5 ) | ( ( rgbho0 & 0x1FC0000 ) << 6 ); + + uint32_t idx = ( ( rgbho >> 33 ) & 0xF ) | ( ( rgbho >> 41 ) & 0x10 ) | ( ( rgbho >> 48 ) & 0x20 ); + lo |= g_flags[idx]; + uint64_t result = static_cast(_bswap(lo)); + result |= static_cast(static_cast(_bswap(hi))) << 32; + + Plane plane; + + plane.plane = result; + if( useHeuristics ) + { + plane.error = 0; + mode = ModePlanar; + } + else + { + plane.error = error; + } + plane.sum4 = _mm256_permute4x64_epi64(srgb, _MM_SHUFFLE(2, 3, 0, 1)); + + return plane; +} + +static etcpak_force_inline uint64_t EncodeSelectors_AVX2( uint64_t d, const uint32_t terr[2][8], const uint32_t tsel[8], const bool rotate, const uint64_t value, const uint32_t error) noexcept +{ + size_t tidx[2]; + + // Get index of minimum error (terr[0] and terr[1]) + __m256i err0 = _mm256_load_si256((const __m256i*)terr[0]); + __m256i err1 = _mm256_load_si256((const __m256i*)terr[1]); + + __m256i errLo = _mm256_permute2x128_si256(err0, err1, (0) | (2 << 4)); + __m256i errHi = _mm256_permute2x128_si256(err0, err1, (1) | (3 << 4)); + + __m256i errMin0 = _mm256_min_epu32(errLo, errHi); + + __m256i errMin1 = _mm256_shuffle_epi32(errMin0, _MM_SHUFFLE(2, 3, 0, 1)); + __m256i errMin2 = _mm256_min_epu32(errMin0, errMin1); + + __m256i errMin3 = _mm256_shuffle_epi32(errMin2, _MM_SHUFFLE(1, 0, 3, 2)); + __m256i errMin4 = _mm256_min_epu32(errMin3, errMin2); + + __m256i errMin5 = _mm256_permute2x128_si256(errMin4, errMin4, (0) | (0 << 4)); + __m256i errMin6 = _mm256_permute2x128_si256(errMin4, errMin4, (1) | (1 << 4)); + + __m256i errMask0 = _mm256_cmpeq_epi32(errMin5, err0); + __m256i errMask1 = _mm256_cmpeq_epi32(errMin6, err1); + + uint32_t mask0 = _mm256_movemask_epi8(errMask0); + uint32_t mask1 = _mm256_movemask_epi8(errMask1); + + tidx[0] = _bit_scan_forward(mask0) >> 2; + tidx[1] = _bit_scan_forward(mask1) >> 2; + + if ((terr[0][tidx[0]] + terr[1][tidx[1]]) >= error) + { + return value; + } + + d |= tidx[0] << 26; + d |= tidx[1] << 29; + + unsigned int t0 = tsel[tidx[0]]; + unsigned int t1 = tsel[tidx[1]]; + + if (!rotate) + { + t0 &= 0xFF00FF00; + t1 &= 0x00FF00FF; + } + else + { + t0 &= 0xCCCCCCCC; + t1 &= 0x33333333; + } + + // Flip selectors from sign bit + unsigned int t2 = (t0 | t1) ^ 0xFFFF0000; + + return d | static_cast(_bswap(t2)) << 32; +} + +#endif + +static etcpak_force_inline void Average( const uint8_t* data, v4i* a ) +{ +#ifdef __SSE4_1__ + __m128i d0 = _mm_loadu_si128(((__m128i*)data) + 0); + __m128i d1 = _mm_loadu_si128(((__m128i*)data) + 1); + __m128i d2 = _mm_loadu_si128(((__m128i*)data) + 2); + __m128i d3 = _mm_loadu_si128(((__m128i*)data) + 3); + + __m128i d0l = _mm_unpacklo_epi8(d0, _mm_setzero_si128()); + __m128i d0h = _mm_unpackhi_epi8(d0, _mm_setzero_si128()); + __m128i d1l = _mm_unpacklo_epi8(d1, _mm_setzero_si128()); + __m128i d1h = _mm_unpackhi_epi8(d1, _mm_setzero_si128()); + __m128i d2l = _mm_unpacklo_epi8(d2, _mm_setzero_si128()); + __m128i d2h = _mm_unpackhi_epi8(d2, _mm_setzero_si128()); + __m128i d3l = _mm_unpacklo_epi8(d3, _mm_setzero_si128()); + __m128i d3h = _mm_unpackhi_epi8(d3, _mm_setzero_si128()); + + __m128i sum0 = _mm_add_epi16(d0l, d1l); + __m128i sum1 = _mm_add_epi16(d0h, d1h); + __m128i sum2 = _mm_add_epi16(d2l, d3l); + __m128i sum3 = _mm_add_epi16(d2h, d3h); + + __m128i sum0l = _mm_unpacklo_epi16(sum0, _mm_setzero_si128()); + __m128i sum0h = _mm_unpackhi_epi16(sum0, _mm_setzero_si128()); + __m128i sum1l = _mm_unpacklo_epi16(sum1, _mm_setzero_si128()); + __m128i sum1h = _mm_unpackhi_epi16(sum1, _mm_setzero_si128()); + __m128i sum2l = _mm_unpacklo_epi16(sum2, _mm_setzero_si128()); + __m128i sum2h = _mm_unpackhi_epi16(sum2, _mm_setzero_si128()); + __m128i sum3l = _mm_unpacklo_epi16(sum3, _mm_setzero_si128()); + __m128i sum3h = _mm_unpackhi_epi16(sum3, _mm_setzero_si128()); + + __m128i b0 = _mm_add_epi32(sum0l, sum0h); + __m128i b1 = _mm_add_epi32(sum1l, sum1h); + __m128i b2 = _mm_add_epi32(sum2l, sum2h); + __m128i b3 = _mm_add_epi32(sum3l, sum3h); + + __m128i a0 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b2, b3), _mm_set1_epi32(4)), 3); + __m128i a1 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b0, b1), _mm_set1_epi32(4)), 3); + __m128i a2 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b1, b3), _mm_set1_epi32(4)), 3); + __m128i a3 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b0, b2), _mm_set1_epi32(4)), 3); + + _mm_storeu_si128((__m128i*)&a[0], _mm_packus_epi32(_mm_shuffle_epi32(a0, _MM_SHUFFLE(3, 0, 1, 2)), _mm_shuffle_epi32(a1, _MM_SHUFFLE(3, 0, 1, 2)))); + _mm_storeu_si128((__m128i*)&a[2], _mm_packus_epi32(_mm_shuffle_epi32(a2, _MM_SHUFFLE(3, 0, 1, 2)), _mm_shuffle_epi32(a3, _MM_SHUFFLE(3, 0, 1, 2)))); +#elif defined __ARM_NEON + uint8x16x2_t t0 = vzipq_u8(vld1q_u8(data + 0), uint8x16_t()); + uint8x16x2_t t1 = vzipq_u8(vld1q_u8(data + 16), uint8x16_t()); + uint8x16x2_t t2 = vzipq_u8(vld1q_u8(data + 32), uint8x16_t()); + uint8x16x2_t t3 = vzipq_u8(vld1q_u8(data + 48), uint8x16_t()); + + uint16x8x2_t d0 = { vreinterpretq_u16_u8(t0.val[0]), vreinterpretq_u16_u8(t0.val[1]) }; + uint16x8x2_t d1 = { vreinterpretq_u16_u8(t1.val[0]), vreinterpretq_u16_u8(t1.val[1]) }; + uint16x8x2_t d2 = { vreinterpretq_u16_u8(t2.val[0]), vreinterpretq_u16_u8(t2.val[1]) }; + uint16x8x2_t d3 = { vreinterpretq_u16_u8(t3.val[0]), vreinterpretq_u16_u8(t3.val[1]) }; + + uint16x8x2_t s0 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d0.val[0] ), vreinterpretq_s16_u16( d1.val[0] ) ) ), uint16x8_t()); + uint16x8x2_t s1 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d0.val[1] ), vreinterpretq_s16_u16( d1.val[1] ) ) ), uint16x8_t()); + uint16x8x2_t s2 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d2.val[0] ), vreinterpretq_s16_u16( d3.val[0] ) ) ), uint16x8_t()); + uint16x8x2_t s3 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d2.val[1] ), vreinterpretq_s16_u16( d3.val[1] ) ) ), uint16x8_t()); + + uint32x4x2_t sum0 = { vreinterpretq_u32_u16(s0.val[0]), vreinterpretq_u32_u16(s0.val[1]) }; + uint32x4x2_t sum1 = { vreinterpretq_u32_u16(s1.val[0]), vreinterpretq_u32_u16(s1.val[1]) }; + uint32x4x2_t sum2 = { vreinterpretq_u32_u16(s2.val[0]), vreinterpretq_u32_u16(s2.val[1]) }; + uint32x4x2_t sum3 = { vreinterpretq_u32_u16(s3.val[0]), vreinterpretq_u32_u16(s3.val[1]) }; + + uint32x4_t b0 = vaddq_u32(sum0.val[0], sum0.val[1]); + uint32x4_t b1 = vaddq_u32(sum1.val[0], sum1.val[1]); + uint32x4_t b2 = vaddq_u32(sum2.val[0], sum2.val[1]); + uint32x4_t b3 = vaddq_u32(sum3.val[0], sum3.val[1]); + + uint32x4_t a0 = vshrq_n_u32(vqaddq_u32(vqaddq_u32(b2, b3), vdupq_n_u32(4)), 3); + uint32x4_t a1 = vshrq_n_u32(vqaddq_u32(vqaddq_u32(b0, b1), vdupq_n_u32(4)), 3); + uint32x4_t a2 = vshrq_n_u32(vqaddq_u32(vqaddq_u32(b1, b3), vdupq_n_u32(4)), 3); + uint32x4_t a3 = vshrq_n_u32(vqaddq_u32(vqaddq_u32(b0, b2), vdupq_n_u32(4)), 3); + + uint16x8_t o0 = vcombine_u16(vqmovun_s32(vreinterpretq_s32_u32( a0 )), vqmovun_s32(vreinterpretq_s32_u32( a1 ))); + uint16x8_t o1 = vcombine_u16(vqmovun_s32(vreinterpretq_s32_u32( a2 )), vqmovun_s32(vreinterpretq_s32_u32( a3 ))); + + a[0] = v4i{o0[2], o0[1], o0[0], 0}; + a[1] = v4i{o0[6], o0[5], o0[4], 0}; + a[2] = v4i{o1[2], o1[1], o1[0], 0}; + a[3] = v4i{o1[6], o1[5], o1[4], 0}; +#else + uint32_t r[4]; + uint32_t g[4]; + uint32_t b[4]; + + memset(r, 0, sizeof(r)); + memset(g, 0, sizeof(g)); + memset(b, 0, sizeof(b)); + + for( int j=0; j<4; j++ ) + { + for( int i=0; i<4; i++ ) + { + int index = (j & 2) + (i >> 1); + b[index] += *data++; + g[index] += *data++; + r[index] += *data++; + data++; + } + } + + a[0] = v4i{ uint16_t( (r[2] + r[3] + 4) / 8 ), uint16_t( (g[2] + g[3] + 4) / 8 ), uint16_t( (b[2] + b[3] + 4) / 8 ), 0}; + a[1] = v4i{ uint16_t( (r[0] + r[1] + 4) / 8 ), uint16_t( (g[0] + g[1] + 4) / 8 ), uint16_t( (b[0] + b[1] + 4) / 8 ), 0}; + a[2] = v4i{ uint16_t( (r[1] + r[3] + 4) / 8 ), uint16_t( (g[1] + g[3] + 4) / 8 ), uint16_t( (b[1] + b[3] + 4) / 8 ), 0}; + a[3] = v4i{ uint16_t( (r[0] + r[2] + 4) / 8 ), uint16_t( (g[0] + g[2] + 4) / 8 ), uint16_t( (b[0] + b[2] + 4) / 8 ), 0}; +#endif +} + +static etcpak_force_inline void CalcErrorBlock( const uint8_t* data, unsigned int err[4][4] ) +{ +#ifdef __SSE4_1__ + __m128i d0 = _mm_loadu_si128(((__m128i*)data) + 0); + __m128i d1 = _mm_loadu_si128(((__m128i*)data) + 1); + __m128i d2 = _mm_loadu_si128(((__m128i*)data) + 2); + __m128i d3 = _mm_loadu_si128(((__m128i*)data) + 3); + + __m128i dm0 = _mm_and_si128(d0, _mm_set1_epi32(0x00FFFFFF)); + __m128i dm1 = _mm_and_si128(d1, _mm_set1_epi32(0x00FFFFFF)); + __m128i dm2 = _mm_and_si128(d2, _mm_set1_epi32(0x00FFFFFF)); + __m128i dm3 = _mm_and_si128(d3, _mm_set1_epi32(0x00FFFFFF)); + + __m128i d0l = _mm_unpacklo_epi8(dm0, _mm_setzero_si128()); + __m128i d0h = _mm_unpackhi_epi8(dm0, _mm_setzero_si128()); + __m128i d1l = _mm_unpacklo_epi8(dm1, _mm_setzero_si128()); + __m128i d1h = _mm_unpackhi_epi8(dm1, _mm_setzero_si128()); + __m128i d2l = _mm_unpacklo_epi8(dm2, _mm_setzero_si128()); + __m128i d2h = _mm_unpackhi_epi8(dm2, _mm_setzero_si128()); + __m128i d3l = _mm_unpacklo_epi8(dm3, _mm_setzero_si128()); + __m128i d3h = _mm_unpackhi_epi8(dm3, _mm_setzero_si128()); + + __m128i sum0 = _mm_add_epi16(d0l, d1l); + __m128i sum1 = _mm_add_epi16(d0h, d1h); + __m128i sum2 = _mm_add_epi16(d2l, d3l); + __m128i sum3 = _mm_add_epi16(d2h, d3h); + + __m128i sum0l = _mm_unpacklo_epi16(sum0, _mm_setzero_si128()); + __m128i sum0h = _mm_unpackhi_epi16(sum0, _mm_setzero_si128()); + __m128i sum1l = _mm_unpacklo_epi16(sum1, _mm_setzero_si128()); + __m128i sum1h = _mm_unpackhi_epi16(sum1, _mm_setzero_si128()); + __m128i sum2l = _mm_unpacklo_epi16(sum2, _mm_setzero_si128()); + __m128i sum2h = _mm_unpackhi_epi16(sum2, _mm_setzero_si128()); + __m128i sum3l = _mm_unpacklo_epi16(sum3, _mm_setzero_si128()); + __m128i sum3h = _mm_unpackhi_epi16(sum3, _mm_setzero_si128()); + + __m128i b0 = _mm_add_epi32(sum0l, sum0h); + __m128i b1 = _mm_add_epi32(sum1l, sum1h); + __m128i b2 = _mm_add_epi32(sum2l, sum2h); + __m128i b3 = _mm_add_epi32(sum3l, sum3h); + + __m128i a0 = _mm_add_epi32(b2, b3); + __m128i a1 = _mm_add_epi32(b0, b1); + __m128i a2 = _mm_add_epi32(b1, b3); + __m128i a3 = _mm_add_epi32(b0, b2); + + _mm_storeu_si128((__m128i*)&err[0], a0); + _mm_storeu_si128((__m128i*)&err[1], a1); + _mm_storeu_si128((__m128i*)&err[2], a2); + _mm_storeu_si128((__m128i*)&err[3], a3); +#elif defined __ARM_NEON + uint8x16x2_t t0 = vzipq_u8(vld1q_u8(data + 0), uint8x16_t()); + uint8x16x2_t t1 = vzipq_u8(vld1q_u8(data + 16), uint8x16_t()); + uint8x16x2_t t2 = vzipq_u8(vld1q_u8(data + 32), uint8x16_t()); + uint8x16x2_t t3 = vzipq_u8(vld1q_u8(data + 48), uint8x16_t()); + + uint16x8x2_t d0 = { vreinterpretq_u16_u8(t0.val[0]), vreinterpretq_u16_u8(t0.val[1]) }; + uint16x8x2_t d1 = { vreinterpretq_u16_u8(t1.val[0]), vreinterpretq_u16_u8(t1.val[1]) }; + uint16x8x2_t d2 = { vreinterpretq_u16_u8(t2.val[0]), vreinterpretq_u16_u8(t2.val[1]) }; + uint16x8x2_t d3 = { vreinterpretq_u16_u8(t3.val[0]), vreinterpretq_u16_u8(t3.val[1]) }; + + uint16x8x2_t s0 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d0.val[0] ), vreinterpretq_s16_u16( d1.val[0] ))), uint16x8_t()); + uint16x8x2_t s1 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d0.val[1] ), vreinterpretq_s16_u16( d1.val[1] ))), uint16x8_t()); + uint16x8x2_t s2 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d2.val[0] ), vreinterpretq_s16_u16( d3.val[0] ))), uint16x8_t()); + uint16x8x2_t s3 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d2.val[1] ), vreinterpretq_s16_u16( d3.val[1] ))), uint16x8_t()); + + uint32x4x2_t sum0 = { vreinterpretq_u32_u16(s0.val[0]), vreinterpretq_u32_u16(s0.val[1]) }; + uint32x4x2_t sum1 = { vreinterpretq_u32_u16(s1.val[0]), vreinterpretq_u32_u16(s1.val[1]) }; + uint32x4x2_t sum2 = { vreinterpretq_u32_u16(s2.val[0]), vreinterpretq_u32_u16(s2.val[1]) }; + uint32x4x2_t sum3 = { vreinterpretq_u32_u16(s3.val[0]), vreinterpretq_u32_u16(s3.val[1]) }; + + uint32x4_t b0 = vaddq_u32(sum0.val[0], sum0.val[1]); + uint32x4_t b1 = vaddq_u32(sum1.val[0], sum1.val[1]); + uint32x4_t b2 = vaddq_u32(sum2.val[0], sum2.val[1]); + uint32x4_t b3 = vaddq_u32(sum3.val[0], sum3.val[1]); + + uint32x4_t a0 = vreinterpretq_u32_u8( vandq_u8(vreinterpretq_u8_u32( vqaddq_u32(b2, b3) ), vreinterpretq_u8_u32( vdupq_n_u32(0x00FFFFFF)) ) ); + uint32x4_t a1 = vreinterpretq_u32_u8( vandq_u8(vreinterpretq_u8_u32( vqaddq_u32(b0, b1) ), vreinterpretq_u8_u32( vdupq_n_u32(0x00FFFFFF)) ) ); + uint32x4_t a2 = vreinterpretq_u32_u8( vandq_u8(vreinterpretq_u8_u32( vqaddq_u32(b1, b3) ), vreinterpretq_u8_u32( vdupq_n_u32(0x00FFFFFF)) ) ); + uint32x4_t a3 = vreinterpretq_u32_u8( vandq_u8(vreinterpretq_u8_u32( vqaddq_u32(b0, b2) ), vreinterpretq_u8_u32( vdupq_n_u32(0x00FFFFFF)) ) ); + + vst1q_u32(err[0], a0); + vst1q_u32(err[1], a1); + vst1q_u32(err[2], a2); + vst1q_u32(err[3], a3); +#else + unsigned int terr[4][4]; + + memset(terr, 0, 16 * sizeof(unsigned int)); + + for( int j=0; j<4; j++ ) + { + for( int i=0; i<4; i++ ) + { + int index = (j & 2) + (i >> 1); + unsigned int d = *data++; + terr[index][0] += d; + d = *data++; + terr[index][1] += d; + d = *data++; + terr[index][2] += d; + data++; + } + } + + for( int i=0; i<3; i++ ) + { + err[0][i] = terr[2][i] + terr[3][i]; + err[1][i] = terr[0][i] + terr[1][i]; + err[2][i] = terr[1][i] + terr[3][i]; + err[3][i] = terr[0][i] + terr[2][i]; + } + for( int i=0; i<4; i++ ) + { + err[i][3] = 0; + } +#endif +} + +static etcpak_force_inline unsigned int CalcError( const unsigned int block[4], const v4i& average ) +{ + unsigned int err = 0x3FFFFFFF; // Big value to prevent negative values, but small enough to prevent overflow + err -= block[0] * 2 * average[2]; + err -= block[1] * 2 * average[1]; + err -= block[2] * 2 * average[0]; + err += 8 * ( sq( average[0] ) + sq( average[1] ) + sq( average[2] ) ); + return err; +} + +static etcpak_force_inline void ProcessAverages( v4i* a ) +{ +#ifdef __SSE4_1__ + for( int i=0; i<2; i++ ) + { + __m128i d = _mm_loadu_si128((__m128i*)a[i*2].data()); + + __m128i t = _mm_add_epi16(_mm_mullo_epi16(d, _mm_set1_epi16(31)), _mm_set1_epi16(128)); + + __m128i c = _mm_srli_epi16(_mm_add_epi16(t, _mm_srli_epi16(t, 8)), 8); + + __m128i c1 = _mm_shuffle_epi32(c, _MM_SHUFFLE(3, 2, 3, 2)); + __m128i diff = _mm_sub_epi16(c, c1); + diff = _mm_max_epi16(diff, _mm_set1_epi16(-4)); + diff = _mm_min_epi16(diff, _mm_set1_epi16(3)); + + __m128i co = _mm_add_epi16(c1, diff); + + c = _mm_blend_epi16(co, c, 0xF0); + + __m128i a0 = _mm_or_si128(_mm_slli_epi16(c, 3), _mm_srli_epi16(c, 2)); + + _mm_storeu_si128((__m128i*)a[4+i*2].data(), a0); + } + + for( int i=0; i<2; i++ ) + { + __m128i d = _mm_loadu_si128((__m128i*)a[i*2].data()); + + __m128i t0 = _mm_add_epi16(_mm_mullo_epi16(d, _mm_set1_epi16(15)), _mm_set1_epi16(128)); + __m128i t1 = _mm_srli_epi16(_mm_add_epi16(t0, _mm_srli_epi16(t0, 8)), 8); + + __m128i t2 = _mm_or_si128(t1, _mm_slli_epi16(t1, 4)); + + _mm_storeu_si128((__m128i*)a[i*2].data(), t2); + } +#elif defined __ARM_NEON + for( int i=0; i<2; i++ ) + { + int16x8_t d = vld1q_s16((int16_t*)&a[i*2]); + int16x8_t t = vaddq_s16(vmulq_s16(d, vdupq_n_s16(31)), vdupq_n_s16(128)); + int16x8_t c = vshrq_n_s16(vaddq_s16(t, vshrq_n_s16(t, 8)), 8); + + int16x8_t c1 = vcombine_s16(vget_high_s16(c), vget_high_s16(c)); + int16x8_t diff = vsubq_s16(c, c1); + diff = vmaxq_s16(diff, vdupq_n_s16(-4)); + diff = vminq_s16(diff, vdupq_n_s16(3)); + + int16x8_t co = vaddq_s16(c1, diff); + + c = vcombine_s16(vget_low_s16(co), vget_high_s16(c)); + + int16x8_t a0 = vorrq_s16(vshlq_n_s16(c, 3), vshrq_n_s16(c, 2)); + + vst1q_s16((int16_t*)&a[4+i*2], a0); + } + + for( int i=0; i<2; i++ ) + { + int16x8_t d = vld1q_s16((int16_t*)&a[i*2]); + + int16x8_t t0 = vaddq_s16(vmulq_s16(d, vdupq_n_s16(15)), vdupq_n_s16(128)); + int16x8_t t1 = vshrq_n_s16(vaddq_s16(t0, vshrq_n_s16(t0, 8)), 8); + + int16x8_t t2 = vorrq_s16(t1, vshlq_n_s16(t1, 4)); + + vst1q_s16((int16_t*)&a[i*2], t2); + } +#else + for( int i=0; i<2; i++ ) + { + for( int j=0; j<3; j++ ) + { + int32_t c1 = mul8bit( a[i*2+1][j], 31 ); + int32_t c2 = mul8bit( a[i*2][j], 31 ); + + int32_t diff = c2 - c1; + if( diff > 3 ) diff = 3; + else if( diff < -4 ) diff = -4; + + int32_t co = c1 + diff; + + a[5+i*2][j] = ( c1 << 3 ) | ( c1 >> 2 ); + a[4+i*2][j] = ( co << 3 ) | ( co >> 2 ); + } + } + + for( int i=0; i<4; i++ ) + { + a[i][0] = g_avg2[mul8bit( a[i][0], 15 )]; + a[i][1] = g_avg2[mul8bit( a[i][1], 15 )]; + a[i][2] = g_avg2[mul8bit( a[i][2], 15 )]; + } +#endif +} + +static etcpak_force_inline void EncodeAverages( uint64_t& _d, const v4i* a, size_t idx ) +{ + auto d = _d; + d |= ( idx << 24 ); + size_t base = idx << 1; + + if( ( idx & 0x2 ) == 0 ) + { + for( int i=0; i<3; i++ ) + { + d |= uint64_t( a[base+0][i] >> 4 ) << ( i*8 ); + d |= uint64_t( a[base+1][i] >> 4 ) << ( i*8 + 4 ); + } + } + else + { + for( int i=0; i<3; i++ ) + { + d |= uint64_t( a[base+1][i] & 0xF8 ) << ( i*8 ); + int32_t c = ( ( a[base+0][i] & 0xF8 ) - ( a[base+1][i] & 0xF8 ) ) >> 3; + c &= ~0xFFFFFFF8; + d |= ((uint64_t)c) << ( i*8 ); + } + } + _d = d; +} + +static etcpak_force_inline uint64_t CheckSolid( const uint8_t* src ) +{ +#ifdef __SSE4_1__ + __m128i d0 = _mm_loadu_si128(((__m128i*)src) + 0); + __m128i d1 = _mm_loadu_si128(((__m128i*)src) + 1); + __m128i d2 = _mm_loadu_si128(((__m128i*)src) + 2); + __m128i d3 = _mm_loadu_si128(((__m128i*)src) + 3); + + __m128i c = _mm_shuffle_epi32(d0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m128i c0 = _mm_cmpeq_epi8(d0, c); + __m128i c1 = _mm_cmpeq_epi8(d1, c); + __m128i c2 = _mm_cmpeq_epi8(d2, c); + __m128i c3 = _mm_cmpeq_epi8(d3, c); + + __m128i m0 = _mm_and_si128(c0, c1); + __m128i m1 = _mm_and_si128(c2, c3); + __m128i m = _mm_and_si128(m0, m1); + + if (!_mm_testc_si128(m, _mm_set1_epi32(-1))) + { + return 0; + } +#elif defined __ARM_NEON + int32x4_t d0 = vld1q_s32((int32_t*)src + 0); + int32x4_t d1 = vld1q_s32((int32_t*)src + 4); + int32x4_t d2 = vld1q_s32((int32_t*)src + 8); + int32x4_t d3 = vld1q_s32((int32_t*)src + 12); + + int32x4_t c = vdupq_n_s32(d0[0]); + + int32x4_t c0 = vreinterpretq_s32_u32(vceqq_s32(d0, c)); + int32x4_t c1 = vreinterpretq_s32_u32(vceqq_s32(d1, c)); + int32x4_t c2 = vreinterpretq_s32_u32(vceqq_s32(d2, c)); + int32x4_t c3 = vreinterpretq_s32_u32(vceqq_s32(d3, c)); + + int32x4_t m0 = vandq_s32(c0, c1); + int32x4_t m1 = vandq_s32(c2, c3); + int64x2_t m = vreinterpretq_s64_s32(vandq_s32(m0, m1)); + + if (m[0] != -1 || m[1] != -1) + { + return 0; + } +#else + const uint8_t* ptr = src + 4; + for( int i=1; i<16; i++ ) + { + if( memcmp( src, ptr, 4 ) != 0 ) + { + return 0; + } + ptr += 4; + } +#endif + return 0x02000000 | + ( (unsigned int)( src[0] & 0xF8 ) << 16 ) | + ( (unsigned int)( src[1] & 0xF8 ) << 8 ) | + ( (unsigned int)( src[2] & 0xF8 ) ); +} + +static etcpak_force_inline void PrepareAverages( v4i a[8], const uint8_t* src, unsigned int err[4] ) +{ + Average( src, a ); + ProcessAverages( a ); + + unsigned int errblock[4][4]; + CalcErrorBlock( src, errblock ); + + for( int i=0; i<4; i++ ) + { + err[i/2] += CalcError( errblock[i], a[i] ); + err[2+i/2] += CalcError( errblock[i], a[i+4] ); + } +} + +static etcpak_force_inline void FindBestFit( uint64_t terr[2][8], uint16_t tsel[16][8], v4i a[8], const uint32_t* id, const uint8_t* data ) +{ + for( size_t i=0; i<16; i++ ) + { + uint16_t* sel = tsel[i]; + unsigned int bid = id[i]; + uint64_t* ter = terr[bid%2]; + + uint8_t b = *data++; + uint8_t g = *data++; + uint8_t r = *data++; + data++; + + int dr = a[bid][0] - r; + int dg = a[bid][1] - g; + int db = a[bid][2] - b; + +#ifdef __SSE4_1__ + // Reference implementation + + __m128i pix = _mm_set1_epi32(dr * 77 + dg * 151 + db * 28); + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + __m128i error0 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[0])); + __m128i error1 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[1])); + __m128i error2 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[0])); + __m128i error3 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[1])); + + __m128i index0 = _mm_and_si128(_mm_cmplt_epi32(error1, error0), _mm_set1_epi32(1)); + __m128i minError0 = _mm_min_epi32(error0, error1); + + __m128i index1 = _mm_sub_epi32(_mm_set1_epi32(2), _mm_cmplt_epi32(error3, error2)); + __m128i minError1 = _mm_min_epi32(error2, error3); + + __m128i minIndex0 = _mm_blendv_epi8(index0, index1, _mm_cmplt_epi32(minError1, minError0)); + __m128i minError = _mm_min_epi32(minError0, minError1); + + // Squaring the minimum error to produce correct values when adding + __m128i minErrorLow = _mm_shuffle_epi32(minError, _MM_SHUFFLE(1, 1, 0, 0)); + __m128i squareErrorLow = _mm_mul_epi32(minErrorLow, minErrorLow); + squareErrorLow = _mm_add_epi64(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 0)); + _mm_storeu_si128(((__m128i*)ter) + 0, squareErrorLow); + __m128i minErrorHigh = _mm_shuffle_epi32(minError, _MM_SHUFFLE(3, 3, 2, 2)); + __m128i squareErrorHigh = _mm_mul_epi32(minErrorHigh, minErrorHigh); + squareErrorHigh = _mm_add_epi64(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 1)); + _mm_storeu_si128(((__m128i*)ter) + 1, squareErrorHigh); + + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + error0 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[2])); + error1 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[3])); + error2 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[2])); + error3 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[3])); + + index0 = _mm_and_si128(_mm_cmplt_epi32(error1, error0), _mm_set1_epi32(1)); + minError0 = _mm_min_epi32(error0, error1); + + index1 = _mm_sub_epi32(_mm_set1_epi32(2), _mm_cmplt_epi32(error3, error2)); + minError1 = _mm_min_epi32(error2, error3); + + __m128i minIndex1 = _mm_blendv_epi8(index0, index1, _mm_cmplt_epi32(minError1, minError0)); + minError = _mm_min_epi32(minError0, minError1); + + // Squaring the minimum error to produce correct values when adding + minErrorLow = _mm_shuffle_epi32(minError, _MM_SHUFFLE(1, 1, 0, 0)); + squareErrorLow = _mm_mul_epi32(minErrorLow, minErrorLow); + squareErrorLow = _mm_add_epi64(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 2)); + _mm_storeu_si128(((__m128i*)ter) + 2, squareErrorLow); + minErrorHigh = _mm_shuffle_epi32(minError, _MM_SHUFFLE(3, 3, 2, 2)); + squareErrorHigh = _mm_mul_epi32(minErrorHigh, minErrorHigh); + squareErrorHigh = _mm_add_epi64(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 3)); + _mm_storeu_si128(((__m128i*)ter) + 3, squareErrorHigh); + __m128i minIndex = _mm_packs_epi32(minIndex0, minIndex1); + _mm_storeu_si128((__m128i*)sel, minIndex); +#elif defined __ARM_NEON + int32x4_t pix = vdupq_n_s32(dr * 77 + dg * 151 + db * 28); + + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + uint32x4_t error0 = vreinterpretq_u32_s32(vabsq_s32(vaddq_s32(pix, g_table256_NEON[0]))); + uint32x4_t error1 = vreinterpretq_u32_s32(vabsq_s32(vaddq_s32(pix, g_table256_NEON[1]))); + uint32x4_t error2 = vreinterpretq_u32_s32(vabsq_s32(vsubq_s32(pix, g_table256_NEON[0]))); + uint32x4_t error3 = vreinterpretq_u32_s32(vabsq_s32(vsubq_s32(pix, g_table256_NEON[1]))); + + uint32x4_t index0 = vandq_u32(vcltq_u32(error1, error0), vdupq_n_u32(1)); + uint32x4_t minError0 = vminq_u32(error0, error1); + + uint32x4_t index1 = vreinterpretq_u32_s32(vsubq_s32(vdupq_n_s32(2), vreinterpretq_s32_u32(vcltq_u32(error3, error2)))); + uint32x4_t minError1 = vminq_u32(error2, error3); + + uint32x4_t blendMask = vcltq_u32(minError1, minError0); + uint32x4_t minIndex0 = vorrq_u32(vbicq_u32(index0, blendMask), vandq_u32(index1, blendMask)); + uint32x4_t minError = vminq_u32(minError0, minError1); + + // Squaring the minimum error to produce correct values when adding + uint32x4_t squareErrorLow = vmulq_u32(minError, minError); + uint32x4_t squareErrorHigh = vshrq_n_u32(vreinterpretq_u32_s32(vqdmulhq_s32(vreinterpretq_s32_u32(minError), vreinterpretq_s32_u32(minError))), 1); + uint32x4x2_t squareErrorZip = vzipq_u32(squareErrorLow, squareErrorHigh); + uint64x2x2_t squareError = { vreinterpretq_u64_u32(squareErrorZip.val[0]), vreinterpretq_u64_u32(squareErrorZip.val[1]) }; + squareError.val[0] = vaddq_u64(squareError.val[0], vld1q_u64(ter + 0)); + squareError.val[1] = vaddq_u64(squareError.val[1], vld1q_u64(ter + 2)); + vst1q_u64(ter + 0, squareError.val[0]); + vst1q_u64(ter + 2, squareError.val[1]); + + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + error0 = vreinterpretq_u32_s32( vabsq_s32(vaddq_s32(pix, g_table256_NEON[2]))); + error1 = vreinterpretq_u32_s32( vabsq_s32(vaddq_s32(pix, g_table256_NEON[3]))); + error2 = vreinterpretq_u32_s32( vabsq_s32(vsubq_s32(pix, g_table256_NEON[2]))); + error3 = vreinterpretq_u32_s32( vabsq_s32(vsubq_s32(pix, g_table256_NEON[3]))); + + index0 = vandq_u32(vcltq_u32(error1, error0), vdupq_n_u32(1)); + minError0 = vminq_u32(error0, error1); + + index1 = vreinterpretq_u32_s32( vsubq_s32(vdupq_n_s32(2), vreinterpretq_s32_u32(vcltq_u32(error3, error2))) ); + minError1 = vminq_u32(error2, error3); + + blendMask = vcltq_u32(minError1, minError0); + uint32x4_t minIndex1 = vorrq_u32(vbicq_u32(index0, blendMask), vandq_u32(index1, blendMask)); + minError = vminq_u32(minError0, minError1); + + // Squaring the minimum error to produce correct values when adding + squareErrorLow = vmulq_u32(minError, minError); + squareErrorHigh = vshrq_n_u32(vreinterpretq_u32_s32( vqdmulhq_s32(vreinterpretq_s32_u32(minError), vreinterpretq_s32_u32(minError)) ), 1 ); + squareErrorZip = vzipq_u32(squareErrorLow, squareErrorHigh); + squareError.val[0] = vaddq_u64(vreinterpretq_u64_u32( squareErrorZip.val[0] ), vld1q_u64(ter + 4)); + squareError.val[1] = vaddq_u64(vreinterpretq_u64_u32( squareErrorZip.val[1] ), vld1q_u64(ter + 6)); + vst1q_u64(ter + 4, squareError.val[0]); + vst1q_u64(ter + 6, squareError.val[1]); + + uint16x8_t minIndex = vcombine_u16(vqmovn_u32(minIndex0), vqmovn_u32(minIndex1)); + vst1q_u16(sel, minIndex); +#else + int pix = dr * 77 + dg * 151 + db * 28; + + for( int t=0; t<8; t++ ) + { + const int64_t* tab = g_table256[t]; + unsigned int idx = 0; + uint64_t err = sq( tab[0] + pix ); + for( int j=1; j<4; j++ ) + { + uint64_t local = sq( tab[j] + pix ); + if( local < err ) + { + err = local; + idx = j; + } + } + *sel++ = idx; + *ter++ += err; + } +#endif + } +} + +#if defined __SSE4_1__ || defined __ARM_NEON +// Non-reference implementation, but faster. Produces same results as the AVX2 version +static etcpak_force_inline void FindBestFit( uint32_t terr[2][8], uint16_t tsel[16][8], v4i a[8], const uint32_t* id, const uint8_t* data ) +{ + for( size_t i=0; i<16; i++ ) + { + uint16_t* sel = tsel[i]; + unsigned int bid = id[i]; + uint32_t* ter = terr[bid%2]; + + uint8_t b = *data++; + uint8_t g = *data++; + uint8_t r = *data++; + data++; + + int dr = a[bid][0] - r; + int dg = a[bid][1] - g; + int db = a[bid][2] - b; + +#ifdef __SSE4_1__ + // The scaling values are divided by two and rounded, to allow the differences to be in the range of signed int16 + // This produces slightly different results, but is significant faster + __m128i pixel = _mm_set1_epi16(dr * 38 + dg * 76 + db * 14); + __m128i pix = _mm_abs_epi16(pixel); + + // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same. + // Since the selector table is symmetrical, we need to calculate the difference only for half of the entries. + __m128i error0 = _mm_abs_epi16(_mm_sub_epi16(pix, g_table128_SIMD[0])); + __m128i error1 = _mm_abs_epi16(_mm_sub_epi16(pix, g_table128_SIMD[1])); + + __m128i index = _mm_and_si128(_mm_cmplt_epi16(error1, error0), _mm_set1_epi16(1)); + __m128i minError = _mm_min_epi16(error0, error1); + + // Exploiting symmetry of the selector table and use the sign bit + // This produces slightly different results, but is needed to produce same results as AVX2 implementation + __m128i indexBit = _mm_andnot_si128(_mm_srli_epi16(pixel, 15), _mm_set1_epi8(-1)); + __m128i minIndex = _mm_or_si128(index, _mm_add_epi16(indexBit, indexBit)); + + // Squaring the minimum error to produce correct values when adding + __m128i squareErrorLo = _mm_mullo_epi16(minError, minError); + __m128i squareErrorHi = _mm_mulhi_epi16(minError, minError); + + __m128i squareErrorLow = _mm_unpacklo_epi16(squareErrorLo, squareErrorHi); + __m128i squareErrorHigh = _mm_unpackhi_epi16(squareErrorLo, squareErrorHi); + + squareErrorLow = _mm_add_epi32(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 0)); + _mm_storeu_si128(((__m128i*)ter) + 0, squareErrorLow); + squareErrorHigh = _mm_add_epi32(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 1)); + _mm_storeu_si128(((__m128i*)ter) + 1, squareErrorHigh); + + _mm_storeu_si128((__m128i*)sel, minIndex); +#elif defined __ARM_NEON + int16x8_t pixel = vdupq_n_s16( dr * 38 + dg * 76 + db * 14 ); + int16x8_t pix = vabsq_s16( pixel ); + + int16x8_t error0 = vabsq_s16( vsubq_s16( pix, g_table128_NEON[0] ) ); + int16x8_t error1 = vabsq_s16( vsubq_s16( pix, g_table128_NEON[1] ) ); + + int16x8_t index = vandq_s16( vreinterpretq_s16_u16( vcltq_s16( error1, error0 ) ), vdupq_n_s16( 1 ) ); + int16x8_t minError = vminq_s16( error0, error1 ); + + int16x8_t indexBit = vandq_s16( vmvnq_s16( vshrq_n_s16( pixel, 15 ) ), vdupq_n_s16( -1 ) ); + int16x8_t minIndex = vorrq_s16( index, vaddq_s16( indexBit, indexBit ) ); + + int16x4_t minErrorLow = vget_low_s16( minError ); + int16x4_t minErrorHigh = vget_high_s16( minError ); + + int32x4_t squareErrorLow = vmull_s16( minErrorLow, minErrorLow ); + int32x4_t squareErrorHigh = vmull_s16( minErrorHigh, minErrorHigh ); + + int32x4_t squareErrorSumLow = vaddq_s32( squareErrorLow, vld1q_s32( (int32_t*)ter ) ); + int32x4_t squareErrorSumHigh = vaddq_s32( squareErrorHigh, vld1q_s32( (int32_t*)ter + 4 ) ); + + vst1q_s32( (int32_t*)ter, squareErrorSumLow ); + vst1q_s32( (int32_t*)ter + 4, squareErrorSumHigh ); + + vst1q_s16( (int16_t*)sel, minIndex ); +#endif + } +} +#endif + +static etcpak_force_inline uint8_t convert6(float f) +{ + int i = (std::min(std::max(static_cast(f), 0), 1023) - 15) >> 1; + return (i + 11 - ((i + 11) >> 7) - ((i + 4) >> 7)) >> 3; +} + +static etcpak_force_inline uint8_t convert7(float f) +{ + int i = (std::min(std::max(static_cast(f), 0), 1023) - 15) >> 1; + return (i + 9 - ((i + 9) >> 8) - ((i + 6) >> 8)) >> 2; +} + +static etcpak_force_inline std::pair Planar( const uint8_t* src, const uint8_t mode, bool useHeuristics ) +{ + int32_t r = 0; + int32_t g = 0; + int32_t b = 0; + + for( int i = 0; i < 16; ++i ) + { + b += src[i * 4 + 0]; + g += src[i * 4 + 1]; + r += src[i * 4 + 2]; + } + + int32_t difRyz = 0; + int32_t difGyz = 0; + int32_t difByz = 0; + int32_t difRxz = 0; + int32_t difGxz = 0; + int32_t difBxz = 0; + + const int32_t scaling[] = { -255, -85, 85, 255 }; + + for (int i = 0; i < 16; ++i) + { + int32_t difB = (static_cast(src[i * 4 + 0]) << 4) - b; + int32_t difG = (static_cast(src[i * 4 + 1]) << 4) - g; + int32_t difR = (static_cast(src[i * 4 + 2]) << 4) - r; + + difRyz += difR * scaling[i % 4]; + difGyz += difG * scaling[i % 4]; + difByz += difB * scaling[i % 4]; + + difRxz += difR * scaling[i / 4]; + difGxz += difG * scaling[i / 4]; + difBxz += difB * scaling[i / 4]; + } + + const float scale = -4.0f / ((255 * 255 * 8.0f + 85 * 85 * 8.0f) * 16.0f); + + float aR = difRxz * scale; + float aG = difGxz * scale; + float aB = difBxz * scale; + + float bR = difRyz * scale; + float bG = difGyz * scale; + float bB = difByz * scale; + + float dR = r * (4.0f / 16.0f); + float dG = g * (4.0f / 16.0f); + float dB = b * (4.0f / 16.0f); + + // calculating the three colors RGBO, RGBH, and RGBV. RGB = df - af * x - bf * y; + float cofR = std::fma(aR, 255.0f, std::fma(bR, 255.0f, dR)); + float cofG = std::fma(aG, 255.0f, std::fma(bG, 255.0f, dG)); + float cofB = std::fma(aB, 255.0f, std::fma(bB, 255.0f, dB)); + float chfR = std::fma(aR, -425.0f, std::fma(bR, 255.0f, dR)); + float chfG = std::fma(aG, -425.0f, std::fma(bG, 255.0f, dG)); + float chfB = std::fma(aB, -425.0f, std::fma(bB, 255.0f, dB)); + float cvfR = std::fma(aR, 255.0f, std::fma(bR, -425.0f, dR)); + float cvfG = std::fma(aG, 255.0f, std::fma(bG, -425.0f, dG)); + float cvfB = std::fma(aB, 255.0f, std::fma(bB, -425.0f, dB)); + + // convert to r6g7b6 + int32_t coR = convert6(cofR); + int32_t coG = convert7(cofG); + int32_t coB = convert6(cofB); + int32_t chR = convert6(chfR); + int32_t chG = convert7(chfG); + int32_t chB = convert6(chfB); + int32_t cvR = convert6(cvfR); + int32_t cvG = convert7(cvfG); + int32_t cvB = convert6(cvfB); + + // Error calculation + uint64_t error = 0; + if( ModePlanar != mode && useHeuristics ) + { + auto ro0 = coR; + auto go0 = coG; + auto bo0 = coB; + auto ro1 = ( ro0 >> 4 ) | ( ro0 << 2 ); + auto go1 = ( go0 >> 6 ) | ( go0 << 1 ); + auto bo1 = ( bo0 >> 4 ) | ( bo0 << 2 ); + auto ro2 = ( ro1 << 2 ) + 2; + auto go2 = ( go1 << 2 ) + 2; + auto bo2 = ( bo1 << 2 ) + 2; + + auto rh0 = chR; + auto gh0 = chG; + auto bh0 = chB; + auto rh1 = ( rh0 >> 4 ) | ( rh0 << 2 ); + auto gh1 = ( gh0 >> 6 ) | ( gh0 << 1 ); + auto bh1 = ( bh0 >> 4 ) | ( bh0 << 2 ); + + auto rh2 = rh1 - ro1; + auto gh2 = gh1 - go1; + auto bh2 = bh1 - bo1; + + auto rv0 = cvR; + auto gv0 = cvG; + auto bv0 = cvB; + auto rv1 = ( rv0 >> 4 ) | ( rv0 << 2 ); + auto gv1 = ( gv0 >> 6 ) | ( gv0 << 1 ); + auto bv1 = ( bv0 >> 4 ) | ( bv0 << 2 ); + + auto rv2 = rv1 - ro1; + auto gv2 = gv1 - go1; + auto bv2 = bv1 - bo1; + for( int i = 0; i < 16; ++i ) + { + int32_t cR = clampu8( ( rh2 * ( i / 4 ) + rv2 * ( i % 4 ) + ro2 ) >> 2 ); + int32_t cG = clampu8( ( gh2 * ( i / 4 ) + gv2 * ( i % 4 ) + go2 ) >> 2 ); + int32_t cB = clampu8( ( bh2 * ( i / 4 ) + bv2 * ( i % 4 ) + bo2 ) >> 2 ); + + int32_t difB = static_cast( src[i * 4 + 0] ) - cB; + int32_t difG = static_cast( src[i * 4 + 1] ) - cG; + int32_t difR = static_cast( src[i * 4 + 2] ) - cR; + + int32_t dif = difR * 38 + difG * 76 + difB * 14; + + error += dif * dif; + } + } + + /**/ + uint32_t rgbv = cvB | ( cvG << 6 ) | ( cvR << 13 ); + uint32_t rgbh = chB | ( chG << 6 ) | ( chR << 13 ); + uint32_t hi = rgbv | ( ( rgbh & 0x1FFF ) << 19 ); + uint32_t lo = ( chR & 0x1 ) | 0x2 | ( ( chR << 1 ) & 0x7C ); + lo |= ( ( coB & 0x07 ) << 7 ) | ( ( coB & 0x18 ) << 8 ) | ( ( coB & 0x20 ) << 11 ); + lo |= ( ( coG & 0x3F ) << 17 ) | ( ( coG & 0x40 ) << 18 ); + lo |= coR << 25; + + const auto idx = ( coR & 0x20 ) | ( ( coG & 0x20 ) >> 1 ) | ( ( coB & 0x1E ) >> 1 ); + + lo |= g_flags[idx]; + + uint64_t result = static_cast( _bswap( lo ) ); + result |= static_cast( static_cast( _bswap( hi ) ) ) << 32; + + return std::make_pair( result, error ); +} + +#ifdef __ARM_NEON + +static etcpak_force_inline int32x2_t Planar_NEON_DifXZ( int16x8_t dif_lo, int16x8_t dif_hi ) +{ + int32x4_t dif0 = vmull_n_s16( vget_low_s16( dif_lo ), -255 ); + int32x4_t dif1 = vmull_n_s16( vget_high_s16( dif_lo ), -85 ); + int32x4_t dif2 = vmull_n_s16( vget_low_s16( dif_hi ), 85 ); + int32x4_t dif3 = vmull_n_s16( vget_high_s16( dif_hi ), 255 ); + int32x4_t dif4 = vaddq_s32( vaddq_s32( dif0, dif1 ), vaddq_s32( dif2, dif3 ) ); + +#ifndef __aarch64__ + int32x2_t dif5 = vpadd_s32( vget_low_s32( dif4 ), vget_high_s32( dif4 ) ); + return vpadd_s32( dif5, dif5 ); +#else + return vdup_n_s32( vaddvq_s32( dif4 ) ); +#endif +} + +static etcpak_force_inline int32x2_t Planar_NEON_DifYZ( int16x8_t dif_lo, int16x8_t dif_hi ) +{ + int16x4_t scaling = { -255, -85, 85, 255 }; + int32x4_t dif0 = vmull_s16( vget_low_s16( dif_lo ), scaling ); + int32x4_t dif1 = vmull_s16( vget_high_s16( dif_lo ), scaling ); + int32x4_t dif2 = vmull_s16( vget_low_s16( dif_hi ), scaling ); + int32x4_t dif3 = vmull_s16( vget_high_s16( dif_hi ), scaling ); + int32x4_t dif4 = vaddq_s32( vaddq_s32( dif0, dif1 ), vaddq_s32( dif2, dif3 ) ); + +#ifndef __aarch64__ + int32x2_t dif5 = vpadd_s32( vget_low_s32( dif4 ), vget_high_s32( dif4 ) ); + return vpadd_s32( dif5, dif5 ); +#else + return vdup_n_s32( vaddvq_s32( dif4 ) ); +#endif +} + +static etcpak_force_inline int16x8_t Planar_NEON_SumWide( uint8x16_t src ) +{ + uint16x8_t accu8 = vpaddlq_u8( src ); +#ifndef __aarch64__ + uint16x4_t accu4 = vpadd_u16( vget_low_u16( accu8 ), vget_high_u16( accu8 ) ); + uint16x4_t accu2 = vpadd_u16( accu4, accu4 ); + uint16x4_t accu1 = vpadd_u16( accu2, accu2 ); + return vreinterpretq_s16_u16( vcombine_u16( accu1, accu1 ) ); +#else + return vdupq_n_s16( vaddvq_u16( accu8 ) ); +#endif +} + +static etcpak_force_inline int16x8_t convert6_NEON( int32x4_t lo, int32x4_t hi ) +{ + uint16x8_t x = vcombine_u16( vqmovun_s32( lo ), vqmovun_s32( hi ) ); + int16x8_t i = vreinterpretq_s16_u16( vshrq_n_u16( vqshlq_n_u16( x, 6 ), 6) ); // clamp 0-1023 + i = vhsubq_s16( i, vdupq_n_s16( 15 ) ); + + int16x8_t ip11 = vaddq_s16( i, vdupq_n_s16( 11 ) ); + int16x8_t ip4 = vaddq_s16( i, vdupq_n_s16( 4 ) ); + + return vshrq_n_s16( vsubq_s16( vsubq_s16( ip11, vshrq_n_s16( ip11, 7 ) ), vshrq_n_s16( ip4, 7) ), 3 ); +} + +static etcpak_force_inline int16x4_t convert7_NEON( int32x4_t x ) +{ + int16x4_t i = vreinterpret_s16_u16( vshr_n_u16( vqshl_n_u16( vqmovun_s32( x ), 6 ), 6 ) ); // clamp 0-1023 + i = vhsub_s16( i, vdup_n_s16( 15 ) ); + + int16x4_t p9 = vadd_s16( i, vdup_n_s16( 9 ) ); + int16x4_t p6 = vadd_s16( i, vdup_n_s16( 6 ) ); + return vshr_n_s16( vsub_s16( vsub_s16( p9, vshr_n_s16( p9, 8 ) ), vshr_n_s16( p6, 8 ) ), 2 ); +} + +static etcpak_force_inline std::pair Planar_NEON( const uint8_t* src, const uint8_t mode, bool useHeuristics ) +{ + uint8x16x4_t srcBlock = vld4q_u8( src ); + + int16x8_t bSumWide = Planar_NEON_SumWide( srcBlock.val[0] ); + int16x8_t gSumWide = Planar_NEON_SumWide( srcBlock.val[1] ); + int16x8_t rSumWide = Planar_NEON_SumWide( srcBlock.val[2] ); + + int16x8_t dif_R_lo = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_low_u8( srcBlock.val[2] ), 4) ), rSumWide ); + int16x8_t dif_R_hi = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_high_u8( srcBlock.val[2] ), 4) ), rSumWide ); + + int16x8_t dif_G_lo = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_low_u8( srcBlock.val[1] ), 4 ) ), gSumWide ); + int16x8_t dif_G_hi = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_high_u8( srcBlock.val[1] ), 4 ) ), gSumWide ); + + int16x8_t dif_B_lo = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_low_u8( srcBlock.val[0] ), 4) ), bSumWide ); + int16x8_t dif_B_hi = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_high_u8( srcBlock.val[0] ), 4) ), bSumWide ); + + int32x2x2_t dif_xz_z = vzip_s32( vzip_s32( Planar_NEON_DifXZ( dif_B_lo, dif_B_hi ), Planar_NEON_DifXZ( dif_R_lo, dif_R_hi ) ).val[0], Planar_NEON_DifXZ( dif_G_lo, dif_G_hi ) ); + int32x4_t dif_xz = vcombine_s32( dif_xz_z.val[0], dif_xz_z.val[1] ); + int32x2x2_t dif_yz_z = vzip_s32( vzip_s32( Planar_NEON_DifYZ( dif_B_lo, dif_B_hi ), Planar_NEON_DifYZ( dif_R_lo, dif_R_hi ) ).val[0], Planar_NEON_DifYZ( dif_G_lo, dif_G_hi ) ); + int32x4_t dif_yz = vcombine_s32( dif_yz_z.val[0], dif_yz_z.val[1] ); + + const float fscale = -4.0f / ( (255 * 255 * 8.0f + 85 * 85 * 8.0f ) * 16.0f ); + float32x4_t fa = vmulq_n_f32( vcvtq_f32_s32( dif_xz ), fscale ); + float32x4_t fb = vmulq_n_f32( vcvtq_f32_s32( dif_yz ), fscale ); + int16x4_t bgrgSum = vzip_s16( vzip_s16( vget_low_s16( bSumWide ), vget_low_s16( rSumWide ) ).val[0], vget_low_s16( gSumWide ) ).val[0]; + float32x4_t fd = vmulq_n_f32( vcvtq_f32_s32( vmovl_s16( bgrgSum ) ), 4.0f / 16.0f); + + float32x4_t cof = vmlaq_n_f32( vmlaq_n_f32( fd, fb, 255.0f ), fa, 255.0f ); + float32x4_t chf = vmlaq_n_f32( vmlaq_n_f32( fd, fb, 255.0f ), fa, -425.0f ); + float32x4_t cvf = vmlaq_n_f32( vmlaq_n_f32( fd, fb, -425.0f ), fa, 255.0f ); + + int32x4_t coi = vcvtq_s32_f32( cof ); + int32x4_t chi = vcvtq_s32_f32( chf ); + int32x4_t cvi = vcvtq_s32_f32( cvf ); + + int32x4x2_t tr_hv = vtrnq_s32( chi, cvi ); + int32x4x2_t tr_o = vtrnq_s32( coi, coi ); + + int16x8_t c_hvoo_br_6 = convert6_NEON( tr_hv.val[0], tr_o.val[0] ); + int16x4_t c_hvox_g_7 = convert7_NEON( vcombine_s32( vget_low_s32( tr_hv.val[1] ), vget_low_s32( tr_o.val[1] ) ) ); + int16x8_t c_hvoo_br_8 = vorrq_s16( vshrq_n_s16( c_hvoo_br_6, 4 ), vshlq_n_s16( c_hvoo_br_6, 2 ) ); + int16x4_t c_hvox_g_8 = vorr_s16( vshr_n_s16( c_hvox_g_7, 6 ), vshl_n_s16( c_hvox_g_7, 1 ) ); + + uint64_t error = 0; + if( mode != ModePlanar && useHeuristics ) + { + int16x4_t rec_gxbr_o = vext_s16( c_hvox_g_8, vget_high_s16( c_hvoo_br_8 ), 3 ); + + rec_gxbr_o = vadd_s16( vshl_n_s16( rec_gxbr_o, 2 ), vdup_n_s16( 2 ) ); + int16x8_t rec_ro_wide = vdupq_lane_s16( rec_gxbr_o, 3 ); + int16x8_t rec_go_wide = vdupq_lane_s16( rec_gxbr_o, 0 ); + int16x8_t rec_bo_wide = vdupq_lane_s16( rec_gxbr_o, 1 ); + + int16x4_t br_hv2 = vsub_s16( vget_low_s16( c_hvoo_br_8 ), vget_high_s16( c_hvoo_br_8 ) ); + int16x4_t gg_hv2 = vsub_s16( c_hvox_g_8, vdup_lane_s16( c_hvox_g_8, 2 ) ); + + int16x8_t scaleh_lo = { 0, 0, 0, 0, 1, 1, 1, 1 }; + int16x8_t scaleh_hi = { 2, 2, 2, 2, 3, 3, 3, 3 }; + int16x8_t scalev = { 0, 1, 2, 3, 0, 1, 2, 3 }; + + int16x8_t rec_r_1 = vmlaq_lane_s16( rec_ro_wide, scalev, br_hv2, 3 ); + int16x8_t rec_r_lo = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_r_1, scaleh_lo, br_hv2, 2 ), 2 ) ) ); + int16x8_t rec_r_hi = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_r_1, scaleh_hi, br_hv2, 2 ), 2 ) ) ); + + int16x8_t rec_b_1 = vmlaq_lane_s16( rec_bo_wide, scalev, br_hv2, 1 ); + int16x8_t rec_b_lo = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_b_1, scaleh_lo, br_hv2, 0 ), 2 ) ) ); + int16x8_t rec_b_hi = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_b_1, scaleh_hi, br_hv2, 0 ), 2 ) ) ); + + int16x8_t rec_g_1 = vmlaq_lane_s16( rec_go_wide, scalev, gg_hv2, 1 ); + int16x8_t rec_g_lo = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_g_1, scaleh_lo, gg_hv2, 0 ), 2 ) ) ); + int16x8_t rec_g_hi = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_g_1, scaleh_hi, gg_hv2, 0 ), 2 ) ) ); + + int16x8_t dif_r_lo = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_low_u8( srcBlock.val[2] ) ) ), rec_r_lo ); + int16x8_t dif_r_hi = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_high_u8( srcBlock.val[2] ) ) ), rec_r_hi ); + + int16x8_t dif_g_lo = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_low_u8( srcBlock.val[1] ) ) ), rec_g_lo ); + int16x8_t dif_g_hi = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_high_u8( srcBlock.val[1] ) ) ), rec_g_hi ); + + int16x8_t dif_b_lo = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_low_u8( srcBlock.val[0] ) ) ), rec_b_lo ); + int16x8_t dif_b_hi = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_high_u8( srcBlock.val[0] ) ) ), rec_b_hi ); + + int16x8_t dif_lo = vmlaq_n_s16( vmlaq_n_s16( vmulq_n_s16( dif_r_lo, 38 ), dif_g_lo, 76 ), dif_b_lo, 14 ); + int16x8_t dif_hi = vmlaq_n_s16( vmlaq_n_s16( vmulq_n_s16( dif_r_hi, 38 ), dif_g_hi, 76 ), dif_b_hi, 14 ); + + int16x4_t tmpDif = vget_low_s16( dif_lo ); + int32x4_t difsq_0 = vmull_s16( tmpDif, tmpDif ); + tmpDif = vget_high_s16( dif_lo ); + int32x4_t difsq_1 = vmull_s16( tmpDif, tmpDif ); + tmpDif = vget_low_s16( dif_hi ); + int32x4_t difsq_2 = vmull_s16( tmpDif, tmpDif ); + tmpDif = vget_high_s16( dif_hi ); + int32x4_t difsq_3 = vmull_s16( tmpDif, tmpDif ); + + uint32x4_t difsq_5 = vaddq_u32( vreinterpretq_u32_s32( difsq_0 ), vreinterpretq_u32_s32( difsq_1 ) ); + uint32x4_t difsq_6 = vaddq_u32( vreinterpretq_u32_s32( difsq_2 ), vreinterpretq_u32_s32( difsq_3 ) ); + + uint64x2_t difsq_7 = vaddl_u32( vget_low_u32( difsq_5 ), vget_high_u32( difsq_5 ) ); + uint64x2_t difsq_8 = vaddl_u32( vget_low_u32( difsq_6 ), vget_high_u32( difsq_6 ) ); + + uint64x2_t difsq_9 = vaddq_u64( difsq_7, difsq_8 ); + +#ifdef __aarch64__ + error = vaddvq_u64( difsq_9 ); +#else + error = vgetq_lane_u64( difsq_9, 0 ) + vgetq_lane_u64( difsq_9, 1 ); +#endif + } + + int32_t coR = c_hvoo_br_6[6]; + int32_t coG = c_hvox_g_7[2]; + int32_t coB = c_hvoo_br_6[4]; + + int32_t chR = c_hvoo_br_6[2]; + int32_t chG = c_hvox_g_7[0]; + int32_t chB = c_hvoo_br_6[0]; + + int32_t cvR = c_hvoo_br_6[3]; + int32_t cvG = c_hvox_g_7[1]; + int32_t cvB = c_hvoo_br_6[1]; + + uint32_t rgbv = cvB | ( cvG << 6 ) | ( cvR << 13 ); + uint32_t rgbh = chB | ( chG << 6 ) | ( chR << 13 ); + uint32_t hi = rgbv | ( ( rgbh & 0x1FFF ) << 19 ); + uint32_t lo = ( chR & 0x1 ) | 0x2 | ( ( chR << 1 ) & 0x7C ); + lo |= ( ( coB & 0x07 ) << 7 ) | ( ( coB & 0x18 ) << 8 ) | ( ( coB & 0x20 ) << 11 ); + lo |= ( ( coG & 0x3F) << 17) | ( (coG & 0x40 ) << 18 ); + lo |= coR << 25; + + const auto idx = ( coR & 0x20 ) | ( ( coG & 0x20 ) >> 1 ) | ( ( coB & 0x1E ) >> 1 ); + + lo |= g_flags[idx]; + + uint64_t result = static_cast( _bswap(lo) ); + result |= static_cast( static_cast( _bswap( hi ) ) ) << 32; + + return std::make_pair( result, error ); +} + +#endif + +#ifdef __AVX2__ +uint32_t calculateErrorTH( bool tMode, uint8_t( colorsRGB444 )[2][3], uint8_t& dist, uint32_t& pixIndices, uint8_t startDist, __m128i r8, __m128i g8, __m128i b8 ) +#else +uint32_t calculateErrorTH( bool tMode, uint8_t* src, uint8_t( colorsRGB444 )[2][3], uint8_t& dist, uint32_t& pixIndices, uint8_t startDist ) +#endif +{ + uint32_t blockErr = 0, bestBlockErr = MaxError; + + uint32_t pixColors; + uint8_t possibleColors[4][3]; + uint8_t colors[2][3]; + + decompressColor( colorsRGB444, colors ); + +#ifdef __AVX2__ + __m128i reverseMask = _mm_set_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 ); +#endif + + // test distances + for( uint8_t d = startDist; d < 8; ++d ) + { + if( d >= 2 && dist == d - 2 ) break; + + blockErr = 0; + pixColors = 0; + + if( tMode ) + { + calculatePaintColors59T( d, colors, possibleColors ); + } + else + { + calculatePaintColors58H( d, colors, possibleColors ); + } + +#ifdef __AVX2__ + // RGB ordering + __m128i b8Rev = _mm_shuffle_epi8( b8, reverseMask ); + __m128i g8Rev = _mm_shuffle_epi8( g8, reverseMask ); + __m128i r8Rev = _mm_shuffle_epi8( r8, reverseMask ); + + // extends 3x128 bits RGB into 3x256 bits RGB for error comparisions + static const __m128i zero = _mm_setzero_si128(); + __m128i b8Lo = _mm_unpacklo_epi8( b8Rev, zero ); + __m128i g8Lo = _mm_unpacklo_epi8( g8Rev, zero ); + __m128i r8Lo = _mm_unpacklo_epi8( r8Rev, zero ); + __m128i b8Hi = _mm_unpackhi_epi8( b8Rev, zero ); + __m128i g8Hi = _mm_unpackhi_epi8( g8Rev, zero ); + __m128i r8Hi = _mm_unpackhi_epi8( r8Rev, zero ); + + __m256i b8 = _mm256_set_m128i( b8Hi, b8Lo ); + __m256i g8 = _mm256_set_m128i( g8Hi, g8Lo ); + __m256i r8 = _mm256_set_m128i( r8Hi, r8Lo ); + + // caculates differences between the pixel colrs and the palette colors + __m256i diffb = _mm256_abs_epi16( _mm256_sub_epi16( b8, _mm256_set1_epi16( possibleColors[0][B] ) ) ); + __m256i diffg = _mm256_abs_epi16( _mm256_sub_epi16( g8, _mm256_set1_epi16( possibleColors[0][G] ) ) ); + __m256i diffr = _mm256_abs_epi16( _mm256_sub_epi16( r8, _mm256_set1_epi16( possibleColors[0][R] ) ) ); + + // luma-based error calculations + static const __m256i bWeight = _mm256_set1_epi16( 14 ); + static const __m256i gWeight = _mm256_set1_epi16( 76 ); + static const __m256i rWeight = _mm256_set1_epi16( 38 ); + + diffb = _mm256_mullo_epi16( diffb, bWeight ); + diffg = _mm256_mullo_epi16( diffg, gWeight ); + diffr = _mm256_mullo_epi16( diffr, rWeight ); + + // obtains the error with the current palette color + __m256i lowestPixErr = _mm256_add_epi16( _mm256_add_epi16( diffb, diffg ), diffr ); + + // error calucations with the remaining three palette colors + static const uint32_t masks[4] = { 0, 0x55555555, 0xAAAAAAAA, 0xFFFFFFFF }; + for( uint8_t c = 1; c < 4; c++ ) + { + __m256i diffb = _mm256_abs_epi16( _mm256_sub_epi16( b8, _mm256_set1_epi16( possibleColors[c][B] ) ) ); + __m256i diffg = _mm256_abs_epi16( _mm256_sub_epi16( g8, _mm256_set1_epi16( possibleColors[c][G] ) ) ); + __m256i diffr = _mm256_abs_epi16( _mm256_sub_epi16( r8, _mm256_set1_epi16( possibleColors[c][R] ) ) ); + + diffb = _mm256_mullo_epi16( diffb, bWeight ); + diffg = _mm256_mullo_epi16( diffg, gWeight ); + diffr = _mm256_mullo_epi16( diffr, rWeight ); + + // error comparison with the previous best color + __m256i pixErrors = _mm256_add_epi16( _mm256_add_epi16( diffb, diffg ), diffr ); + __m256i minErr = _mm256_min_epu16( lowestPixErr, pixErrors ); + __m256i cmpRes = _mm256_cmpeq_epi16( pixErrors, minErr ); + lowestPixErr = minErr; + + // update pixel colors + uint32_t updPixColors = _mm256_movemask_epi8( cmpRes ); + uint32_t prevPixColors = pixColors & ~updPixColors; + uint32_t mskPixColors = masks[c] & updPixColors; + pixColors = prevPixColors | mskPixColors; + } + + // accumulate the block error + alignas( 32 ) uint16_t pixErr16[16] = { 0, }; + _mm256_storeu_si256( (__m256i*)pixErr16, lowestPixErr ); + for( uint8_t p = 0; p < 16; p++ ) + { + blockErr += (int)( pixErr16[p] ) * pixErr16[p]; + } +#else + for( size_t y = 0; y < 4; ++y ) + { + for( size_t x = 0; x < 4; ++x ) + { + uint32_t bestPixErr = MaxError; + pixColors <<= 2; // Make room for next value + + // Loop possible block colors + for( uint8_t c = 0; c < 4; ++c ) + { + int diff[3]; + diff[R] = src[4 * ( x * 4 + y ) + R] - possibleColors[c][R]; + diff[G] = src[4 * ( x * 4 + y ) + G] - possibleColors[c][G]; + diff[B] = src[4 * ( x * 4 + y ) + B] - possibleColors[c][B]; + + const uint32_t err = 38 * abs( diff[R] ) + 76 * abs( diff[G] ) + 14 * abs( diff[B] ); + uint32_t pixErr = err * err; + + // Choose best error + if( pixErr < bestPixErr ) + { + bestPixErr = pixErr; + pixColors ^= ( pixColors & 3 ); // Reset the two first bits + pixColors |= c; + } + } + blockErr += bestPixErr; + } + } +#endif + + if( blockErr < bestBlockErr ) + { + bestBlockErr = blockErr; + dist = d; + pixIndices = pixColors; + } + } + + return bestBlockErr; +} + + +// main T-/H-mode compression function +#ifdef __AVX2__ +uint32_t compressBlockTH( uint8_t* src, Luma& l, uint32_t& compressed1, uint32_t& compressed2, bool& tMode, __m128i r8, __m128i g8, __m128i b8 ) +#else +uint32_t compressBlockTH( uint8_t *src, Luma& l, uint32_t& compressed1, uint32_t& compressed2, bool &tMode ) +#endif +{ +#ifdef __AVX2__ + alignas( 8 ) uint8_t luma[16] = { 0, }; + _mm_storeu_si128 ( (__m128i* )luma, l.luma8 ); +#elif defined __ARM_NEON && defined __aarch64__ + alignas( 8 ) uint8_t luma[16] = { 0 }; + vst1q_u8( luma, l.luma8 ); +#else + uint8_t* luma = l.val; +#endif + + uint8_t pixIdx[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + + // 1) sorts the pairs of (luma, pix_idx) + insertionSort( luma, pixIdx ); + + // 2) finds the min (left+right) + uint8_t minSumRangeIdx = 0; + uint16_t minSumRangeValue; + uint16_t sum; + static const uint8_t diffBonus[15] = {8, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 8}; + const int16_t temp = luma[15] - luma[0]; + + minSumRangeValue = luma[15] - luma[1] + diffBonus[0]; + for( uint8_t i = 1; i < 14; i++ ) + { + sum = temp - luma[i+1] + luma[i] + diffBonus[i]; + if( minSumRangeValue > sum ) + { + minSumRangeValue = sum; + minSumRangeIdx = i; + } + } + + sum = luma[14] - luma[0] + diffBonus[14]; + if( minSumRangeValue > sum ) + { + minSumRangeValue = sum; + minSumRangeIdx = 14; + } + uint8_t lRange, rRange; + + lRange = luma[minSumRangeIdx] - luma[0]; + rRange = luma[15] - luma[minSumRangeIdx + 1]; + + // 3) sets a proper mode + bool swap = false; + if( lRange >= rRange ) + { + if( lRange >= rRange * 2 ) + { + swap = true; + tMode = true; + } + } + else + { + if( lRange * 2 <= rRange ) tMode = true; + } + // 4) calculates the two base colors + uint8_t rangeIdx[4] = { pixIdx[0], pixIdx[minSumRangeIdx], pixIdx[minSumRangeIdx + 1], pixIdx[15] }; + + uint16_t r[4], g[4], b[4]; + for( uint8_t i = 0; i < 4; ++i ) + { + uint8_t idx = rangeIdx[i] * 4; + b[i] = src[idx]; + g[i] = src[idx + 1]; + r[i] = src[idx + 2]; + } + + uint8_t mid_rgb[2][3]; + if( swap ) + { + mid_rgb[1][B] = ( b[0] + b[1] ) / 2; + mid_rgb[1][G] = ( g[0] + g[1] ) / 2; + mid_rgb[1][R] = ( r[0] + r[1] ) / 2; + + uint16_t sum_rgb[3] = { 0, 0, 0 }; + for( uint8_t i = minSumRangeIdx + 1; i < 16; i++ ) + { + uint8_t idx = pixIdx[i] * 4; + sum_rgb[B] += src[idx]; + sum_rgb[G] += src[idx + 1]; + sum_rgb[R] += src[idx + 2]; + } + const uint8_t temp = 15 - minSumRangeIdx; + mid_rgb[0][B] = sum_rgb[B] / temp; + mid_rgb[0][G] = sum_rgb[G] / temp; + mid_rgb[0][R] = sum_rgb[R] / temp; + } + else + { + mid_rgb[0][B] = (b[0] + b[1]) / 2; + mid_rgb[0][G] = (g[0] + g[1]) / 2; + mid_rgb[0][R] = (r[0] + r[1]) / 2; + if( tMode ) + { + uint16_t sum_rgb[3] = { 0, 0, 0 }; + for( uint8_t i = minSumRangeIdx + 1; i < 16; i++ ) + { + uint8_t idx = pixIdx[i] * 4; + sum_rgb[B] += src[idx]; + sum_rgb[G] += src[idx + 1]; + sum_rgb[R] += src[idx + 2]; + } + const uint8_t temp = 15 - minSumRangeIdx; + mid_rgb[1][B] = sum_rgb[B] / temp; + mid_rgb[1][G] = sum_rgb[G] / temp; + mid_rgb[1][R] = sum_rgb[R] / temp; + } + else + { + mid_rgb[1][B] = (b[2] + b[3]) / 2; + mid_rgb[1][G] = (g[2] + g[3]) / 2; + mid_rgb[1][R] = (r[2] + r[3]) / 2; + } + } + + // 5) sets the start distance index + uint32_t startDistCandidate; + uint32_t avgDist; + if( tMode ) + { + if( swap ) + { + avgDist = ( b[1] - b[0] + g[1] - g[0] + r[1] - r[0] ) / 6; + } + else + { + avgDist = ( b[3] - b[2] + g[3] - g[2] + r[3] - r[2] ) / 6; + } + } + else + { + avgDist = ( b[1] - b[0] + g[1] - g[0] + r[1] - r[0] + b[3] - b[2] + g[3] - g[2] + r[3] - r[2] ) / 12; + } + + if( avgDist <= 16) + { + startDistCandidate = 0; + } + else if( avgDist <= 23 ) + { + startDistCandidate = 1; + } + else if( avgDist <= 32 ) + { + startDistCandidate = 2; + } + else if( avgDist <= 41 ) + { + startDistCandidate = 3; + } + else + { + startDistCandidate = 4; + } + + uint32_t bestErr = MaxError; + uint32_t bestPixIndices; + uint8_t bestDist = 10; + uint8_t colorsRGB444[2][3]; + compressColor( mid_rgb, colorsRGB444, tMode ); + compressed1 = 0; + + // 6) finds the best candidate with the lowest error +#ifdef __AVX2__ + // Vectorized ver + bestErr = calculateErrorTH( tMode, colorsRGB444, bestDist, bestPixIndices, startDistCandidate, r8, g8, b8 ); +#else + // Scalar ver + bestErr = calculateErrorTH( tMode, src, colorsRGB444, bestDist, bestPixIndices, startDistCandidate ); +#endif + + // 7) outputs the final T or H block + if( tMode ) + { + // Put the compress params into the compression block + compressed1 |= ( colorsRGB444[0][R] & 0xf ) << 23; + compressed1 |= ( colorsRGB444[0][G] & 0xf ) << 19; + compressed1 |= ( colorsRGB444[0][B] ) << 15; + compressed1 |= ( colorsRGB444[1][R] ) << 11; + compressed1 |= ( colorsRGB444[1][G] ) << 7; + compressed1 |= ( colorsRGB444[1][B] ) << 3; + compressed1 |= bestDist & 0x7; + } + else + { + int bestRGB444ColPacked[2]; + bestRGB444ColPacked[0] = (colorsRGB444[0][R] << 8) + (colorsRGB444[0][G] << 4) + colorsRGB444[0][B]; + bestRGB444ColPacked[1] = (colorsRGB444[1][R] << 8) + (colorsRGB444[1][G] << 4) + colorsRGB444[1][B]; + if( ( bestRGB444ColPacked[0] >= bestRGB444ColPacked[1] ) ^ ( ( bestDist & 1 ) == 1 ) ) + { + swapColors( colorsRGB444 ); + // Reshuffle pixel indices to to exchange C1 with C3, and C2 with C4 + bestPixIndices = ( 0x55555555 & bestPixIndices ) | ( 0xaaaaaaaa & ( ~bestPixIndices ) ); + } + + // Put the compress params into the compression block + compressed1 |= ( colorsRGB444[0][R] & 0xf ) << 22; + compressed1 |= ( colorsRGB444[0][G] & 0xf ) << 18; + compressed1 |= ( colorsRGB444[0][B] & 0xf ) << 14; + compressed1 |= ( colorsRGB444[1][R] & 0xf ) << 10; + compressed1 |= ( colorsRGB444[1][G] & 0xf ) << 6; + compressed1 |= ( colorsRGB444[1][B] & 0xf ) << 2; + compressed1 |= ( bestDist >> 1 ) & 0x3; + } + + bestPixIndices = indexConversion( bestPixIndices ); + compressed2 = 0; + compressed2 = ( compressed2 & ~( ( 0x2 << 31 ) - 1 ) ) | ( bestPixIndices & ( ( 2 << 31 ) - 1 ) ); + + return bestErr; +} +//#endif + +template +static etcpak_force_inline uint64_t EncodeSelectors( uint64_t d, const T terr[2][8], const S tsel[16][8], const uint32_t* id, const uint64_t value, const uint64_t error) +{ + size_t tidx[2]; + tidx[0] = GetLeastError( terr[0], 8 ); + tidx[1] = GetLeastError( terr[1], 8 ); + + if ((terr[0][tidx[0]] + terr[1][tidx[1]]) >= error) + { + return value; + } + + d |= tidx[0] << 26; + d |= tidx[1] << 29; + for( int i=0; i<16; i++ ) + { + uint64_t t = tsel[i][tidx[id[i]%2]]; + d |= ( t & 0x1 ) << ( i + 32 ); + d |= ( t & 0x2 ) << ( i + 47 ); + } + + return FixByteOrder(d); +} + +} + +static etcpak_force_inline uint64_t ProcessRGB( const uint8_t* src ) +{ +#ifdef __AVX2__ + uint64_t d = CheckSolid_AVX2( src ); + if( d != 0 ) return d; + + alignas(32) v4i a[8]; + + __m128i err0 = PrepareAverages_AVX2( a, src ); + + // Get index of minimum error (err0) + __m128i err1 = _mm_shuffle_epi32(err0, _MM_SHUFFLE(2, 3, 0, 1)); + __m128i errMin0 = _mm_min_epu32(err0, err1); + + __m128i errMin1 = _mm_shuffle_epi32(errMin0, _MM_SHUFFLE(1, 0, 3, 2)); + __m128i errMin2 = _mm_min_epu32(errMin1, errMin0); + + __m128i errMask = _mm_cmpeq_epi32(errMin2, err0); + + uint32_t mask = _mm_movemask_epi8(errMask); + + uint32_t idx = _bit_scan_forward(mask) >> 2; + + d |= EncodeAverages_AVX2( a, idx ); + + alignas(32) uint32_t terr[2][8] = {}; + alignas(32) uint32_t tsel[8]; + + if ((idx == 0) || (idx == 2)) + { + FindBestFit_4x2_AVX2( terr, tsel, a, idx * 2, src ); + } + else + { + FindBestFit_2x4_AVX2( terr, tsel, a, idx * 2, src ); + } + + return EncodeSelectors_AVX2( d, terr, tsel, (idx % 2) == 1 ); +#else + uint64_t d = CheckSolid( src ); + if( d != 0 ) return d; + + v4i a[8]; + unsigned int err[4] = {}; + PrepareAverages( a, src, err ); + size_t idx = GetLeastError( err, 4 ); + EncodeAverages( d, a, idx ); + +#if ( defined __SSE4_1__ || defined __ARM_NEON ) && !defined REFERENCE_IMPLEMENTATION + uint32_t terr[2][8] = {}; +#else + uint64_t terr[2][8] = {}; +#endif + uint16_t tsel[16][8]; + auto id = g_id[idx]; + FindBestFit( terr, tsel, a, id, src ); + + return FixByteOrder( EncodeSelectors( d, terr, tsel, id ) ); +#endif +} + +#ifdef __AVX2__ +// horizontal min/max functions. https://stackoverflow.com/questions/22256525/horizontal-minimum-and-maximum-using-sse +// if an error occurs in GCC, please change the value of -march in CFLAGS to a specific value for your CPU (e.g., skylake). +static inline int16_t hMax( __m128i buffer, uint8_t& idx ) +{ + __m128i tmp1 = _mm_sub_epi8( _mm_set1_epi8( (char)( 255 ) ), buffer ); + __m128i tmp2 = _mm_min_epu8( tmp1, _mm_srli_epi16( tmp1, 8 ) ); + __m128i tmp3 = _mm_minpos_epu16( tmp2 ); + uint8_t result = 255 - (uint8_t)_mm_cvtsi128_si32( tmp3 ); + __m128i mask = _mm_cmpeq_epi8( buffer, _mm_set1_epi8( result ) ); + idx = _tzcnt_u32( _mm_movemask_epi8( mask ) ); + + return result; +} +#elif defined __ARM_NEON && defined __aarch64__ +static inline int16_t hMax( uint8x16_t buffer, uint8_t& idx ) +{ + const uint8_t max = vmaxvq_u8( buffer ); + const uint16x8_t vmax = vdupq_n_u16( max ); + uint8x16x2_t buff_wide = vzipq_u8( buffer, uint8x16_t() ); + uint16x8_t lowbuf16 = vreinterpretq_u16_u8( buff_wide.val[0] ); + uint16x8_t hibuf16 = vreinterpretq_u16_u8( buff_wide.val[1] ); + uint16x8_t low_eqmask = vceqq_u16( lowbuf16, vmax ); + uint16x8_t hi_eqmask = vceqq_u16( hibuf16, vmax ); + + static const uint16_t mask_lsb[] = { + 0x1, 0x2, 0x4, 0x8, + 0x10, 0x20, 0x40, 0x80 }; + + static const uint16_t mask_msb[] = { + 0x100, 0x200, 0x400, 0x800, + 0x1000, 0x2000, 0x4000, 0x8000 }; + + uint16x8_t vmask_lsb = vld1q_u16( mask_lsb ); + uint16x8_t vmask_msb = vld1q_u16( mask_msb ); + uint16x8_t pos_lsb = vandq_u16( vmask_lsb, low_eqmask ); + uint16x8_t pos_msb = vandq_u16( vmask_msb, hi_eqmask ); + pos_lsb = vpaddq_u16( pos_lsb, pos_lsb ); + pos_lsb = vpaddq_u16( pos_lsb, pos_lsb ); + pos_lsb = vpaddq_u16( pos_lsb, pos_lsb ); + uint64_t idx_lane1 = vgetq_lane_u64( vreinterpretq_u64_u16( pos_lsb ), 0 ); + pos_msb = vpaddq_u16( pos_msb, pos_msb ); + pos_msb = vpaddq_u16( pos_msb, pos_msb ); + pos_msb = vpaddq_u16( pos_msb, pos_msb ); + uint32_t idx_lane2 = vgetq_lane_u32( vreinterpretq_u32_u16( pos_msb ), 0 ); + idx = idx_lane1 != 0 ? __builtin_ctz( idx_lane1 ) : __builtin_ctz( idx_lane2 ); + + return max; +} +#endif + +#ifdef __AVX2__ +static inline int16_t hMin( __m128i buffer, uint8_t& idx ) +{ + __m128i tmp2 = _mm_min_epu8( buffer, _mm_srli_epi16( buffer, 8 ) ); + __m128i tmp3 = _mm_minpos_epu16( tmp2 ); + uint8_t result = (uint8_t)_mm_cvtsi128_si32( tmp3 ); + __m128i mask = _mm_cmpeq_epi8( buffer, _mm_set1_epi8( result ) ); + idx = _tzcnt_u32( _mm_movemask_epi8( mask ) ); + return result; +} +#elif defined __ARM_NEON && defined __aarch64__ +static inline int16_t hMin( uint8x16_t buffer, uint8_t& idx ) +{ + const uint8_t min = vminvq_u8( buffer ); + const uint16x8_t vmin = vdupq_n_u16( min ); + uint8x16x2_t buff_wide = vzipq_u8( buffer, uint8x16_t() ); + uint16x8_t lowbuf16 = vreinterpretq_u16_u8( buff_wide.val[0] ); + uint16x8_t hibuf16 = vreinterpretq_u16_u8( buff_wide.val[1] ); + uint16x8_t low_eqmask = vceqq_u16( lowbuf16, vmin ); + uint16x8_t hi_eqmask = vceqq_u16( hibuf16, vmin ); + + static const uint16_t mask_lsb[] = { + 0x1, 0x2, 0x4, 0x8, + 0x10, 0x20, 0x40, 0x80 }; + + static const uint16_t mask_msb[] = { + 0x100, 0x200, 0x400, 0x800, + 0x1000, 0x2000, 0x4000, 0x8000 }; + + uint16x8_t vmask_lsb = vld1q_u16( mask_lsb ); + uint16x8_t vmask_msb = vld1q_u16( mask_msb ); + uint16x8_t pos_lsb = vandq_u16( vmask_lsb, low_eqmask ); + uint16x8_t pos_msb = vandq_u16( vmask_msb, hi_eqmask ); + pos_lsb = vpaddq_u16( pos_lsb, pos_lsb ); + pos_lsb = vpaddq_u16( pos_lsb, pos_lsb ); + pos_lsb = vpaddq_u16( pos_lsb, pos_lsb ); + uint64_t idx_lane1 = vgetq_lane_u64( vreinterpretq_u64_u16( pos_lsb ), 0 ); + pos_msb = vpaddq_u16( pos_msb, pos_msb ); + pos_msb = vpaddq_u16( pos_msb, pos_msb ); + pos_msb = vpaddq_u16( pos_msb, pos_msb ); + uint32_t idx_lane2 = vgetq_lane_u32( vreinterpretq_u32_u16( pos_msb ), 0 ); + idx = idx_lane1 != 0 ? __builtin_ctz( idx_lane1 ) : __builtin_ctz( idx_lane2 ); + + return min; +} +#endif + +// During search it is not convenient to store the bits the way they are stored in the +// file format. Hence, after search, it is converted to this format. +// NO WARRANTY --- SEE STATEMENT IN TOP OF FILE (C) Ericsson AB 2005-2013. All Rights Reserved. +static inline void stuff59bits( unsigned int thumbT59W1, unsigned int thumbT59W2, unsigned int& thumbTW1, unsigned int& thumbTW2 ) +{ + // Put bits in twotimer configuration for 59 (red overflows) + // + // Go from this bit layout: + // + // |63 62 61 60 59|58 57 56 55|54 53 52 51|50 49 48 47|46 45 44 43|42 41 40 39|38 37 36 35|34 33 32| + // |----empty-----|---red 0---|--green 0--|--blue 0---|---red 1---|--green 1--|--blue 1---|--dist--| + // + // |31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00| + // |----------------------------------------index bits---------------------------------------------| + // + // + // To this: + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 + // ----------------------------------------------------------------------------------------------- + // |// // //|R0a |//|R0b |G0 |B0 |R1 |G1 |B1 |da |df|db| + // ----------------------------------------------------------------------------------------------- + // + // |31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00| + // |----------------------------------------index bits---------------------------------------------| + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 + // ----------------------------------------------------------------------------------------------- + // | base col1 | dcol 2 | base col1 | dcol 2 | base col 1 | dcol 2 | table | table |df|fp| + // | R1' (5 bits) | dR2 | G1' (5 bits) | dG2 | B1' (5 bits) | dB2 | cw 1 | cw 2 |bt|bt| + // ------------------------------------------------------------------------------------------------ + + uint8_t R0a; + uint8_t bit, a, b, c, d, bits; + + R0a = ( thumbT59W1 >> 25 ) & 0x3; + + // Fix middle part + thumbTW1 = thumbT59W1 << 1; + // Fix R0a (top two bits of R0) + thumbTW1 = ( thumbTW1 & ~( 0x3 << 27 ) ) | ( ( R0a & 0x3 ) << 27 ); + // Fix db (lowest bit of d) + thumbTW1 = ( thumbTW1 & ~0x1 ) | ( thumbT59W1 & 0x1 ); + + // Make sure that red overflows: + a = ( thumbTW1 >> 28 ) & 0x1; + b = ( thumbTW1 >> 27 ) & 0x1; + c = ( thumbTW1 >> 25 ) & 0x1; + d = ( thumbTW1 >> 24 ) & 0x1; + + // The following bit abcd bit sequences should be padded with ones: 0111, 1010, 1011, 1101, 1110, 1111 + // The following logical expression checks for the presence of any of those: + bit = ( a & c ) | ( !a & b & c & d ) | ( a & b & !c & d ); + bits = 0xf * bit; + thumbTW1 = ( thumbTW1 & ~( 0x7 << 29 ) ) | ( bits & 0x7 ) << 29; + thumbTW1 = ( thumbTW1 & ~( 0x1 << 26 ) ) | ( !bit & 0x1 ) << 26; + + // Set diffbit + thumbTW1 = ( thumbTW1 & ~0x2 ) | 0x2; + thumbTW2 = thumbT59W2; +} + +// During search it is not convenient to store the bits the way they are stored in the +// file format. Hence, after search, it is converted to this format. +// NO WARRANTY --- SEE STATEMENT IN TOP OF FILE (C) Ericsson AB 2005-2013. All Rights Reserved. +static inline void stuff58bits( unsigned int thumbH58W1, unsigned int thumbH58W2, unsigned int& thumbHW1, unsigned int& thumbHW2 ) +{ + // Put bits in twotimer configuration for 58 (red doesn't overflow, green does) + // + // Go from this bit layout: + // + // + // |63 62 61 60 59 58|57 56 55 54|53 52 51 50|49 48 47 46|45 44 43 42|41 40 39 38|37 36 35 34|33 32| + // |-------empty-----|---red 0---|--green 0--|--blue 0---|---red 1---|--green 1--|--blue 1---|d2 d1| + // + // |31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00| + // |---------------------------------------index bits----------------------------------------------| + // + // To this: + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 + // ----------------------------------------------------------------------------------------------- + // |//|R0 |G0 |// // //|G0|B0|//|B0b |R1 |G1 |B0 |d2|df|d1| + // ----------------------------------------------------------------------------------------------- + // + // |31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00| + // |---------------------------------------index bits----------------------------------------------| + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 + // ----------------------------------------------------------------------------------------------- + // | base col1 | dcol 2 | base col1 | dcol 2 | base col 1 | dcol 2 | table | table |df|fp| + // | R1' (5 bits) | dR2 | G1' (5 bits) | dG2 | B1' (5 bits) | dB2 | cw 1 | cw 2 |bt|bt| + // ----------------------------------------------------------------------------------------------- + // + // + // Thus, what we are really doing is going from this bit layout: + // + // + // |63 62 61 60 59 58|57 56 55 54 53 52 51|50 49|48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33|32 | + // |-------empty-----|part0---------------|part1|part2------------------------------------------|part3| + // + // To this: + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 + // --------------------------------------------------------------------------------------------------| + // |//|part0 |// // //|part1|//|part2 |df|part3| + // --------------------------------------------------------------------------------------------------| + + unsigned int part0, part1, part2, part3; + uint8_t bit, a, b, c, d, bits; + + // move parts + part0 = ( thumbH58W1 >> 19 ) & 0x7f; + part1 = ( thumbH58W1 >> 17 ) & 0x3; + part2 = ( thumbH58W1 >> 1 ) & 0xffff; + part3 = thumbH58W1 & 0x1; + thumbHW1 = 0; + thumbHW1 = ( thumbHW1 & ~( 0x7f << 24 ) ) | ( ( part0 & 0x7f ) << 24 ); + thumbHW1 = ( thumbHW1 & ~( 0x3 << 19 ) ) | ( ( part1 & 0x3 ) << 19 ); + thumbHW1 = ( thumbHW1 & ~( 0xffff << 2 ) ) | ( ( part2 & 0xffff ) << 2 ); + thumbHW1 = ( thumbHW1 & ~0x1 ) | ( part3 & 0x1 ); + + // Make sure that red does not overflow: + bit = ( thumbHW1 >> 30 ) & 0x1; + thumbHW1 = ( thumbHW1 & ~( 0x1 << 31 ) ) | ( ( !bit & 0x1 ) << 31 ); + + // Make sure that green overflows: + a = ( thumbHW1 >> 20 ) & 0x1; + b = ( thumbHW1 >> 19 ) & 0x1; + c = ( thumbHW1 >> 17 ) & 0x1; + d = ( thumbHW1 >> 16 ) & 0x1; + // The following bit abcd bit sequences should be padded with ones: 0111, 1010, 1011, 1101, 1110, 1111 + // The following logical expression checks for the presence of any of those: + bit = ( a & c ) | ( !a & b & c & d ) | ( a & b & !c & d ); + bits = 0xf * bit; + thumbHW1 = ( thumbHW1 & ~( 0x7 << 21 ) ) | ( ( bits & 0x7 ) << 21 ); + thumbHW1 = ( thumbHW1 & ~( 0x1 << 18 ) ) | ( ( !bit & 0x1 ) << 18 ); + + // Set diffbit + thumbHW1 = ( thumbHW1 & ~0x2 ) | 0x2; + thumbHW2 = thumbH58W2; +} + +#if defined __AVX2__ || (defined __ARM_NEON && defined __aarch64__) +static etcpak_force_inline Channels GetChannels( const uint8_t* src ) +{ + Channels ch; +#ifdef __AVX2__ + __m128i d0 = _mm_loadu_si128( ( (__m128i*)src ) + 0 ); + __m128i d1 = _mm_loadu_si128( ( (__m128i*)src ) + 1 ); + __m128i d2 = _mm_loadu_si128( ( (__m128i*)src ) + 2 ); + __m128i d3 = _mm_loadu_si128( ( (__m128i*)src ) + 3 ); + + __m128i rgb0 = _mm_shuffle_epi8( d0, _mm_setr_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, -1, -1, -1, -1 ) ); + __m128i rgb1 = _mm_shuffle_epi8( d1, _mm_setr_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, -1, -1, -1, -1 ) ); + __m128i rgb2 = _mm_shuffle_epi8( d2, _mm_setr_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, -1, -1, -1, -1 ) ); + __m128i rgb3 = _mm_shuffle_epi8( d3, _mm_setr_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, -1, -1, -1, -1 ) ); + + __m128i rg0 = _mm_unpacklo_epi32( rgb0, rgb1 ); + __m128i rg1 = _mm_unpacklo_epi32( rgb2, rgb3 ); + __m128i b0 = _mm_unpackhi_epi32( rgb0, rgb1 ); + __m128i b1 = _mm_unpackhi_epi32( rgb2, rgb3 ); + + // swap channels + ch.b8 = _mm_unpacklo_epi64( rg0, rg1 ); + ch.g8 = _mm_unpackhi_epi64( rg0, rg1 ); + ch.r8 = _mm_unpacklo_epi64( b0, b1 ); +#elif defined __ARM_NEON && defined __aarch64__ + //load pixel data into 4 rows + uint8x16_t px0 = vld1q_u8( src + 0 ); + uint8x16_t px1 = vld1q_u8( src + 16 ); + uint8x16_t px2 = vld1q_u8( src + 32 ); + uint8x16_t px3 = vld1q_u8( src + 48 ); + + uint8x16x2_t px0z1 = vzipq_u8( px0, px1 ); + uint8x16x2_t px2z3 = vzipq_u8( px2, px3 ); + uint8x16x2_t px01 = vzipq_u8( px0z1.val[0], px0z1.val[1] ); + uint8x16x2_t rgb01 = vzipq_u8( px01.val[0], px01.val[1] ); + uint8x16x2_t px23 = vzipq_u8( px2z3.val[0], px2z3.val[1] ); + uint8x16x2_t rgb23 = vzipq_u8( px23.val[0], px23.val[1] ); + + uint8x16_t rr = vreinterpretq_u8_u64( vzip1q_u64( vreinterpretq_u64_u8( rgb01.val[0] ), vreinterpretq_u64_u8( rgb23.val[0] ) ) ); + uint8x16_t gg = vreinterpretq_u8_u64( vzip2q_u64( vreinterpretq_u64_u8( rgb01.val[0] ), vreinterpretq_u64_u8( rgb23.val[0] ) ) ); + uint8x16_t bb = vreinterpretq_u8_u64( vzip1q_u64( vreinterpretq_u64_u8( rgb01.val[1] ), vreinterpretq_u64_u8( rgb23.val[1] ) ) ); + + uint8x16x2_t red = vzipq_u8( rr, uint8x16_t() ); + uint8x16x2_t grn = vzipq_u8( gg, uint8x16_t() ); + uint8x16x2_t blu = vzipq_u8( bb, uint8x16_t() ); + ch.r = red; + ch.b = blu; + ch.g = grn; +#endif + return ch; +} +#endif + +#if defined __AVX2__ || (defined __ARM_NEON && defined __aarch64__) +static etcpak_force_inline void CalculateLuma( Channels& ch, Luma& luma ) +#else +static etcpak_force_inline void CalculateLuma( const uint8_t* src, Luma& luma ) +#endif +{ +#ifdef __AVX2__ + __m256i b16_luma = _mm256_mullo_epi16( _mm256_cvtepu8_epi16( ch.b8 ), _mm256_set1_epi16( 14 ) ); + __m256i g16_luma = _mm256_mullo_epi16( _mm256_cvtepu8_epi16( ch.g8 ), _mm256_set1_epi16( 76 ) ); + __m256i r16_luma = _mm256_mullo_epi16( _mm256_cvtepu8_epi16( ch.r8 ), _mm256_set1_epi16( 38 ) ); + + __m256i luma_16bit = _mm256_add_epi16( _mm256_add_epi16( g16_luma, r16_luma ), b16_luma ); + __m256i luma_8bit_m256i = _mm256_srli_epi16( luma_16bit, 7 ); + __m128i luma_8bit_lo = _mm256_extractf128_si256( luma_8bit_m256i, 0 ); + __m128i luma_8bit_hi = _mm256_extractf128_si256( luma_8bit_m256i, 1 ); + + static const __m128i interleaving_mask_lo = _mm_set_epi8( 15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0 ); + static const __m128i interleaving_mask_hi = _mm_set_epi8( 14, 12, 10, 8, 6, 4, 2, 0, 15, 13, 11, 9, 7, 5, 3, 1 ); + __m128i luma_8bit_lo_moved = _mm_shuffle_epi8( luma_8bit_lo, interleaving_mask_lo ); + __m128i luma_8bit_hi_moved = _mm_shuffle_epi8( luma_8bit_hi, interleaving_mask_hi ); + __m128i luma_8bit = _mm_or_si128( luma_8bit_hi_moved, luma_8bit_lo_moved ); + luma.luma8 = luma_8bit; + + // min/max calculation + luma.min = hMin( luma_8bit, luma.minIdx ) * 0.00392156f; + luma.max = hMax( luma_8bit, luma.maxIdx ) * 0.00392156f; +#elif defined __ARM_NEON && defined __aarch64__ + //load pixel data into 4 rows + uint16x8_t red0 = vmulq_n_u16( vreinterpretq_u16_u8( ch.r.val[0] ), 14 ); + uint16x8_t red1 = vmulq_n_u16( vreinterpretq_u16_u8( ch.r.val[1] ), 14 ); + uint16x8_t grn0 = vmulq_n_u16( vreinterpretq_u16_u8( ch.g.val[0] ), 76 ); + uint16x8_t grn1 = vmulq_n_u16( vreinterpretq_u16_u8( ch.g.val[1] ), 76 ); + uint16x8_t blu0 = vmulq_n_u16( vreinterpretq_u16_u8( ch.b.val[0] ), 38 ); + uint16x8_t blu1 = vmulq_n_u16( vreinterpretq_u16_u8( ch.b.val[1] ), 38 ); + + //calculate luma for rows 0,1 and 2,3 + uint16x8_t lum_r01 = vaddq_u16( vaddq_u16( red0, grn0 ), blu0 ); + uint16x8_t lum_r23 = vaddq_u16( vaddq_u16( red1, grn1 ), blu1 ); + + //divide luma values with right shift and narrow results to 8bit + uint8x8_t lum_r01_d = vshrn_n_u16( lum_r01, 7 ); + uint8x8_t lum_r02_d = vshrn_n_u16( lum_r23, 7 ); + + luma.luma8 = vcombine_u8( lum_r01_d, lum_r02_d ); + //find min and max luma value + luma.min = hMin( luma.luma8, luma.minIdx ) * 0.00392156f; + luma.max = hMax( luma.luma8, luma.maxIdx ) * 0.00392156f; +#else + for( int i = 0; i < 16; ++i ) + { + luma.val[i] = ( src[i * 4 + 2] * 76 + src[i * 4 + 1] * 150 + src[i * 4] * 28 ) / 254; // luma calculation + if( luma.min > luma.val[i] ) + { + luma.min = luma.val[i]; + luma.minIdx = i; + } + if( luma.max < luma.val[i] ) + { + luma.max = luma.val[i]; + luma.maxIdx = i; + } + } +#endif +} + +static etcpak_force_inline uint8_t SelectModeETC2( const Luma& luma ) +{ +#if defined __AVX2__ || defined __ARM_NEON + const float lumaRange = ( luma.max - luma.min ); +#else + const float lumaRange = ( luma.max - luma.min ) * ( 1.f / 255.f ); +#endif + // filters a very-low-contrast block + if( lumaRange <= ecmd_threshold[0] ) + { + return ModePlanar; + } + // checks whether a pair of the corner pixels in a block has the min/max luma values; + // if so, the ETC2 planar mode is enabled, and otherwise, the ETC1 mode is enabled + else if( lumaRange <= ecmd_threshold[1] ) + { +#ifdef __AVX2__ + static const __m128i corner_pair = _mm_set_epi8( 1, 1, 1, 1, 1, 1, 1, 1, 0, 15, 3, 12, 12, 3, 15, 0 ); + __m128i current_max_min = _mm_set_epi8( 0, 0, 0, 0, 0, 0, 0, 0, luma.minIdx, luma.maxIdx, luma.minIdx, luma.maxIdx, luma.minIdx, luma.maxIdx, luma.minIdx, luma.maxIdx ); + + __m128i max_min_result = _mm_cmpeq_epi16( corner_pair, current_max_min ); + + int mask = _mm_movemask_epi8( max_min_result ); + if( mask ) + { + return ModePlanar; + } +#else + // check whether a pair of the corner pixels in a block has the min/max luma values; + // if so, the ETC2 planar mode is enabled. + if( ( luma.minIdx == 0 && luma.maxIdx == 15 ) || + ( luma.minIdx == 15 && luma.maxIdx == 0 ) || + ( luma.minIdx == 3 && luma.maxIdx == 12 ) || + ( luma.minIdx == 12 && luma.maxIdx == 3 ) ) + { + return ModePlanar; + } +#endif + } + // filters a high-contrast block for checking both ETC1 mode and the ETC2 T/H mode + else if( lumaRange >= ecmd_threshold[2] ) + { + return ModeTH; + } + return ModeUndecided; +} + +static etcpak_force_inline uint64_t ProcessRGB_ETC2( const uint8_t* src, bool useHeuristics ) +{ +#ifdef __AVX2__ + uint64_t d = CheckSolid_AVX2( src ); + if( d != 0 ) return d; +#else + uint64_t d = CheckSolid( src ); + if (d != 0) return d; +#endif + + uint8_t mode = ModeUndecided; + Luma luma; +#ifdef __AVX2__ + Channels ch = GetChannels( src ); + if( useHeuristics ) + { + CalculateLuma( ch, luma ); + mode = SelectModeETC2( luma ); + } + + auto plane = Planar_AVX2( ch, mode, useHeuristics ); + if( useHeuristics && mode == ModePlanar ) return plane.plane; + + alignas( 32 ) v4i a[8]; + __m128i err0 = PrepareAverages_AVX2( a, plane.sum4 ); + + // Get index of minimum error (err0) + __m128i err1 = _mm_shuffle_epi32( err0, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i errMin0 = _mm_min_epu32(err0, err1); + + __m128i errMin1 = _mm_shuffle_epi32( errMin0, _MM_SHUFFLE( 1, 0, 3, 2 ) ); + __m128i errMin2 = _mm_min_epu32( errMin1, errMin0 ); + + __m128i errMask = _mm_cmpeq_epi32( errMin2, err0 ); + + uint32_t mask = _mm_movemask_epi8( errMask ); + + size_t idx = _bit_scan_forward( mask ) >> 2; + + d = EncodeAverages_AVX2( a, idx ); + + alignas(32) uint32_t terr[2][8] = {}; + alignas(32) uint32_t tsel[8]; + + if ((idx == 0) || (idx == 2)) + { + FindBestFit_4x2_AVX2( terr, tsel, a, idx * 2, src ); + } + else + { + FindBestFit_2x4_AVX2( terr, tsel, a, idx * 2, src ); + } + + if( useHeuristics ) + { + if( mode == ModeTH ) + { + uint64_t result = 0; + uint64_t error = 0; + uint32_t compressed[4] = { 0, 0, 0, 0 }; + bool tMode = false; + + error = compressBlockTH( (uint8_t*)src, luma, compressed[0], compressed[1], tMode, ch.r8, ch.g8, ch.b8 ); + if( tMode ) + { + stuff59bits( compressed[0], compressed[1], compressed[2], compressed[3] ); + } + else + { + stuff58bits( compressed[0], compressed[1], compressed[2], compressed[3] ); + } + + result = (uint32_t)_bswap( compressed[2] ); + result |= static_cast( _bswap( compressed[3] ) ) << 32; + + plane.plane = result; + plane.error = error; + } + else + { + plane.plane = 0; + plane.error = MaxError; + } + } + + return EncodeSelectors_AVX2( d, terr, tsel, ( idx % 2 ) == 1, plane.plane, plane.error ); +#else + if( useHeuristics ) + { +#if defined __ARM_NEON && defined __aarch64__ + Channels ch = GetChannels( src ); + CalculateLuma( ch, luma ); +#else + CalculateLuma( src, luma ); +#endif + mode = SelectModeETC2( luma ); + } +#ifdef __ARM_NEON + auto result = Planar_NEON( src, mode, useHeuristics ); +#else + auto result = Planar( src, mode, useHeuristics ); +#endif + if( result.second == 0 ) return result.first; + + v4i a[8]; + unsigned int err[4] = {}; + PrepareAverages( a, src, err ); + size_t idx = GetLeastError( err, 4 ); + EncodeAverages( d, a, idx ); + +#if ( defined __SSE4_1__ || defined __ARM_NEON ) && !defined REFERENCE_IMPLEMENTATION + uint32_t terr[2][8] = {}; +#else + uint64_t terr[2][8] = {}; +#endif + uint16_t tsel[16][8]; + auto id = g_id[idx]; + FindBestFit( terr, tsel, a, id, src ); + + if( useHeuristics ) + { + if( mode == ModeTH ) + { + uint32_t compressed[4] = { 0, 0, 0, 0 }; + bool tMode = false; + + result.second = compressBlockTH( (uint8_t*)src, luma, compressed[0], compressed[1], tMode ); + if( tMode ) + { + stuff59bits( compressed[0], compressed[1], compressed[2], compressed[3] ); + } + else + { + stuff58bits( compressed[0], compressed[1], compressed[2], compressed[3] ); + } + + result.first = (uint32_t)_bswap( compressed[2] ); + result.first |= static_cast( _bswap( compressed[3] ) ) << 32; + } + else + { + result.first = 0; + result.second = MaxError; + } + } + + return EncodeSelectors( d, terr, tsel, id, result.first, result.second ); +#endif +} + +#ifdef __SSE4_1__ +template +static etcpak_force_inline __m128i Widen( const __m128i src ) +{ + static_assert( K >= 0 && K <= 7, "Index out of range" ); + + __m128i tmp; + switch( K ) + { + case 0: + tmp = _mm_shufflelo_epi16( src, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + case 1: + tmp = _mm_shufflelo_epi16( src, _MM_SHUFFLE( 1, 1, 1, 1 ) ); + return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + case 2: + tmp = _mm_shufflelo_epi16( src, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + case 3: + tmp = _mm_shufflelo_epi16( src, _MM_SHUFFLE( 3, 3, 3, 3 ) ); + return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + case 4: + tmp = _mm_shufflehi_epi16( src, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + case 5: + tmp = _mm_shufflehi_epi16( src, _MM_SHUFFLE( 1, 1, 1, 1 ) ); + return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + case 6: + tmp = _mm_shufflehi_epi16( src, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + case 7: + tmp = _mm_shufflehi_epi16( src, _MM_SHUFFLE( 3, 3, 3, 3 ) ); + return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + } +} + +static etcpak_force_inline int GetMulSel( int sel ) +{ + switch( sel ) + { + case 0: + return 0; + case 1: + case 2: + case 3: + return 1; + case 4: + return 2; + case 5: + case 6: + case 7: + return 3; + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + return 4; + case 14: + case 15: + return 5; + } +} + +#endif + +#ifdef __ARM_NEON + +static constexpr etcpak_force_inline int GetMulSel(int sel) +{ + return ( sel < 1 ) ? 0 : ( sel < 4 ) ? 1 : ( sel < 5 ) ? 2 : ( sel < 8 ) ? 3 : ( sel < 14 ) ? 4 : 5; +} + +static constexpr int ClampConstant( int x, int min, int max ) +{ + return x < min ? min : x > max ? max : x; +} + +template +etcpak_force_inline static uint16x8_t ErrorProbe_EAC_NEON( uint8x8_t recVal, uint8x16_t alphaBlock ) +{ + uint8x8_t srcValWide; +#ifndef __aarch64__ + if( Index < 8 ) + srcValWide = vdup_lane_u8( vget_low_u8( alphaBlock ), ClampConstant( Index, 0, 7 ) ); + else + srcValWide = vdup_lane_u8( vget_high_u8( alphaBlock ), ClampConstant( Index - 8, 0, 7 ) ); +#else + srcValWide = vdup_laneq_u8( alphaBlock, Index ); +#endif + + uint8x8_t deltaVal = vabd_u8( srcValWide, recVal ); + return vmull_u8( deltaVal, deltaVal ); +} + +etcpak_force_inline static uint16_t MinError_EAC_NEON( uint16x8_t errProbe ) +{ +#ifndef __aarch64__ + uint16x4_t tmpErr = vpmin_u16( vget_low_u16( errProbe ), vget_high_u16( errProbe ) ); + tmpErr = vpmin_u16( tmpErr, tmpErr ); + return vpmin_u16( tmpErr, tmpErr )[0]; +#else + return vminvq_u16( errProbe ); +#endif +} + +template +etcpak_force_inline static uint64_t MinErrorIndex_EAC_NEON( uint8x8_t recVal, uint8x16_t alphaBlock ) +{ + uint16x8_t errProbe = ErrorProbe_EAC_NEON( recVal, alphaBlock ); + uint16x8_t minErrMask = vceqq_u16( errProbe, vdupq_n_u16( MinError_EAC_NEON( errProbe ) ) ); + uint64_t idx = __builtin_ctzll( vget_lane_u64( vreinterpret_u64_u8( vqmovn_u16( minErrMask ) ), 0 ) ); + idx >>= 3; + idx <<= 45 - Index * 3; + + return idx; +} + +template +etcpak_force_inline static int16x8_t WidenMultiplier_EAC_NEON( int16x8_t multipliers ) +{ + constexpr int Lane = GetMulSel( Index ); +#ifndef __aarch64__ + if( Lane < 4 ) + return vdupq_lane_s16( vget_low_s16( multipliers ), ClampConstant( Lane, 0, 3 ) ); + else + return vdupq_lane_s16( vget_high_s16( multipliers ), ClampConstant( Lane - 4, 0, 3 ) ); +#else + return vdupq_laneq_s16( multipliers, Lane ); +#endif +} + +#endif + +template +static etcpak_force_inline uint64_t ProcessAlpha_ETC2( const uint8_t* src ) +{ +#if defined __SSE4_1__ + __m128i s = _mm_loadu_si128( (__m128i*)src ); + + if( checkSolid ) + { + // Check solid + __m128i solidCmp = _mm_set1_epi8( src[0] ); + __m128i cmpRes = _mm_cmpeq_epi8( s, solidCmp ); + if( _mm_testc_si128( cmpRes, _mm_set1_epi32( -1 ) ) ) + { + return src[0]; + } + } + + // Calculate min, max + __m128i s1 = _mm_shuffle_epi32( s, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i max1 = _mm_max_epu8( s, s1 ); + __m128i min1 = _mm_min_epu8( s, s1 ); + __m128i smax2 = _mm_shuffle_epi32( max1, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i smin2 = _mm_shuffle_epi32( min1, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i max2 = _mm_max_epu8( max1, smax2 ); + __m128i min2 = _mm_min_epu8( min1, smin2 ); + __m128i smax3 = _mm_alignr_epi8( max2, max2, 2 ); + __m128i smin3 = _mm_alignr_epi8( min2, min2, 2 ); + __m128i max3 = _mm_max_epu8( max2, smax3 ); + __m128i min3 = _mm_min_epu8( min2, smin3 ); + __m128i smax4 = _mm_alignr_epi8( max3, max3, 1 ); + __m128i smin4 = _mm_alignr_epi8( min3, min3, 1 ); + __m128i max = _mm_max_epu8( max3, smax4 ); + __m128i min = _mm_min_epu8( min3, smin4 ); + __m128i max16 = _mm_unpacklo_epi8( max, _mm_setzero_si128() ); + __m128i min16 = _mm_unpacklo_epi8( min, _mm_setzero_si128() ); + + // src range, mid + __m128i srcRange = _mm_sub_epi16( max16, min16 ); + __m128i srcRangeHalf = _mm_srli_epi16( srcRange, 1 ); + __m128i srcMid = _mm_add_epi16( min16, srcRangeHalf ); + + // multiplier + __m128i mul1 = _mm_mulhi_epi16( srcRange, g_alphaRange_SIMD ); + __m128i mul = _mm_add_epi16( mul1, _mm_set1_epi16( 1 ) ); + + // wide source + __m128i s16_1 = _mm_shuffle_epi32( s, _MM_SHUFFLE( 3, 2, 3, 2 ) ); + __m128i s16[2] = { _mm_unpacklo_epi8( s, _mm_setzero_si128() ), _mm_unpacklo_epi8( s16_1, _mm_setzero_si128() ) }; + + __m128i sr[16] = { + Widen<0>( s16[0] ), + Widen<1>( s16[0] ), + Widen<2>( s16[0] ), + Widen<3>( s16[0] ), + Widen<4>( s16[0] ), + Widen<5>( s16[0] ), + Widen<6>( s16[0] ), + Widen<7>( s16[0] ), + Widen<0>( s16[1] ), + Widen<1>( s16[1] ), + Widen<2>( s16[1] ), + Widen<3>( s16[1] ), + Widen<4>( s16[1] ), + Widen<5>( s16[1] ), + Widen<6>( s16[1] ), + Widen<7>( s16[1] ) + }; + +#ifdef __AVX2__ + __m256i srcRangeWide = _mm256_broadcastsi128_si256( srcRange ); + __m256i srcMidWide = _mm256_broadcastsi128_si256( srcMid ); + + __m256i mulWide1 = _mm256_mulhi_epi16( srcRangeWide, g_alphaRange_AVX ); + __m256i mulWide = _mm256_add_epi16( mulWide1, _mm256_set1_epi16( 1 ) ); + + __m256i modMul[8] = { + _mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[0] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[0] ) ) ), _mm256_setzero_si256() ), + _mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[1] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[1] ) ) ), _mm256_setzero_si256() ), + _mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[2] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[2] ) ) ), _mm256_setzero_si256() ), + _mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[3] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[3] ) ) ), _mm256_setzero_si256() ), + _mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[4] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[4] ) ) ), _mm256_setzero_si256() ), + _mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[5] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[5] ) ) ), _mm256_setzero_si256() ), + _mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[6] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[6] ) ) ), _mm256_setzero_si256() ), + _mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[7] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[7] ) ) ), _mm256_setzero_si256() ), + }; + + // find selector + __m256i mulErr = _mm256_setzero_si256(); + for( int j=0; j<16; j++ ) + { + __m256i s16Wide = _mm256_broadcastsi128_si256( sr[j] ); + __m256i err1, err2; + + err1 = _mm256_sub_epi16( s16Wide, modMul[0] ); + __m256i localErr = _mm256_mullo_epi16( err1, err1 ); + + err1 = _mm256_sub_epi16( s16Wide, modMul[1] ); + err2 = _mm256_mullo_epi16( err1, err1 ); + localErr = _mm256_min_epu16( localErr, err2 ); + + err1 = _mm256_sub_epi16( s16Wide, modMul[2] ); + err2 = _mm256_mullo_epi16( err1, err1 ); + localErr = _mm256_min_epu16( localErr, err2 ); + + err1 = _mm256_sub_epi16( s16Wide, modMul[3] ); + err2 = _mm256_mullo_epi16( err1, err1 ); + localErr = _mm256_min_epu16( localErr, err2 ); + + err1 = _mm256_sub_epi16( s16Wide, modMul[4] ); + err2 = _mm256_mullo_epi16( err1, err1 ); + localErr = _mm256_min_epu16( localErr, err2 ); + + err1 = _mm256_sub_epi16( s16Wide, modMul[5] ); + err2 = _mm256_mullo_epi16( err1, err1 ); + localErr = _mm256_min_epu16( localErr, err2 ); + + err1 = _mm256_sub_epi16( s16Wide, modMul[6] ); + err2 = _mm256_mullo_epi16( err1, err1 ); + localErr = _mm256_min_epu16( localErr, err2 ); + + err1 = _mm256_sub_epi16( s16Wide, modMul[7] ); + err2 = _mm256_mullo_epi16( err1, err1 ); + localErr = _mm256_min_epu16( localErr, err2 ); + + // note that this can overflow, but since we're looking for the smallest error, it shouldn't matter + mulErr = _mm256_adds_epu16( mulErr, localErr ); + } + uint64_t minPos1 = _mm_cvtsi128_si64( _mm_minpos_epu16( _mm256_castsi256_si128( mulErr ) ) ); + uint64_t minPos2 = _mm_cvtsi128_si64( _mm_minpos_epu16( _mm256_extracti128_si256( mulErr, 1 ) ) ); + int sel = ( ( minPos1 & 0xFFFF ) < ( minPos2 & 0xFFFF ) ) ? ( minPos1 >> 16 ) : ( 8 + ( minPos2 >> 16 ) ); + + __m128i recVal16; + switch( sel ) + { + case 0: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<0>( mul ), g_alpha_SIMD[0] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<0>( mul ), g_alpha_SIMD[0] ) ) ), _mm_setzero_si128() ); + break; + case 1: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[1] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[1] ) ) ), _mm_setzero_si128() ); + break; + case 2: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[2] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[2] ) ) ), _mm_setzero_si128() ); + break; + case 3: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[3] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[3] ) ) ), _mm_setzero_si128() ); + break; + case 4: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<2>( mul ), g_alpha_SIMD[4] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<2>( mul ), g_alpha_SIMD[4] ) ) ), _mm_setzero_si128() ); + break; + case 5: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[5] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[5] ) ) ), _mm_setzero_si128() ); + break; + case 6: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[6] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[6] ) ) ), _mm_setzero_si128() ); + break; + case 7: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[7] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[7] ) ) ), _mm_setzero_si128() ); + break; + case 8: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[8] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[8] ) ) ), _mm_setzero_si128() ); + break; + case 9: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[9] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[9] ) ) ), _mm_setzero_si128() ); + break; + case 10: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[10] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[10] ) ) ), _mm_setzero_si128() ); + break; + case 11: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[11] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[11] ) ) ), _mm_setzero_si128() ); + break; + case 12: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[12] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[12] ) ) ), _mm_setzero_si128() ); + break; + case 13: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[13] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[13] ) ) ), _mm_setzero_si128() ); + break; + case 14: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[14] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[14] ) ) ), _mm_setzero_si128() ); + break; + case 15: + recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[15] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[15] ) ) ), _mm_setzero_si128() ); + break; + default: + assert( false ); + break; + } +#else + // wide multiplier + __m128i rangeMul[16] = { + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<0>( mul ), g_alpha_SIMD[0] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<0>( mul ), g_alpha_SIMD[0] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[1] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[1] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[2] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[2] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[3] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[3] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<2>( mul ), g_alpha_SIMD[4] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<2>( mul ), g_alpha_SIMD[4] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[5] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[5] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[6] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[6] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[7] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[7] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[8] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[8] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[9] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[9] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[10] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[10] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[11] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[11] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[12] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[12] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[13] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[13] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[14] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[14] ) ) ), _mm_setzero_si128() ), + _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[15] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[15] ) ) ), _mm_setzero_si128() ) + }; + + // find selector + int err = std::numeric_limits::max(); + int sel; + for( int r=0; r<16; r++ ) + { + __m128i err1, err2, minerr; + __m128i recVal16 = rangeMul[r]; + int rangeErr; + + err1 = _mm_sub_epi16( sr[0], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr = _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[1], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[2], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[3], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[4], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[5], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[6], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[7], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[8], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[9], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[10], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[11], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[12], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[13], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[14], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + err1 = _mm_sub_epi16( sr[15], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF; + + if( rangeErr < err ) + { + err = rangeErr; + sel = r; + if( err == 0 ) break; + } + } + + __m128i recVal16 = rangeMul[sel]; +#endif + + // find indices + __m128i err1, err2, minerr; + uint64_t idx = 0, tmp; + + err1 = _mm_sub_epi16( sr[0], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 15*3; + + err1 = _mm_sub_epi16( sr[1], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 14*3; + + err1 = _mm_sub_epi16( sr[2], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 13*3; + + err1 = _mm_sub_epi16( sr[3], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 12*3; + + err1 = _mm_sub_epi16( sr[4], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 11*3; + + err1 = _mm_sub_epi16( sr[5], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 10*3; + + err1 = _mm_sub_epi16( sr[6], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 9*3; + + err1 = _mm_sub_epi16( sr[7], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 8*3; + + err1 = _mm_sub_epi16( sr[8], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 7*3; + + err1 = _mm_sub_epi16( sr[9], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 6*3; + + err1 = _mm_sub_epi16( sr[10], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 5*3; + + err1 = _mm_sub_epi16( sr[11], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 4*3; + + err1 = _mm_sub_epi16( sr[12], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 3*3; + + err1 = _mm_sub_epi16( sr[13], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 2*3; + + err1 = _mm_sub_epi16( sr[14], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 1*3; + + err1 = _mm_sub_epi16( sr[15], recVal16 ); + err2 = _mm_mullo_epi16( err1, err1 ); + minerr = _mm_minpos_epu16( err2 ); + tmp = _mm_cvtsi128_si64( minerr ); + idx |= ( tmp >> 16 ) << 0*3; + + uint16_t rm[8]; + _mm_storeu_si128( (__m128i*)rm, mul ); + uint16_t sm = _mm_cvtsi128_si64( srcMid ); + + uint64_t d = ( uint64_t( sm ) << 56 ) | + ( uint64_t( rm[GetMulSel( sel )] ) << 52 ) | + ( uint64_t( sel ) << 48 ) | + idx; + + return _bswap64( d ); +#elif defined __ARM_NEON + + int16x8_t srcMidWide, multipliers; + int srcMid; + uint8x16_t srcAlphaBlock = vld1q_u8( src ); + { + if( checkSolid ) + { + uint8_t ref = src[0]; + uint8x16_t a0 = vdupq_n_u8( ref ); + uint8x16_t r = vceqq_u8( srcAlphaBlock, a0 ); + int64x2_t m = vreinterpretq_s64_u8( r ); + if( m[0] == -1 && m[1] == -1 ) + return ref; + } + + // srcRange +#ifdef __aarch64__ + uint8_t min = vminvq_u8( srcAlphaBlock ); + uint8_t max = vmaxvq_u8( srcAlphaBlock ); + uint8_t srcRange = max - min; + multipliers = vqaddq_s16( vshrq_n_s16( vqdmulhq_n_s16( g_alphaRange_NEON, srcRange ), 1 ), vdupq_n_s16( 1 ) ); + srcMid = min + srcRange / 2; + srcMidWide = vdupq_n_s16( srcMid ); +#else + uint8x8_t vmin = vpmin_u8( vget_low_u8( srcAlphaBlock ), vget_high_u8( srcAlphaBlock ) ); + vmin = vpmin_u8( vmin, vmin ); + vmin = vpmin_u8( vmin, vmin ); + vmin = vpmin_u8( vmin, vmin ); + uint8x8_t vmax = vpmax_u8( vget_low_u8( srcAlphaBlock ), vget_high_u8( srcAlphaBlock ) ); + vmax = vpmax_u8( vmax, vmax ); + vmax = vpmax_u8( vmax, vmax ); + vmax = vpmax_u8( vmax, vmax ); + + int16x8_t srcRangeWide = vreinterpretq_s16_u16( vsubl_u8( vmax, vmin ) ); + multipliers = vqaddq_s16( vshrq_n_s16( vqdmulhq_s16( g_alphaRange_NEON, srcRangeWide ), 1 ), vdupq_n_s16( 1 ) ); + srcMidWide = vsraq_n_s16( vreinterpretq_s16_u16(vmovl_u8(vmin)), srcRangeWide, 1); + srcMid = vgetq_lane_s16( srcMidWide, 0 ); +#endif + } + + // calculate reconstructed values +#define EAC_APPLY_16X( m ) m( 0 ) m( 1 ) m( 2 ) m( 3 ) m( 4 ) m( 5 ) m( 6 ) m( 7 ) m( 8 ) m( 9 ) m( 10 ) m( 11 ) m( 12 ) m( 13 ) m( 14 ) m( 15 ) + +#define EAC_RECONSTRUCT_VALUE( n ) vqmovun_s16( vmlaq_s16( srcMidWide, g_alpha_NEON[n], WidenMultiplier_EAC_NEON( multipliers ) ) ), + uint8x8_t recVals[16] = { EAC_APPLY_16X( EAC_RECONSTRUCT_VALUE ) }; + + // find selector + int err = std::numeric_limits::max(); + int sel = 0; + for( int r = 0; r < 16; r++ ) + { + uint8x8_t recVal = recVals[r]; + + int rangeErr = 0; +#define EAC_ACCUMULATE_ERROR( n ) rangeErr += MinError_EAC_NEON( ErrorProbe_EAC_NEON( recVal, srcAlphaBlock ) ); + EAC_APPLY_16X( EAC_ACCUMULATE_ERROR ) + + if( rangeErr < err ) + { + err = rangeErr; + sel = r; + if ( err == 0 ) break; + } + } + + // combine results + uint64_t d = ( uint64_t( srcMid ) << 56 ) | + ( uint64_t( multipliers[GetMulSel( sel )] ) << 52 ) | + ( uint64_t( sel ) << 48); + + // generate indices + uint8x8_t recVal = recVals[sel]; +#define EAC_INSERT_INDEX(n) d |= MinErrorIndex_EAC_NEON( recVal, srcAlphaBlock ); + EAC_APPLY_16X( EAC_INSERT_INDEX ) + + return _bswap64( d ); + +#undef EAC_APPLY_16X +#undef EAC_INSERT_INDEX +#undef EAC_ACCUMULATE_ERROR +#undef EAC_RECONSTRUCT_VALUE + +#else + if( checkSolid ) + { + bool solid = true; + const uint8_t* ptr = src + 1; + const uint8_t ref = *src; + for( int i=1; i<16; i++ ) + { + if( ref != *ptr++ ) + { + solid = false; + break; + } + } + if( solid ) + { + return ref; + } + } + + uint8_t min = src[0]; + uint8_t max = src[0]; + for( int i=1; i<16; i++ ) + { + if( min > src[i] ) min = src[i]; + else if( max < src[i] ) max = src[i]; + } + int srcRange = max - min; + int srcMid = min + srcRange / 2; + + uint8_t buf[16][16]; + int err = std::numeric_limits::max(); + int sel; + int selmul; + for( int r=0; r<16; r++ ) + { + int mul = ( ( srcRange * g_alphaRange[r] ) >> 16 ) + 1; + + int rangeErr = 0; + for( int i=0; i<16; i++ ) + { + const auto srcVal = src[i]; + + int idx = 0; + const auto modVal = g_alpha[r][0] * mul; + const auto recVal = clampu8( srcMid + modVal ); + int localErr = sq( srcVal - recVal ); + + if( localErr != 0 ) + { + for( int j=1; j<8; j++ ) + { + const auto modVal = g_alpha[r][j] * mul; + const auto recVal = clampu8( srcMid + modVal ); + const auto errProbe = sq( srcVal - recVal ); + if( errProbe < localErr ) + { + localErr = errProbe; + idx = j; + } + } + } + + buf[r][i] = idx; + rangeErr += localErr; + } + + if( rangeErr < err ) + { + err = rangeErr; + sel = r; + selmul = mul; + if( err == 0 ) break; + } + } + + uint64_t d = ( uint64_t( srcMid ) << 56 ) | + ( uint64_t( selmul ) << 52 ) | + ( uint64_t( sel ) << 48 ); + + int offset = 45; + auto ptr = buf[sel]; + for( int i=0; i<16; i++ ) + { + d |= uint64_t( *ptr++ ) << offset; + offset -= 3; + } + + return _bswap64( d ); +#endif +} + +void CompressEtc1Rgb( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int w = 0; + uint32_t buf[4*4]; + do + { +#ifdef __SSE4_1__ + __m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) ); + __m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) ); + __m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) ); + __m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) ); + + _MM_TRANSPOSE4_PS( px0, px1, px2, px3 ); + + _mm_store_si128( (__m128i*)(buf + 0), _mm_castps_si128( px0 ) ); + _mm_store_si128( (__m128i*)(buf + 4), _mm_castps_si128( px1 ) ); + _mm_store_si128( (__m128i*)(buf + 8), _mm_castps_si128( px2 ) ); + _mm_store_si128( (__m128i*)(buf + 12), _mm_castps_si128( px3 ) ); + + src += 4; +#else + auto ptr = buf; + for( int x=0; x<4; x++ ) + { + *ptr++ = *src; + src += width; + *ptr++ = *src; + src += width; + *ptr++ = *src; + src += width; + *ptr++ = *src; + src -= width * 3 - 1; + } +#endif + if( ++w == width/4 ) + { + src += width * 3; + w = 0; + } + *dst++ = ProcessRGB( (uint8_t*)buf ); + } + while( --blocks ); +} + +void CompressEtc1RgbDither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int w = 0; + uint32_t buf[4*4]; + do + { +#ifdef __SSE4_1__ + __m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) ); + __m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) ); + __m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) ); + __m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) ); + + _MM_TRANSPOSE4_PS( px0, px1, px2, px3 ); + +# ifdef __AVX2__ + DitherAvx2( (uint8_t*)buf, _mm_castps_si128( px0 ), _mm_castps_si128( px1 ), _mm_castps_si128( px2 ), _mm_castps_si128( px3 ) ); +# else + _mm_store_si128( (__m128i*)(buf + 0), _mm_castps_si128( px0 ) ); + _mm_store_si128( (__m128i*)(buf + 4), _mm_castps_si128( px1 ) ); + _mm_store_si128( (__m128i*)(buf + 8), _mm_castps_si128( px2 ) ); + _mm_store_si128( (__m128i*)(buf + 12), _mm_castps_si128( px3 ) ); + + Dither( (uint8_t*)buf ); +# endif + + src += 4; +#else + auto ptr = buf; + for( int x=0; x<4; x++ ) + { + *ptr++ = *src; + src += width; + *ptr++ = *src; + src += width; + *ptr++ = *src; + src += width; + *ptr++ = *src; + src -= width * 3 - 1; + } +#endif + if( ++w == width/4 ) + { + src += width * 3; + w = 0; + } + *dst++ = ProcessRGB( (uint8_t*)buf ); + } + while( --blocks ); +} + +void CompressEtc2Rgb( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, bool useHeuristics ) +{ + int w = 0; + uint32_t buf[4*4]; + do + { +#ifdef __SSE4_1__ + __m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) ); + __m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) ); + __m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) ); + __m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) ); + + _MM_TRANSPOSE4_PS( px0, px1, px2, px3 ); + + _mm_store_si128( (__m128i*)(buf + 0), _mm_castps_si128( px0 ) ); + _mm_store_si128( (__m128i*)(buf + 4), _mm_castps_si128( px1 ) ); + _mm_store_si128( (__m128i*)(buf + 8), _mm_castps_si128( px2 ) ); + _mm_store_si128( (__m128i*)(buf + 12), _mm_castps_si128( px3 ) ); + + src += 4; +#else + auto ptr = buf; + for( int x=0; x<4; x++ ) + { + *ptr++ = *src; + src += width; + *ptr++ = *src; + src += width; + *ptr++ = *src; + src += width; + *ptr++ = *src; + src -= width * 3 - 1; + } +#endif + if( ++w == width/4 ) + { + src += width * 3; + w = 0; + } + *dst++ = ProcessRGB_ETC2( (uint8_t*)buf, useHeuristics ); + } + while( --blocks ); +} + +void CompressEtc2Rgba( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, bool useHeuristics ) +{ + int w = 0; + uint32_t rgba[4*4]; + uint8_t alpha[4*4]; + do + { +#ifdef __SSE4_1__ + __m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) ); + __m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) ); + __m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) ); + __m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) ); + + _MM_TRANSPOSE4_PS( px0, px1, px2, px3 ); + + __m128i c0 = _mm_castps_si128( px0 ); + __m128i c1 = _mm_castps_si128( px1 ); + __m128i c2 = _mm_castps_si128( px2 ); + __m128i c3 = _mm_castps_si128( px3 ); + + _mm_store_si128( (__m128i*)(rgba + 0), c0 ); + _mm_store_si128( (__m128i*)(rgba + 4), c1 ); + _mm_store_si128( (__m128i*)(rgba + 8), c2 ); + _mm_store_si128( (__m128i*)(rgba + 12), c3 ); + + __m128i mask = _mm_setr_epi32( 0x0f0b0703, -1, -1, -1 ); + + __m128i a0 = _mm_shuffle_epi8( c0, mask ); + __m128i a1 = _mm_shuffle_epi8( c1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i a2 = _mm_shuffle_epi8( c2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i a3 = _mm_shuffle_epi8( c3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + + __m128i s0 = _mm_or_si128( a0, a1 ); + __m128i s1 = _mm_or_si128( a2, a3 ); + __m128i s2 = _mm_or_si128( s0, s1 ); + + _mm_store_si128( (__m128i*)alpha, s2 ); + + src += 4; +#else + auto ptr = rgba; + auto ptr8 = alpha; + for( int x=0; x<4; x++ ) + { + auto v = *src; + *ptr++ = v; + *ptr8++ = v >> 24; + src += width; + v = *src; + *ptr++ = v; + *ptr8++ = v >> 24; + src += width; + v = *src; + *ptr++ = v; + *ptr8++ = v >> 24; + src += width; + v = *src; + *ptr++ = v; + *ptr8++ = v >> 24; + src -= width * 3 - 1; + } +#endif + if( ++w == width/4 ) + { + src += width * 3; + w = 0; + } + *dst++ = ProcessAlpha_ETC2( alpha ); + *dst++ = ProcessRGB_ETC2( (uint8_t*)rgba, useHeuristics ); + } + while( --blocks ); +} + +void CompressEacR( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int w = 0; + uint8_t r[4*4]; + do + { +#ifdef __SSE4_1__ + __m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) ); + __m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) ); + __m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) ); + __m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) ); + + _MM_TRANSPOSE4_PS( px0, px1, px2, px3 ); + + __m128i c0 = _mm_castps_si128( px0 ); + __m128i c1 = _mm_castps_si128( px1 ); + __m128i c2 = _mm_castps_si128( px2 ); + __m128i c3 = _mm_castps_si128( px3 ); + + __m128i mask = _mm_setr_epi32( 0x0e0a0602, -1, -1, -1 ); + + __m128i a0 = _mm_shuffle_epi8( c0, mask ); + __m128i a1 = _mm_shuffle_epi8( c1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i a2 = _mm_shuffle_epi8( c2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i a3 = _mm_shuffle_epi8( c3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + + __m128i s0 = _mm_or_si128( a0, a1 ); + __m128i s1 = _mm_or_si128( a2, a3 ); + __m128i s2 = _mm_or_si128( s0, s1 ); + + _mm_store_si128( (__m128i*)r, s2 ); + + src += 4; +#else + auto ptr8 = r; + for( int x=0; x<4; x++ ) + { + auto v = *src; + *ptr8++ = (v & 0xff0000) >> 16; + src += width; + v = *src; + *ptr8++ = (v & 0xff0000) >> 16; + src += width; + v = *src; + *ptr8++ = (v & 0xff0000) >> 16; + src += width; + v = *src; + *ptr8++ = (v & 0xff0000) >> 16; + src -= width * 3 - 1; + } +#endif + if( ++w == width/4 ) + { + src += width * 3; + w = 0; + } + *dst++ = ProcessAlpha_ETC2( r ); + } + while( --blocks ); +} + +void CompressEacRg( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int w = 0; + uint8_t rg[4*4*2]; + do + { +#ifdef __SSE4_1__ + __m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) ); + __m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) ); + __m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) ); + __m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) ); + + _MM_TRANSPOSE4_PS( px0, px1, px2, px3 ); + + __m128i c0 = _mm_castps_si128( px0 ); + __m128i c1 = _mm_castps_si128( px1 ); + __m128i c2 = _mm_castps_si128( px2 ); + __m128i c3 = _mm_castps_si128( px3 ); + + __m128i mask = _mm_setr_epi32( 0x0e0a0602, -1, -1, -1 ); + + __m128i r0 = _mm_shuffle_epi8( c0, mask ); + __m128i r1 = _mm_shuffle_epi8( c1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i r2 = _mm_shuffle_epi8( c2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i r3 = _mm_shuffle_epi8( c3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + + __m128i s0 = _mm_or_si128( r0, r1 ); + __m128i s1 = _mm_or_si128( r2, r3 ); + __m128i s2 = _mm_or_si128( s0, s1 ); + + _mm_store_si128( (__m128i*)rg, s2 ); + + mask = _mm_setr_epi32( 0x0d090501, -1, -1, -1 ); + + r0 = _mm_shuffle_epi8( c0, mask ); + r1 = _mm_shuffle_epi8( c1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + r2 = _mm_shuffle_epi8( c2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + r3 = _mm_shuffle_epi8( c3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + + s0 = _mm_or_si128( r0, r1 ); + s1 = _mm_or_si128( r2, r3 ); + s2 = _mm_or_si128( s0, s1 ); + + _mm_store_si128( (__m128i*)&rg[16], s2 ); + src += 4; +#else + auto ptrr = rg; + auto ptrg = ptrr + 16; + for( int x=0; x<4; x++ ) + { + auto v = *src; + *ptrr++ = (v & 0xff0000) >> 16; + *ptrg++ = (v & 0xff00) >> 8; + src += width; + v = *src; + *ptrr++ = (v & 0xff0000) >> 16; + *ptrg++ = (v & 0xff00) >> 8; + src += width; + v = *src; + *ptrr++ = (v & 0xff0000) >> 16; + *ptrg++ = (v & 0xff00) >> 8; + src += width; + v = *src; + *ptrr++ = (v & 0xff0000) >> 16; + *ptrg++ = (v & 0xff00) >> 8; + src -= width * 3 - 1; + } +#endif + if( ++w == width/4 ) + { + src += width * 3; + w = 0; + } + *dst++ = ProcessAlpha_ETC2( rg ); + *dst++ = ProcessAlpha_ETC2( &rg[16] ); + } + while( --blocks ); +} diff --git a/lib/etcpak/etcpak/ProcessRGB.hpp b/lib/etcpak/etcpak/ProcessRGB.hpp new file mode 100644 index 00000000000..087118fb0c5 --- /dev/null +++ b/lib/etcpak/etcpak/ProcessRGB.hpp @@ -0,0 +1,14 @@ +#ifndef __PROCESSRGB_HPP__ +#define __PROCESSRGB_HPP__ + +#include + +void CompressEtc1Rgb( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressEtc1RgbDither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressEtc2Rgb( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, bool useHeuristics ); +void CompressEtc2Rgba( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, bool useHeuristics ); + +void CompressEacR( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressEacRg( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); + +#endif diff --git a/lib/etcpak/etcpak/README.md b/lib/etcpak/etcpak/README.md new file mode 100644 index 00000000000..7166f98a935 --- /dev/null +++ b/lib/etcpak/etcpak/README.md @@ -0,0 +1,85 @@ +# etcpak 2.1 # + +## The fastest ETC compressor on the planet ## + +etcpak is an extremely fast [Ericsson Texture Compression](http://en.wikipedia.org/wiki/Ericsson_Texture_Compression) and [Block Compression](https://en.wikipedia.org/wiki/S3_Texture_Compression) utility. Currently it's best suited for rapid assets preparation during development, when graphics quality is not a concern, but it's also used in production builds of applications used by millions of people. + +## Compression times ## + +Benchmark performed on an AMD Ryzen 9 7950X, using a real-life RGBA 16K × 16K atlas. + +ETC1: ST: **797 Mpx/s**, MT: **9613 Mpx/s** +ETC2: ST: **356 Mpx/s**, MT: **6378 Mpx/s** +BC1: ST: **5730 Mpx/s**, MT: **10174 Mpx/s** +BC3: ST: **2437 Mpx/s**, MT: **8568 Mpx/s** +BC7: ST: **12.1 Mpx/s**, MT: **225 Mpx/s** + +The same benchmark performed on Intel i7 1185G7: + +ETC1: ST: **516 Mpx/s**, MT: **2223 Mpx/s** +ETC2: ST: **238 Mpx/s**, MT: **984 Mpx/s** +BC1: ST: **2969 Mpx/s**, MT: **9199 Mpx/s** +BC3: ST: **1351 Mpx/s**, MT: **5503 Mpx/s** +BC7: ST: **7.8 Mpx/s**, MT: **21.3 Mpx/s** + +Apple M3 Max benchmark: + +ETC1: ST: **204 Mpx/s**, MT: **2455 Mpx/s** +ETC2: ST: **101 Mpx/s**, MT: **1231 Mpx/s** +BC1: ST: **3255 Mpx/s**, MT: **30366 Mpx/s** +BC3: ST: **1147 Mpx/s**, MT: **13238 Mpx/s** +BC7: ST: **5.47 Mpx/s**, MT: **65.8 Mpx/s** + +[Why there's no image quality metrics? / Quality comparison.](http://i.imgur.com/FxlmUOF.png) + +## Decompression times ## + +etcpak can also decompress textures. Timings on Ryzen 7950X (all single-threaded): + +ETC1: **604 Mpx/s** +ETC2: **599 Mpx/s** +BC1: **1634 Mpx/s** +BC3: **1172 Mpx/s** +BC7: **201 Mpx/s** + +i7 1185G7: + +ETC1: **383 Mpx/s** +ETC2: **378 Mpx/s** +BC1: **1056 Mpx/s** +BC3: **788 Mpx/s** +BC7: **76 Mpx/s** + +M3 Max: + +ETC1: **690 Mpx/s** +ETC2: **786 Mpx/s** +BC1: **2434 Mpx/s** +BC3: **1414 Mpx/s** +BC7: **406 Mpx/s** + +To give some perspective here, Nvidia in-driver ETC2 decoder can do only 42.5 Mpx/s. + +## Quality comparison ## + +Original image: + +![](examples/kodim23.png) + +Compressed image: + +ETC1: + +![](examples/etc1.png "ETC1 mode") + +ETC2: + +![](examples/etc2.png "ETC2 mode") + +BC1: + +![](examples/dxtc.png "BC1 mode") + +BC7: + +![](examples/bc7.png "BC7 mode") diff --git a/lib/etcpak/etcpak/Semaphore.hpp b/lib/etcpak/etcpak/Semaphore.hpp new file mode 100644 index 00000000000..9e42dbb9e00 --- /dev/null +++ b/lib/etcpak/etcpak/Semaphore.hpp @@ -0,0 +1,46 @@ +#ifndef __DARKRL__SEMAPHORE_HPP__ +#define __DARKRL__SEMAPHORE_HPP__ + +#include +#include + +class Semaphore +{ +public: + Semaphore( int count ) : m_count( count ) {} + + void lock() + { + std::unique_lock lock( m_mutex ); + m_cv.wait( lock, [this](){ return m_count != 0; } ); + m_count--; + } + + void unlock() + { + std::lock_guard lock( m_mutex ); + m_count++; + m_cv.notify_one(); + } + + bool try_lock() + { + std::lock_guard lock( m_mutex ); + if( m_count == 0 ) + { + return false; + } + else + { + m_count--; + return true; + } + } + +private: + std::mutex m_mutex; + std::condition_variable m_cv; + unsigned int m_count; +}; + +#endif diff --git a/lib/etcpak/etcpak/System.cpp b/lib/etcpak/etcpak/System.cpp new file mode 100644 index 00000000000..1383d0ecd0e --- /dev/null +++ b/lib/etcpak/etcpak/System.cpp @@ -0,0 +1,68 @@ +#include +#ifdef _WIN32 +# include +#else +# include +# include +#endif + +#include "System.hpp" + +unsigned int System::CPUCores() +{ + static unsigned int cores = 0; + if( cores == 0 ) + { + int tmp; +#ifdef _WIN32 + SYSTEM_INFO info; + GetSystemInfo( &info ); + tmp = (int)info.dwNumberOfProcessors; +#else +# ifndef _SC_NPROCESSORS_ONLN +# ifdef _SC_NPROC_ONLN +# define _SC_NPROCESSORS_ONLN _SC_NPROC_ONLN +# elif defined _SC_CRAY_NCPU +# define _SC_NPROCESSORS_ONLN _SC_CRAY_NCPU +# endif +# endif + tmp = (int)(long)sysconf( _SC_NPROCESSORS_ONLN ); +#endif + cores = (unsigned int)std::max( tmp, 1 ); + } + return cores; +} + +void System::SetThreadName( std::thread& thread, const char* name ) +{ +#ifdef _WIN32 + const DWORD MS_VC_EXCEPTION=0x406D1388; + +# pragma pack( push, 8 ) + struct THREADNAME_INFO + { + DWORD dwType; + LPCSTR szName; + DWORD dwThreadID; + DWORD dwFlags; + }; +# pragma pack(pop) + + DWORD ThreadId = GetThreadId( static_cast( thread.native_handle() ) ); + THREADNAME_INFO info; + info.dwType = 0x1000; + info.szName = name; + info.dwThreadID = ThreadId; + info.dwFlags = 0; + + __try + { + RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info ); + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + } +#elif !defined(__APPLE__) + pthread_setname_np( thread.native_handle(), name ); +#endif +} diff --git a/lib/etcpak/etcpak/System.hpp b/lib/etcpak/etcpak/System.hpp new file mode 100644 index 00000000000..1a09bb15e1c --- /dev/null +++ b/lib/etcpak/etcpak/System.hpp @@ -0,0 +1,15 @@ +#ifndef __DARKRL__SYSTEM_HPP__ +#define __DARKRL__SYSTEM_HPP__ + +#include + +class System +{ +public: + System() = delete; + + static unsigned int CPUCores(); + static void SetThreadName( std::thread& thread, const char* name ); +}; + +#endif diff --git a/lib/etcpak/etcpak/Tables.cpp b/lib/etcpak/etcpak/Tables.cpp new file mode 100644 index 00000000000..65d7db74991 --- /dev/null +++ b/lib/etcpak/etcpak/Tables.cpp @@ -0,0 +1,223 @@ +#include "Tables.hpp" + +const int32_t g_table[8][4] = { + { 2, 8, -2, -8 }, + { 5, 17, -5, -17 }, + { 9, 29, -9, -29 }, + { 13, 42, -13, -42 }, + { 18, 60, -18, -60 }, + { 24, 80, -24, -80 }, + { 33, 106, -33, -106 }, + { 47, 183, -47, -183 } +}; + +const int64_t g_table256[8][4] = { + { 2*256, 8*256, -2*256, -8*256 }, + { 5*256, 17*256, -5*256, -17*256 }, + { 9*256, 29*256, -9*256, -29*256 }, + { 13*256, 42*256, -13*256, -42*256 }, + { 18*256, 60*256, -18*256, -60*256 }, + { 24*256, 80*256, -24*256, -80*256 }, + { 33*256, 106*256, -33*256, -106*256 }, + { 47*256, 183*256, -47*256, -183*256 } +}; + +const uint32_t g_id[4][16] = { + { 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, + { 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2 }, + { 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4 }, + { 7, 7, 6, 6, 7, 7, 6, 6, 7, 7, 6, 6, 7, 7, 6, 6 } +}; + +const uint32_t g_avg2[16] = { + 0x00, + 0x11, + 0x22, + 0x33, + 0x44, + 0x55, + 0x66, + 0x77, + 0x88, + 0x99, + 0xAA, + 0xBB, + 0xCC, + 0xDD, + 0xEE, + 0xFF +}; + +const uint32_t g_flags[64] = { + 0x80800402, 0x80800402, 0x80800402, 0x80800402, + 0x80800402, 0x80800402, 0x80800402, 0x8080E002, + 0x80800402, 0x80800402, 0x8080E002, 0x8080E002, + 0x80800402, 0x8080E002, 0x8080E002, 0x8080E002, + 0x80000402, 0x80000402, 0x80000402, 0x80000402, + 0x80000402, 0x80000402, 0x80000402, 0x8000E002, + 0x80000402, 0x80000402, 0x8000E002, 0x8000E002, + 0x80000402, 0x8000E002, 0x8000E002, 0x8000E002, + 0x00800402, 0x00800402, 0x00800402, 0x00800402, + 0x00800402, 0x00800402, 0x00800402, 0x0080E002, + 0x00800402, 0x00800402, 0x0080E002, 0x0080E002, + 0x00800402, 0x0080E002, 0x0080E002, 0x0080E002, + 0x00000402, 0x00000402, 0x00000402, 0x00000402, + 0x00000402, 0x00000402, 0x00000402, 0x0000E002, + 0x00000402, 0x00000402, 0x0000E002, 0x0000E002, + 0x00000402, 0x0000E002, 0x0000E002, 0x0000E002 +}; + +const int32_t g_alpha[16][8] = { + { -3, -6, -9, -15, 2, 5, 8, 14 }, + { -3, -7, -10, -13, 2, 6, 9, 12 }, + { -2, -5, -8, -13, 1, 4, 7, 12 }, + { -2, -4, -6, -13, 1, 3, 5, 12 }, + { -3, -6, -8, -12, 2, 5, 7, 11 }, + { -3, -7, -9, -11, 2, 6, 8, 10 }, + { -4, -7, -8, -11, 3, 6, 7, 10 }, + { -3, -5, -8, -11, 2, 4, 7, 10 }, + { -2, -6, -8, -10, 1, 5, 7, 9 }, + { -2, -5, -8, -10, 1, 4, 7, 9 }, + { -2, -4, -8, -10, 1, 3, 7, 9 }, + { -2, -5, -7, -10, 1, 4, 6, 9 }, + { -3, -4, -7, -10, 2, 3, 6, 9 }, + { -1, -2, -3, -10, 0, 1, 2, 9 }, + { -4, -6, -8, -9, 3, 5, 7, 8 }, + { -3, -5, -7, -9, 2, 4, 6, 8 } +}; + +const int32_t g_alpha11Mul[16] = { 1, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120 }; + +const int32_t g_alphaRange[16] = { + 0x100FF / ( 1 + g_alpha[0][7] - g_alpha[0][3] ), + 0x100FF / ( 1 + g_alpha[1][7] - g_alpha[1][3] ), + 0x100FF / ( 1 + g_alpha[2][7] - g_alpha[2][3] ), + 0x100FF / ( 1 + g_alpha[3][7] - g_alpha[3][3] ), + 0x100FF / ( 1 + g_alpha[4][7] - g_alpha[4][3] ), + 0x100FF / ( 1 + g_alpha[5][7] - g_alpha[5][3] ), + 0x100FF / ( 1 + g_alpha[6][7] - g_alpha[6][3] ), + 0x100FF / ( 1 + g_alpha[7][7] - g_alpha[7][3] ), + 0x100FF / ( 1 + g_alpha[8][7] - g_alpha[8][3] ), + 0x100FF / ( 1 + g_alpha[9][7] - g_alpha[9][3] ), + 0x100FF / ( 1 + g_alpha[10][7] - g_alpha[10][3] ), + 0x100FF / ( 1 + g_alpha[11][7] - g_alpha[11][3] ), + 0x100FF / ( 1 + g_alpha[12][7] - g_alpha[12][3] ), + 0x100FF / ( 1 + g_alpha[13][7] - g_alpha[13][3] ), + 0x100FF / ( 1 + g_alpha[14][7] - g_alpha[14][3] ), + 0x100FF / ( 1 + g_alpha[15][7] - g_alpha[15][3] ), +}; + +#ifdef __SSE4_1__ +const __m128i g_table_SIMD[2] = +{ + _mm_setr_epi16( 2, 5, 9, 13, 18, 24, 33, 47), + _mm_setr_epi16( 8, 17, 29, 42, 60, 80, 106, 183) +}; +const __m128i g_table128_SIMD[2] = +{ + _mm_setr_epi16( 2*128, 5*128, 9*128, 13*128, 18*128, 24*128, 33*128, 47*128), + _mm_setr_epi16( 8*128, 17*128, 29*128, 42*128, 60*128, 80*128, 106*128, 183*128) +}; +const __m128i g_table256_SIMD[4] = +{ + _mm_setr_epi32( 2*256, 5*256, 9*256, 13*256), + _mm_setr_epi32( 8*256, 17*256, 29*256, 42*256), + _mm_setr_epi32( 18*256, 24*256, 33*256, 47*256), + _mm_setr_epi32( 60*256, 80*256, 106*256, 183*256) +}; + +const __m128i g_alpha_SIMD[16] = { + _mm_setr_epi16( g_alpha[ 0][0], g_alpha[ 0][1], g_alpha[ 0][2], g_alpha[ 0][3], g_alpha[ 0][4], g_alpha[ 0][5], g_alpha[ 0][6], g_alpha[ 0][7] ), + _mm_setr_epi16( g_alpha[ 1][0], g_alpha[ 1][1], g_alpha[ 1][2], g_alpha[ 1][3], g_alpha[ 1][4], g_alpha[ 1][5], g_alpha[ 1][6], g_alpha[ 1][7] ), + _mm_setr_epi16( g_alpha[ 2][0], g_alpha[ 2][1], g_alpha[ 2][2], g_alpha[ 2][3], g_alpha[ 2][4], g_alpha[ 2][5], g_alpha[ 2][6], g_alpha[ 2][7] ), + _mm_setr_epi16( g_alpha[ 3][0], g_alpha[ 3][1], g_alpha[ 3][2], g_alpha[ 3][3], g_alpha[ 3][4], g_alpha[ 3][5], g_alpha[ 3][6], g_alpha[ 3][7] ), + _mm_setr_epi16( g_alpha[ 4][0], g_alpha[ 4][1], g_alpha[ 4][2], g_alpha[ 4][3], g_alpha[ 4][4], g_alpha[ 4][5], g_alpha[ 4][6], g_alpha[ 4][7] ), + _mm_setr_epi16( g_alpha[ 5][0], g_alpha[ 5][1], g_alpha[ 5][2], g_alpha[ 5][3], g_alpha[ 5][4], g_alpha[ 5][5], g_alpha[ 5][6], g_alpha[ 5][7] ), + _mm_setr_epi16( g_alpha[ 6][0], g_alpha[ 6][1], g_alpha[ 6][2], g_alpha[ 6][3], g_alpha[ 6][4], g_alpha[ 6][5], g_alpha[ 6][6], g_alpha[ 6][7] ), + _mm_setr_epi16( g_alpha[ 7][0], g_alpha[ 7][1], g_alpha[ 7][2], g_alpha[ 7][3], g_alpha[ 7][4], g_alpha[ 7][5], g_alpha[ 7][6], g_alpha[ 7][7] ), + _mm_setr_epi16( g_alpha[ 8][0], g_alpha[ 8][1], g_alpha[ 8][2], g_alpha[ 8][3], g_alpha[ 8][4], g_alpha[ 8][5], g_alpha[ 8][6], g_alpha[ 8][7] ), + _mm_setr_epi16( g_alpha[ 9][0], g_alpha[ 9][1], g_alpha[ 9][2], g_alpha[ 9][3], g_alpha[ 9][4], g_alpha[ 9][5], g_alpha[ 9][6], g_alpha[ 9][7] ), + _mm_setr_epi16( g_alpha[10][0], g_alpha[10][1], g_alpha[10][2], g_alpha[10][3], g_alpha[10][4], g_alpha[10][5], g_alpha[10][6], g_alpha[10][7] ), + _mm_setr_epi16( g_alpha[11][0], g_alpha[11][1], g_alpha[11][2], g_alpha[11][3], g_alpha[11][4], g_alpha[11][5], g_alpha[11][6], g_alpha[11][7] ), + _mm_setr_epi16( g_alpha[12][0], g_alpha[12][1], g_alpha[12][2], g_alpha[12][3], g_alpha[12][4], g_alpha[12][5], g_alpha[12][6], g_alpha[12][7] ), + _mm_setr_epi16( g_alpha[13][0], g_alpha[13][1], g_alpha[13][2], g_alpha[13][3], g_alpha[13][4], g_alpha[13][5], g_alpha[13][6], g_alpha[13][7] ), + _mm_setr_epi16( g_alpha[14][0], g_alpha[14][1], g_alpha[14][2], g_alpha[14][3], g_alpha[14][4], g_alpha[14][5], g_alpha[14][6], g_alpha[14][7] ), + _mm_setr_epi16( g_alpha[15][0], g_alpha[15][1], g_alpha[15][2], g_alpha[15][3], g_alpha[15][4], g_alpha[15][5], g_alpha[15][6], g_alpha[15][7] ), +}; + +const __m128i g_alphaRange_SIMD = _mm_setr_epi16( + g_alphaRange[0], + g_alphaRange[1], + g_alphaRange[4], + g_alphaRange[5], + g_alphaRange[8], + g_alphaRange[14], + 0, + 0 ); +#endif + +#ifdef __AVX2__ +const __m256i g_alpha_AVX[8] = { + _mm256_setr_epi16( g_alpha[ 0][0], g_alpha[ 1][0], g_alpha[ 2][0], g_alpha[ 3][0], g_alpha[ 4][0], g_alpha[ 5][0], g_alpha[ 6][0], g_alpha[ 7][0], g_alpha[ 8][0], g_alpha[ 9][0], g_alpha[10][0], g_alpha[11][0], g_alpha[12][0], g_alpha[13][0], g_alpha[14][0], g_alpha[15][0] ), + _mm256_setr_epi16( g_alpha[ 0][1], g_alpha[ 1][1], g_alpha[ 2][1], g_alpha[ 3][1], g_alpha[ 4][1], g_alpha[ 5][1], g_alpha[ 6][1], g_alpha[ 7][1], g_alpha[ 8][1], g_alpha[ 9][1], g_alpha[10][1], g_alpha[11][1], g_alpha[12][1], g_alpha[13][1], g_alpha[14][1], g_alpha[15][1] ), + _mm256_setr_epi16( g_alpha[ 0][2], g_alpha[ 1][2], g_alpha[ 2][2], g_alpha[ 3][2], g_alpha[ 4][2], g_alpha[ 5][2], g_alpha[ 6][2], g_alpha[ 7][2], g_alpha[ 8][2], g_alpha[ 9][2], g_alpha[10][2], g_alpha[11][2], g_alpha[12][2], g_alpha[13][2], g_alpha[14][2], g_alpha[15][2] ), + _mm256_setr_epi16( g_alpha[ 0][3], g_alpha[ 1][3], g_alpha[ 2][3], g_alpha[ 3][3], g_alpha[ 4][3], g_alpha[ 5][3], g_alpha[ 6][3], g_alpha[ 7][3], g_alpha[ 8][3], g_alpha[ 9][3], g_alpha[10][3], g_alpha[11][3], g_alpha[12][3], g_alpha[13][3], g_alpha[14][3], g_alpha[15][3] ), + _mm256_setr_epi16( g_alpha[ 0][4], g_alpha[ 1][4], g_alpha[ 2][4], g_alpha[ 3][4], g_alpha[ 4][4], g_alpha[ 5][4], g_alpha[ 6][4], g_alpha[ 7][4], g_alpha[ 8][4], g_alpha[ 9][4], g_alpha[10][4], g_alpha[11][4], g_alpha[12][4], g_alpha[13][4], g_alpha[14][4], g_alpha[15][4] ), + _mm256_setr_epi16( g_alpha[ 0][5], g_alpha[ 1][5], g_alpha[ 2][5], g_alpha[ 3][5], g_alpha[ 4][5], g_alpha[ 5][5], g_alpha[ 6][5], g_alpha[ 7][5], g_alpha[ 8][5], g_alpha[ 9][5], g_alpha[10][5], g_alpha[11][5], g_alpha[12][5], g_alpha[13][5], g_alpha[14][5], g_alpha[15][5] ), + _mm256_setr_epi16( g_alpha[ 0][6], g_alpha[ 1][6], g_alpha[ 2][6], g_alpha[ 3][6], g_alpha[ 4][6], g_alpha[ 5][6], g_alpha[ 6][6], g_alpha[ 7][6], g_alpha[ 8][6], g_alpha[ 9][6], g_alpha[10][6], g_alpha[11][6], g_alpha[12][6], g_alpha[13][6], g_alpha[14][6], g_alpha[15][6] ), + _mm256_setr_epi16( g_alpha[ 0][7], g_alpha[ 1][7], g_alpha[ 2][7], g_alpha[ 3][7], g_alpha[ 4][7], g_alpha[ 5][7], g_alpha[ 6][7], g_alpha[ 7][7], g_alpha[ 8][7], g_alpha[ 9][7], g_alpha[10][7], g_alpha[11][7], g_alpha[12][7], g_alpha[13][7], g_alpha[14][7], g_alpha[15][7] ), +}; + +const __m256i g_alphaRange_AVX = _mm256_setr_epi16( + g_alphaRange[ 0], g_alphaRange[ 1], g_alphaRange[ 2], g_alphaRange[ 3], g_alphaRange[ 4], g_alphaRange[ 5], g_alphaRange[ 6], g_alphaRange[ 7], + g_alphaRange[ 8], g_alphaRange[ 9], g_alphaRange[10], g_alphaRange[11], g_alphaRange[12], g_alphaRange[13], g_alphaRange[14], g_alphaRange[15] +); +#endif + +#ifdef __ARM_NEON +const int16x8_t g_table128_NEON[2] = +{ + { 2*128, 5*128, 9*128, 13*128, 18*128, 24*128, 33*128, 47*128 }, + { 8*128, 17*128, 29*128, 42*128, 60*128, 80*128, 106*128, 183*128 } +}; + +const int32x4_t g_table256_NEON[4] = +{ + { 2*256, 5*256, 9*256, 13*256 }, + { 8*256, 17*256, 29*256, 42*256 }, + { 18*256, 24*256, 33*256, 47*256 }, + { 60*256, 80*256, 106*256, 183*256 } +}; + +const int16x8_t g_alpha_NEON[16] = +{ + { -3, -6, -9, -15, 2, 5, 8, 14 }, + { -3, -7, -10, -13, 2, 6, 9, 12 }, + { -2, -5, -8, -13, 1, 4, 7, 12 }, + { -2, -4, -6, -13, 1, 3, 5, 12 }, + { -3, -6, -8, -12, 2, 5, 7, 11 }, + { -3, -7, -9, -11, 2, 6, 8, 10 }, + { -4, -7, -8, -11, 3, 6, 7, 10 }, + { -3, -5, -8, -11, 2, 4, 7, 10 }, + { -2, -6, -8, -10, 1, 5, 7, 9 }, + { -2, -5, -8, -10, 1, 4, 7, 9 }, + { -2, -4, -8, -10, 1, 3, 7, 9 }, + { -2, -5, -7, -10, 1, 4, 6, 9 }, + { -3, -4, -7, -10, 2, 3, 6, 9 }, + { -1, -2, -3, -10, 0, 1, 2, 9 }, + { -4, -6, -8, -9, 3, 5, 7, 8 }, + { -3, -5, -7, -9, 2, 4, 6, 8 } +}; + +const int16x8_t g_alphaRange_NEON = +{ + (int16_t)g_alphaRange[0], + (int16_t)g_alphaRange[1], + (int16_t)g_alphaRange[4], + (int16_t)g_alphaRange[5], + (int16_t)g_alphaRange[8], + (int16_t)g_alphaRange[14], + 0, + 0 +}; +#endif diff --git a/lib/etcpak/etcpak/Tables.hpp b/lib/etcpak/etcpak/Tables.hpp new file mode 100644 index 00000000000..41cce61423e --- /dev/null +++ b/lib/etcpak/etcpak/Tables.hpp @@ -0,0 +1,54 @@ +#ifndef __TABLES_HPP__ +#define __TABLES_HPP__ + +#include + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#ifdef __AVX2__ +# include +#endif +#ifdef __SSE4_1__ +# include +#endif +#ifdef __ARM_NEON +# include +#endif + +extern const int32_t g_table[8][4]; +extern const int64_t g_table256[8][4]; + +extern const uint32_t g_id[4][16]; + +extern const uint32_t g_avg2[16]; + +extern const uint32_t g_flags[64]; + +extern const int32_t g_alpha[16][8]; +extern const int32_t g_alpha11Mul[16]; +extern const int32_t g_alphaRange[16]; + +#ifdef __SSE4_1__ +extern const __m128i g_table_SIMD[2]; +extern const __m128i g_table128_SIMD[2]; +extern const __m128i g_table256_SIMD[4]; + +extern const __m128i g_alpha_SIMD[16]; +extern const __m128i g_alphaRange_SIMD; +#endif + +#ifdef __AVX2__ +extern const __m256i g_alpha_AVX[8]; +extern const __m256i g_alphaRange_AVX; +#endif + +#ifdef __ARM_NEON +extern const int16x8_t g_table128_NEON[2]; +extern const int32x4_t g_table256_NEON[4]; +extern const int16x8_t g_alpha_NEON[16]; +extern const int16x8_t g_alphaRange_NEON; +#endif + +#endif diff --git a/lib/etcpak/etcpak/TaskDispatch.cpp b/lib/etcpak/etcpak/TaskDispatch.cpp new file mode 100644 index 00000000000..7287da4de22 --- /dev/null +++ b/lib/etcpak/etcpak/TaskDispatch.cpp @@ -0,0 +1,115 @@ +#include +#include + +#include "Debug.hpp" +#include "System.hpp" +#include "TaskDispatch.hpp" + +static TaskDispatch* s_instance = nullptr; + +TaskDispatch::TaskDispatch( size_t workers ) + : m_exit( false ) + , m_jobs( 0 ) +{ + assert( !s_instance ); + s_instance = this; + + assert( workers >= 1 ); + workers--; + + m_workers.reserve( workers ); + for( size_t i=0; i& f ) +{ + std::unique_lock lock( s_instance->m_queueLock ); + s_instance->m_queue.emplace_back( f ); + const auto size = s_instance->m_queue.size(); + lock.unlock(); + if( size > 1 ) + { + s_instance->m_cvWork.notify_one(); + } +} + +void TaskDispatch::Queue( std::function&& f ) +{ + std::unique_lock lock( s_instance->m_queueLock ); + s_instance->m_queue.emplace_back( std::move( f ) ); + const auto size = s_instance->m_queue.size(); + lock.unlock(); + if( size > 1 ) + { + s_instance->m_cvWork.notify_one(); + } +} + +void TaskDispatch::Sync() +{ + std::unique_lock lock( s_instance->m_queueLock ); + while( !s_instance->m_queue.empty() ) + { + auto f = s_instance->m_queue.back(); + s_instance->m_queue.pop_back(); + lock.unlock(); + f(); + lock.lock(); + } + s_instance->m_cvJobs.wait( lock, []{ return s_instance->m_jobs == 0; } ); +} + +void TaskDispatch::Worker() +{ + for(;;) + { + std::unique_lock lock( m_queueLock ); + m_cvWork.wait( lock, [this]{ return !m_queue.empty() || m_exit; } ); + if( m_exit ) return; + auto f = m_queue.back(); + m_queue.pop_back(); + m_jobs++; + lock.unlock(); + f(); + lock.lock(); + m_jobs--; + bool notify = m_jobs == 0 && m_queue.empty(); + lock.unlock(); + if( notify ) + { + m_cvJobs.notify_all(); + } + } +} diff --git a/lib/etcpak/etcpak/TaskDispatch.hpp b/lib/etcpak/etcpak/TaskDispatch.hpp new file mode 100644 index 00000000000..b513de4c0c5 --- /dev/null +++ b/lib/etcpak/etcpak/TaskDispatch.hpp @@ -0,0 +1,34 @@ +#ifndef __DARKRL__TASKDISPATCH_HPP__ +#define __DARKRL__TASKDISPATCH_HPP__ + +#include +#include +#include +#include +#include +#include + +class TaskDispatch +{ +public: + TaskDispatch( size_t workers ); + ~TaskDispatch(); + + static void Queue( const std::function& f ); + static void Queue( std::function&& f ); + + static void Sync(); + +private: + void Worker(); + + std::vector> m_queue; + std::mutex m_queueLock; + std::condition_variable m_cvWork, m_cvJobs; + std::atomic m_exit; + size_t m_jobs; + + std::vector m_workers; +}; + +#endif diff --git a/lib/etcpak/etcpak/TextureHeader.cpp b/lib/etcpak/etcpak/TextureHeader.cpp new file mode 100644 index 00000000000..bee8152192e --- /dev/null +++ b/lib/etcpak/etcpak/TextureHeader.cpp @@ -0,0 +1,129 @@ +#include "TextureHeader.hpp" +#include + +void ProcessHeader(uint8_t* data, CodecType& type, int32_t& width, int32_t& height, size_t& dataOffset){ + auto data32 = (uint32_t*)data; + if( *data32 == 0x03525650 ) + { + // PVR + switch( *(data32+2) ) + { + case 6: + type = Etc1; + break; + case 7: + type = Bc1; + break; + case 11: + type = Bc3; + break; + case 12: + type = Bc4; + break; + case 13: + type = Bc5; + break; + case 15: + type = Bc7; + break; + case 22: + type = Etc2_RGB; + break; + case 23: + type = Etc2_RGBA; + break; + case 25: + type = Etc2_R11; + break; + case 26: + type = Etc2_RG11; + break; + default: + assert( false ); + break; + } + + height = *(data32+6); + width = *(data32+7); + dataOffset = 52 + *(data32+12); + } + else if( *data32 == 0x58544BAB ) + { + // KTX + switch( *(data32+7) ) + { + case 0x9274: + type = Etc2_RGB; + break; + case 0x9278: + type = Etc2_RGBA; + break; + case 0x9270: + type = Etc2_R11; + break; + case 0x9272: + type = Etc2_RG11; + break; + default: + assert( false ); + break; + } + + width = *(data32+9); + height = *(data32+10); + dataOffset = sizeof( uint32_t ) * 17 + *(data32+15); + } + else if( *data32 == 0x20534444 ) + { + // DDS + switch( *(data32+21) ) + { + case 0x31545844: + type = Bc1; + dataOffset = 128; + break; + case 0x35545844: + type = Bc3; + dataOffset = 128; + break; + case 0x30315844: + dataOffset = 148; + // DXGI_FORMAT_BCn + switch( *(data32+32) ) + { + case 71: + case 72: + type = Bc1; + break; + case 77: + case 78: + type = Bc3; + break; + case 80: + type = Bc4; + break; + case 83: + type = Bc5; + break; + case 98: + case 99: + type = Bc7; + break; + default: + assert( false ); + break; + }; + break; + default: + assert( false ); + break; + }; + + width = *(data32+4); + height = *(data32+3); + } + else + { + assert( false ); + } +} diff --git a/lib/etcpak/etcpak/TextureHeader.hpp b/lib/etcpak/etcpak/TextureHeader.hpp new file mode 100644 index 00000000000..0deb7178faa --- /dev/null +++ b/lib/etcpak/etcpak/TextureHeader.hpp @@ -0,0 +1,24 @@ +#ifndef __TEXTUREHEADER_HPP__ +#define __TEXTUREHEADER_HPP__ + +#include "ForceInline.hpp" +#include +#include + +enum CodecType +{ + Etc1, + Etc2_RGB, + Etc2_RGBA, + Etc2_R11, + Etc2_RG11, + Bc1, + Bc3, + Bc4, + Bc5, + Bc7 +}; + +// Public interface for processing header +etcpak_no_inline void ProcessHeader(uint8_t* data, CodecType& type, int32_t& width, int32_t& height, size_t& dataOffset); +#endif \ No newline at end of file diff --git a/lib/etcpak/etcpak/Timing.cpp b/lib/etcpak/etcpak/Timing.cpp new file mode 100644 index 00000000000..2af851f9a91 --- /dev/null +++ b/lib/etcpak/etcpak/Timing.cpp @@ -0,0 +1,8 @@ +#include + +#include "Timing.hpp" + +uint64_t GetTime() +{ + return std::chrono::time_point_cast( std::chrono::high_resolution_clock::now() ).time_since_epoch().count(); +} diff --git a/lib/etcpak/etcpak/Timing.hpp b/lib/etcpak/etcpak/Timing.hpp new file mode 100644 index 00000000000..3767e20f24a --- /dev/null +++ b/lib/etcpak/etcpak/Timing.hpp @@ -0,0 +1,8 @@ +#ifndef __DARKRL__TIMING_HPP__ +#define __DARKRL__TIMING_HPP__ + +#include + +uint64_t GetTime(); + +#endif diff --git a/lib/etcpak/etcpak/Vector.hpp b/lib/etcpak/etcpak/Vector.hpp new file mode 100644 index 00000000000..3370a88aea4 --- /dev/null +++ b/lib/etcpak/etcpak/Vector.hpp @@ -0,0 +1,222 @@ +#ifndef __DARKRL__VECTOR_HPP__ +#define __DARKRL__VECTOR_HPP__ + +#include +#include +#include +#include + +#include "Math.hpp" + +template +struct Vector2 +{ + Vector2() : x( 0 ), y( 0 ) {} + Vector2( T v ) : x( v ), y( v ) {} + Vector2( T _x, T _y ) : x( _x ), y( _y ) {} + + bool operator==( const Vector2& rhs ) const { return x == rhs.x && y == rhs.y; } + bool operator!=( const Vector2& rhs ) const { return !( *this == rhs ); } + + Vector2& operator+=( const Vector2& rhs ) + { + x += rhs.x; + y += rhs.y; + return *this; + } + Vector2& operator-=( const Vector2& rhs ) + { + x -= rhs.x; + y -= rhs.y; + return *this; + } + Vector2& operator*=( const Vector2& rhs ) + { + x *= rhs.x; + y *= rhs.y; + return *this; + } + + T x, y; +}; + +template +Vector2 operator+( const Vector2& lhs, const Vector2& rhs ) +{ + return Vector2( lhs.x + rhs.x, lhs.y + rhs.y ); +} + +template +Vector2 operator-( const Vector2& lhs, const Vector2& rhs ) +{ + return Vector2( lhs.x - rhs.x, lhs.y - rhs.y ); +} + +template +Vector2 operator*( const Vector2& lhs, const float& rhs ) +{ + return Vector2( lhs.x * rhs, lhs.y * rhs ); +} + +template +Vector2 operator/( const Vector2& lhs, const T& rhs ) +{ + return Vector2( lhs.x / rhs, lhs.y / rhs ); +} + + +typedef Vector2 v2i; +typedef Vector2 v2f; + + +template +struct Vector3 +{ + Vector3() : x( 0 ), y( 0 ), z( 0 ) {} + Vector3( T v ) : x( v ), y( v ), z( v ) {} + Vector3( T _x, T _y, T _z ) : x( _x ), y( _y ), z( _z ) {} + template + Vector3( const Vector3& v ) : x( T( v.x ) ), y( T( v.y ) ), z( T( v.z ) ) {} + + T Luminance() const { return T( x * 0.3f + y * 0.59f + z * 0.11f ); } + void Clamp() + { + x = std::min( T(1), std::max( T(0), x ) ); + y = std::min( T(1), std::max( T(0), y ) ); + z = std::min( T(1), std::max( T(0), z ) ); + } + + bool operator==( const Vector3& rhs ) const { return x == rhs.x && y == rhs.y && z == rhs.z; } + bool operator!=( const Vector2& rhs ) const { return !( *this == rhs ); } + + T& operator[]( unsigned int idx ) { assert( idx < 3 ); return ((T*)this)[idx]; } + const T& operator[]( unsigned int idx ) const { assert( idx < 3 ); return ((T*)this)[idx]; } + + Vector3 operator+=( const Vector3& rhs ) + { + x += rhs.x; + y += rhs.y; + z += rhs.z; + return *this; + } + + Vector3 operator*=( const Vector3& rhs ) + { + x *= rhs.x; + y *= rhs.y; + z *= rhs.z; + return *this; + } + + Vector3 operator*=( const float& rhs ) + { + x *= rhs; + y *= rhs; + z *= rhs; + return *this; + } + + T x, y, z; + T padding; +}; + +template +Vector3 operator+( const Vector3& lhs, const Vector3& rhs ) +{ + return Vector3( lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z ); +} + +template +Vector3 operator-( const Vector3& lhs, const Vector3& rhs ) +{ + return Vector3( lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z ); +} + +template +Vector3 operator*( const Vector3& lhs, const Vector3& rhs ) +{ + return Vector3( lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z ); +} + +template +Vector3 operator*( const Vector3& lhs, const float& rhs ) +{ + return Vector3( T( lhs.x * rhs ), T( lhs.y * rhs ), T( lhs.z * rhs ) ); +} + +template +Vector3 operator/( const Vector3& lhs, const T& rhs ) +{ + return Vector3( lhs.x / rhs, lhs.y / rhs, lhs.z / rhs ); +} + +template +bool operator<( const Vector3& lhs, const Vector3& rhs ) +{ + return lhs.Luminance() < rhs.Luminance(); +} + +typedef Vector3 v3i; +typedef Vector3 v3f; +typedef Vector3 v3b; + + +static inline v3b v3f_to_v3b( const v3f& v ) +{ + return v3b( uint8_t( std::min( 1.f, v.x ) * 255 ), uint8_t( std::min( 1.f, v.y ) * 255 ), uint8_t( std::min( 1.f, v.z ) * 255 ) ); +} + +template +Vector3 Mix( const Vector3& v1, const Vector3& v2, float amount ) +{ + return v1 + ( v2 - v1 ) * amount; +} + +template<> +inline v3b Mix( const v3b& v1, const v3b& v2, float amount ) +{ + return v3b( v3f( v1 ) + ( v3f( v2 ) - v3f( v1 ) ) * amount ); +} + +template +Vector3 Desaturate( const Vector3& v ) +{ + T l = v.Luminance(); + return Vector3( l, l, l ); +} + +template +Vector3 Desaturate( const Vector3& v, float mul ) +{ + T l = T( v.Luminance() * mul ); + return Vector3( l, l, l ); +} + +template +Vector3 pow( const Vector3& base, float exponent ) +{ + return Vector3( + pow( base.x, exponent ), + pow( base.y, exponent ), + pow( base.z, exponent ) ); +} + +template +Vector3 sRGB2linear( const Vector3& v ) +{ + return Vector3( + sRGB2linear( v.x ), + sRGB2linear( v.y ), + sRGB2linear( v.z ) ); +} + +template +Vector3 linear2sRGB( const Vector3& v ) +{ + return Vector3( + linear2sRGB( v.x ), + linear2sRGB( v.y ), + linear2sRGB( v.z ) ); +} + +#endif diff --git a/lib/etcpak/etcpak/mmap.cpp b/lib/etcpak/etcpak/mmap.cpp new file mode 100644 index 00000000000..c2460ee9e4e --- /dev/null +++ b/lib/etcpak/etcpak/mmap.cpp @@ -0,0 +1,38 @@ +#include "mmap.hpp" + +#ifdef _WIN32 +# include +# include + +void* mmap( void* addr, size_t length, int prot, int flags, int fd, off_t offset ) +{ + HANDLE hnd; + void* map = nullptr; + + switch( prot ) + { + case PROT_READ: + if( hnd = CreateFileMapping( HANDLE( _get_osfhandle( fd ) ), nullptr, PAGE_READONLY, 0, DWORD( length ), nullptr ) ) + { + map = MapViewOfFile( hnd, FILE_MAP_READ, 0, 0, length ); + CloseHandle( hnd ); + } + break; + case PROT_WRITE: + if( hnd = CreateFileMapping( HANDLE( _get_osfhandle( fd ) ), nullptr, PAGE_READWRITE, 0, DWORD( length ), nullptr ) ) + { + map = MapViewOfFile( hnd, FILE_MAP_WRITE, 0, 0, length ); + CloseHandle( hnd ); + } + break; + } + + return map ? (char*)map + offset : (void*)-1; +} + +int munmap( void* addr, size_t length ) +{ + return UnmapViewOfFile( addr ) != 0 ? 0 : -1; +} + +#endif diff --git a/lib/etcpak/etcpak/mmap.hpp b/lib/etcpak/etcpak/mmap.hpp new file mode 100644 index 00000000000..e4cfe7759ca --- /dev/null +++ b/lib/etcpak/etcpak/mmap.hpp @@ -0,0 +1,19 @@ +#ifndef __MMAP_HPP__ +#define __MMAP_HPP__ + +#ifndef _WIN32 +# include +#else +# include +# include + +# define PROT_READ 1 +# define PROT_WRITE 2 +# define MAP_SHARED 0 + +void* mmap( void* addr, size_t length, int prot, int flags, int fd, off_t offset ); +int munmap( void* addr, size_t length ); + +#endif + +#endif diff --git a/lib/etcpak/etcpak/simd.py b/lib/etcpak/etcpak/simd.py new file mode 100644 index 00000000000..e87d0dfcd3d --- /dev/null +++ b/lib/etcpak/etcpak/simd.py @@ -0,0 +1,118 @@ +import lldb + +class Simd128Printer: + def __init__(self, valobj, internal_dict): + self.valobj = valobj + + def update(self): + self.v0 = self.valobj.GetChildAtIndex(0).GetValueAsUnsigned() + self.v1 = self.valobj.GetChildAtIndex(1).GetValueAsUnsigned() + + def num_children(self): + return 8 + + def get_child_index(self, name): + return int(name.lstrip('[').rstrip(']')) + + def get_child_at_index(self, index): + if index == 0: + return self.valobj.CreateValueFromExpression('u8x16', 'uint16_t x[16] = {' + str(self.v0 & 0xFF) + ',' + str((self.v0 >> 8) & 0xFF) + ',' + str((self.v0 >> 16) & 0xFF) + ',' + str((self.v0 >> 24) & 0xFF) + ',' + str((self.v0 >> 32) & 0xFF) + ',' + str((self.v0 >> 40) & 0xFF) + ',' + str((self.v0 >> 48) & 0xFF) + ',' + str(self.v0 >> 56) + ',' + str(self.v1 & 0xFF) + ',' + str((self.v1 >> 8) & 0xFF) + ',' + str((self.v1 >> 16) & 0xFF) + ',' + str((self.v1 >> 24) & 0xFF) + ',' + str((self.v1 >> 32) & 0xFF) + ',' + str((self.v1 >> 40) & 0xFF) + ',' + str((self.v1 >> 48) & 0xFF) + ',' + str(self.v1 >> 56) + '}; x') + elif index == 1: + return self.valobj.CreateValueFromExpression('i8x16', 'int16_t x[16] = {(int8_t)' + str(self.v0 & 0xFF) + ',(int8_t)' + str((self.v0 >> 8) & 0xFF) + ',(int8_t)' + str((self.v0 >> 16) & 0xFF) + ',(int8_t)' + str((self.v0 >> 24) & 0xFF) + ',(int8_t)' + str((self.v0 >> 32) & 0xFF) + ',(int8_t)' + str((self.v0 >> 40) & 0xFF) + ',(int8_t)' + str((self.v0 >> 48) & 0xFF) + ',(int8_t)' + str(self.v0 >> 56) + ',(int8_t)' + str(self.v1 & 0xFF) + ',(int8_t)' + str((self.v1 >> 8) & 0xFF) + ',(int8_t)' + str((self.v1 >> 16) & 0xFF) + ',(int8_t)' + str((self.v1 >> 24) & 0xFF) + ',(int8_t)' + str((self.v1 >> 32) & 0xFF) + ',(int8_t)' + str((self.v1 >> 40) & 0xFF) + ',(int8_t)' + str((self.v1 >> 48) & 0xFF) + ',(int8_t)' + str(self.v1 >> 56) + '}; x') + elif index == 2: + return self.valobj.CreateValueFromExpression('u16x8', 'uint16_t x[8] = {' + str(self.v0 & 0xFFFF) + ',' + str((self.v0 >> 16) & 0xFFFF) + ',' + str((self.v0 >> 32) & 0xFFFF) + ',' + str(self.v0 >> 48) + ',' + str(self.v1 & 0xFFFF) + ',' + str((self.v1 >> 16) & 0xFFFF) + ',' + str((self.v1 >> 32) & 0xFFFF) + ',' + str(self.v1 >> 48) + '}; x') + elif index == 3: + return self.valobj.CreateValueFromExpression('i16x8', 'int16_t x[8] = {(int16_t)' + str(self.v0 & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v0 >> 48) + ',(int16_t)' + str(self.v1 & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v1 >> 48) + '}; x') + elif index == 4: + return self.valobj.CreateValueFromExpression('u32x4', 'uint32_t x[4] = {' + str(self.v0 & 0xFFFFFFFF) + ',' + str(self.v0 >> 32) + ',' + str(self.v1 & 0xFFFFFFFF) + ',' + str(self.v1 >> 32) + '}; x') + elif index == 5: + return self.valobj.CreateValueFromExpression('i32x4', 'int32_t x[4] = {(int32_t)' + str(self.v0 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v0 >> 32) + ',(int32_t)' + str(self.v1 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v1 >> 32) + '}; x') + elif index == 6: + return self.valobj.CreateValueFromExpression('u64x2', 'uint64_t x[2] = {' + str(self.v0) + ',' + str(self.v1) + '}; x') + elif index == 7: + return self.valobj.CreateValueFromExpression('i64x2', 'int64_t x[2] = {(int64_t)' + str(self.v0) + ',(int64_t)' + str(self.v1) + '}; x') + else: + return None + +class Simd256Printer: + def __init__(self, valobj, internal_dict): + self.valobj = valobj + + def update(self): + self.v0 = self.valobj.GetChildAtIndex(0).GetValueAsUnsigned() + self.v1 = self.valobj.GetChildAtIndex(1).GetValueAsUnsigned() + self.v2 = self.valobj.GetChildAtIndex(2).GetValueAsUnsigned() + self.v3 = self.valobj.GetChildAtIndex(3).GetValueAsUnsigned() + + def num_children(self): + return 8 + + def get_child_index(self, name): + return int(name.lstrip('[').rstrip(']')) + + def get_child_at_index(self, index): + if index == 0: + return self.valobj.CreateValueFromExpression('u8x32', 'uint16_t x[32] = {' + str(self.v0 & 0xFF) + ',' + str((self.v0 >> 8) & 0xFF) + ',' + str((self.v0 >> 16) & 0xFF) + ',' + str((self.v0 >> 24) & 0xFF) + ',' + str((self.v0 >> 32) & 0xFF) + ',' + str((self.v0 >> 40) & 0xFF) + ',' + str((self.v0 >> 48) & 0xFF) + ',' + str(self.v0 >> 56) + ',' + str(self.v1 & 0xFF) + ',' + str((self.v1 >> 8) & 0xFF) + ',' + str((self.v1 >> 16) & 0xFF) + ',' + str((self.v1 >> 24) & 0xFF) + ',' + str((self.v1 >> 32) & 0xFF) + ',' + str((self.v1 >> 40) & 0xFF) + ',' + str((self.v1 >> 48) & 0xFF) + ',' + str(self.v1 >> 56) + ',' + str(self.v2 & 0xFF) + ',' + str((self.v2 >> 8) & 0xFF) + ',' + str((self.v2 >> 16) & 0xFF) + ',' + str((self.v2 >> 24) & 0xFF) + ',' + str((self.v2 >> 32) & 0xFF) + ',' + str((self.v2 >> 40) & 0xFF) + ',' + str((self.v2 >> 48) & 0xFF) + ',' + str(self.v2 >> 56) + ',' + str(self.v3 & 0xFF) + ',' + str((self.v3 >> 8) & 0xFF) + ',' + str((self.v3 >> 16) & 0xFF) + ',' + str((self.v3 >> 24) & 0xFF) + ',' + str((self.v3 >> 32) & 0xFF) + ',' + str((self.v3 >> 40) & 0xFF) + ',' + str((self.v3 >> 48) & 0xFF) + ',' + str(self.v3 >> 56) + '}; x') + elif index == 1: + return self.valobj.CreateValueFromExpression('i8x32', 'int16_t x[32] = {(int8_t)' + str(self.v0 & 0xFF) + ',(int8_t)' + str((self.v0 >> 8) & 0xFF) + ',(int8_t)' + str((self.v0 >> 16) & 0xFF) + ',(int8_t)' + str((self.v0 >> 24) & 0xFF) + ',(int8_t)' + str((self.v0 >> 32) & 0xFF) + ',(int8_t)' + str((self.v0 >> 40) & 0xFF) + ',(int8_t)' + str((self.v0 >> 48) & 0xFF) + ',(int8_t)' + str(self.v0 >> 56) + ',(int8_t)' + str(self.v1 & 0xFF) + ',(int8_t)' + str((self.v1 >> 8) & 0xFF) + ',(int8_t)' + str((self.v1 >> 16) & 0xFF) + ',(int8_t)' + str((self.v1 >> 24) & 0xFF) + ',(int8_t)' + str((self.v1 >> 32) & 0xFF) + ',(int8_t)' + str((self.v1 >> 40) & 0xFF) + ',(int8_t)' + str((self.v1 >> 48) & 0xFF) + ',(int8_t)' + str(self.v1 >> 56) + ',(int8_t)' + str(self.v2 & 0xFF) + ',(int8_t)' + str((self.v2 >> 8) & 0xFF) + ',(int8_t)' + str((self.v2 >> 16) & 0xFF) + ',(int8_t)' + str((self.v2 >> 24) & 0xFF) + ',(int8_t)' + str((self.v2 >> 32) & 0xFF) + ',(int8_t)' + str((self.v2 >> 40) & 0xFF) + ',(int8_t)' + str((self.v2 >> 48) & 0xFF) + ',(int8_t)' + str(self.v2 >> 56) + ',(int8_t)' + str(self.v3 & 0xFF) + ',(int8_t)' + str((self.v3 >> 8) & 0xFF) + ',(int8_t)' + str((self.v3 >> 16) & 0xFF) + ',(int8_t)' + str((self.v3 >> 24) & 0xFF) + ',(int8_t)' + str((self.v3 >> 32) & 0xFF) + ',(int8_t)' + str((self.v3 >> 40) & 0xFF) + ',(int8_t)' + str((self.v3 >> 48) & 0xFF) + ',(int8_t)' + str(self.v3 >> 56) + '}; x') + elif index == 2: + return self.valobj.CreateValueFromExpression('u16x16', 'uint16_t x[16] = {' + str(self.v0 & 0xFFFF) + ',' + str((self.v0 >> 16) & 0xFFFF) + ',' + str((self.v0 >> 32) & 0xFFFF) + ',' + str(self.v0 >> 48) + ',' + str(self.v1 & 0xFFFF) + ',' + str((self.v1 >> 16) & 0xFFFF) + ',' + str((self.v1 >> 32) & 0xFFFF) + ',' + str(self.v1 >> 48) + ',' + str(self.v2 & 0xFFFF) + ',' + str((self.v2 >> 16) & 0xFFFF) + ',' + str((self.v2 >> 32) & 0xFFFF) + ',' + str(self.v2 >> 48) + ',' + str(self.v3 & 0xFFFF) + ',' + str((self.v3 >> 16) & 0xFFFF) + ',' + str((self.v3 >> 32) & 0xFFFF) + ',' + str(self.v3 >> 48) + '}; x') + elif index == 3: + return self.valobj.CreateValueFromExpression('i16x16', 'int16_t x[16] = {(int16_t)' + str(self.v0 & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v0 >> 48) + ',(int16_t)' + str(self.v1 & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v1 >> 48) + ',(int16_t)' + str(self.v2 & 0xFFFF) + ',(int16_t)' + str((self.v2 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v2 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v2 >> 48) + ',(int16_t)' + str(self.v3 & 0xFFFF) + ',(int16_t)' + str((self.v3 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v3 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v3 >> 48) + '}; x') + elif index == 4: + return self.valobj.CreateValueFromExpression('u32x8', 'uint32_t x[8] = {' + str(self.v0 & 0xFFFFFFFF) + ',' + str(self.v0 >> 32) + ',' + str(self.v1 & 0xFFFFFFFF) + ',' + str(self.v1 >> 32) + ',' + str(self.v2 & 0xFFFFFFFF) + ',' + str(self.v2 >> 32) + ',' + str(self.v3 & 0xFFFFFFFF) + ',' + str(self.v3 >> 32) + '}; x') + elif index == 5: + return self.valobj.CreateValueFromExpression('i32x8', 'int32_t x[8] = {(int32_t)' + str(self.v0 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v0 >> 32) + ',(int32_t)' + str(self.v1 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v1 >> 32) + ',(int32_t)' + str(self.v2 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v2 >> 32) + ',(int32_t)' + str(self.v3 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v3 >> 32) + '}; x') + elif index == 6: + return self.valobj.CreateValueFromExpression('u64x4', 'uint64_t x[4] = {' + str(self.v0) + ',' + str(self.v1) + ',' + str(self.v2) + ',' + str(self.v3) + '}; x') + elif index == 7: + return self.valobj.CreateValueFromExpression('i64x4', 'int64_t x[4] = {(int64_t)' + str(self.v0) + ',(int64_t)' + str(self.v1) + ',(int64_t)' + str(self.v2) + ',(int64_t)' + str(self.v3) + '}; x') + else: + return None + +class Simd512Printer: + def __init__(self, valobj, internal_dict): + self.valobj = valobj + + def update(self): + self.v0 = self.valobj.GetChildAtIndex(0).GetValueAsUnsigned() + self.v1 = self.valobj.GetChildAtIndex(1).GetValueAsUnsigned() + self.v2 = self.valobj.GetChildAtIndex(2).GetValueAsUnsigned() + self.v3 = self.valobj.GetChildAtIndex(3).GetValueAsUnsigned() + self.v4 = self.valobj.GetChildAtIndex(4).GetValueAsUnsigned() + self.v5 = self.valobj.GetChildAtIndex(5).GetValueAsUnsigned() + self.v6 = self.valobj.GetChildAtIndex(6).GetValueAsUnsigned() + self.v7 = self.valobj.GetChildAtIndex(7).GetValueAsUnsigned() + + def num_children(self): + return 8 + + def get_child_index(self, name): + return int(name.lstrip('[').rstrip(']')) + + def get_child_at_index(self, index): + if index == 0: + return self.valobj.CreateValueFromExpression('u8x64', 'uint16_t x[64] = {' + str(self.v0 & 0xFF) + ',' + str((self.v0 >> 8) & 0xFF) + ',' + str((self.v0 >> 16) & 0xFF) + ',' + str((self.v0 >> 24) & 0xFF) + ',' + str((self.v0 >> 32) & 0xFF) + ',' + str((self.v0 >> 40) & 0xFF) + ',' + str((self.v0 >> 48) & 0xFF) + ',' + str(self.v0 >> 56) + ',' + str(self.v1 & 0xFF) + ',' + str((self.v1 >> 8) & 0xFF) + ',' + str((self.v1 >> 16) & 0xFF) + ',' + str((self.v1 >> 24) & 0xFF) + ',' + str((self.v1 >> 32) & 0xFF) + ',' + str((self.v1 >> 40) & 0xFF) + ',' + str((self.v1 >> 48) & 0xFF) + ',' + str(self.v1 >> 56) + ',' + str(self.v2 & 0xFF) + ',' + str((self.v2 >> 8) & 0xFF) + ',' + str((self.v2 >> 16) & 0xFF) + ',' + str((self.v2 >> 24) & 0xFF) + ',' + str((self.v2 >> 32) & 0xFF) + ',' + str((self.v2 >> 40) & 0xFF) + ',' + str((self.v2 >> 48) & 0xFF) + ',' + str(self.v2 >> 56) + ',' + str(self.v3 & 0xFF) + ',' + str((self.v3 >> 8) & 0xFF) + ',' + str((self.v3 >> 16) & 0xFF) + ',' + str((self.v3 >> 24) & 0xFF) + ',' + str((self.v3 >> 32) & 0xFF) + ',' + str((self.v3 >> 40) & 0xFF) + ',' + str((self.v3 >> 48) & 0xFF) + ',' + str(self.v3 >> 56) + ',' + str(self.v4 & 0xFF) + ',' + str((self.v4 >> 8) & 0xFF) + ',' + str((self.v4 >> 16) & 0xFF) + ',' + str((self.v4 >> 24) & 0xFF) + ',' + str((self.v4 >> 32) & 0xFF) + ',' + str((self.v4 >> 40) & 0xFF) + ',' + str((self.v4 >> 48) & 0xFF) + ',' + str(self.v4 >> 56) + ',' + str(self.v5 & 0xFF) + ',' + str((self.v5 >> 8) & 0xFF) + ',' + str((self.v5 >> 16) & 0xFF) + ',' + str((self.v5 >> 24) & 0xFF) + ',' + str((self.v5 >> 32) & 0xFF) + ',' + str((self.v5 >> 40) & 0xFF) + ',' + str((self.v5 >> 48) & 0xFF) + ',' + str(self.v5 >> 56) + ',' + str(self.v6 & 0xFF) + ',' + str((self.v6 >> 8) & 0xFF) + ',' + str((self.v6 >> 16) & 0xFF) + ',' + str((self.v6 >> 24) & 0xFF) + ',' + str((self.v6 >> 32) & 0xFF) + ',' + str((self.v6 >> 40) & 0xFF) + ',' + str((self.v6 >> 48) & 0xFF) + ',' + str(self.v6 >> 56) + ',' + str(self.v7 & 0xFF) + ',' + str((self.v7 >> 8) & 0xFF) + ',' + str((self.v7 >> 16) & 0xFF) + ',' + str((self.v7 >> 24) & 0xFF) + ',' + str((self.v7 >> 32) & 0xFF) + ',' + str((self.v7 >> 40) & 0xFF) + ',' + str((self.v7 >> 48) & 0xFF) + ',' + str(self.v7 >> 56) + '}; x') + elif index == 1: + return self.valobj.CreateValueFromExpression('i8x64', 'int16_t x[64] = {(int8_t)' + str(self.v0 & 0xFF) + ',(int8_t)' + str((self.v0 >> 8) & 0xFF) + ',(int8_t)' + str((self.v0 >> 16) & 0xFF) + ',(int8_t)' + str((self.v0 >> 24) & 0xFF) + ',(int8_t)' + str((self.v0 >> 32) & 0xFF) + ',(int8_t)' + str((self.v0 >> 40) & 0xFF) + ',(int8_t)' + str((self.v0 >> 48) & 0xFF) + ',(int8_t)' + str(self.v0 >> 56) + ',(int8_t)' + str(self.v1 & 0xFF) + ',(int8_t)' + str((self.v1 >> 8) & 0xFF) + ',(int8_t)' + str((self.v1 >> 16) & 0xFF) + ',(int8_t)' + str((self.v1 >> 24) & 0xFF) + ',(int8_t)' + str((self.v1 >> 32) & 0xFF) + ',(int8_t)' + str((self.v1 >> 40) & 0xFF) + ',(int8_t)' + str((self.v1 >> 48) & 0xFF) + ',(int8_t)' + str(self.v1 >> 56) + ',(int8_t)' + str(self.v2 & 0xFF) + ',(int8_t)' + str((self.v2 >> 8) & 0xFF) + ',(int8_t)' + str((self.v2 >> 16) & 0xFF) + ',(int8_t)' + str((self.v2 >> 24) & 0xFF) + ',(int8_t)' + str((self.v2 >> 32) & 0xFF) + ',(int8_t)' + str((self.v2 >> 40) & 0xFF) + ',(int8_t)' + str((self.v2 >> 48) & 0xFF) + ',(int8_t)' + str(self.v2 >> 56) + ',(int8_t)' + str(self.v3 & 0xFF) + ',(int8_t)' + str((self.v3 >> 8) & 0xFF) + ',(int8_t)' + str((self.v3 >> 16) & 0xFF) + ',(int8_t)' + str((self.v3 >> 24) & 0xFF) + ',(int8_t)' + str((self.v3 >> 32) & 0xFF) + ',(int8_t)' + str((self.v3 >> 40) & 0xFF) + ',(int8_t)' + str((self.v3 >> 48) & 0xFF) + ',(int8_t)' + str(self.v3 >> 56) + ',(int8_t)' + str(self.v4 & 0xFF) + ',(int8_t)' + str((self.v4 >> 8) & 0xFF) + ',(int8_t)' + str((self.v4 >> 16) & 0xFF) + ',(int8_t)' + str((self.v4 >> 24) & 0xFF) + ',(int8_t)' + str((self.v4 >> 32) & 0xFF) + ',(int8_t)' + str((self.v4 >> 40) & 0xFF) + ',(int8_t)' + str((self.v4 >> 48) & 0xFF) + ',(int8_t)' + str(self.v4 >> 56) + ',(int8_t)' + str(self.v5 & 0xFF) + ',(int8_t)' + str((self.v5 >> 8) & 0xFF) + ',(int8_t)' + str((self.v5 >> 16) & 0xFF) + ',(int8_t)' + str((self.v5 >> 24) & 0xFF) + ',(int8_t)' + str((self.v5 >> 32) & 0xFF) + ',(int8_t)' + str((self.v5 >> 40) & 0xFF) + ',(int8_t)' + str((self.v5 >> 48) & 0xFF) + ',(int8_t)' + str(self.v5 >> 56) + ',(int8_t)' + str(self.v6 & 0xFF) + ',(int8_t)' + str((self.v6 >> 8) & 0xFF) + ',(int8_t)' + str((self.v6 >> 16) & 0xFF) + ',(int8_t)' + str((self.v6 >> 24) & 0xFF) + ',(int8_t)' + str((self.v6 >> 32) & 0xFF) + ',(int8_t)' + str((self.v6 >> 40) & 0xFF) + ',(int8_t)' + str((self.v6 >> 48) & 0xFF) + ',(int8_t)' + str(self.v6 >> 56) + ',(int8_t)' + str(self.v7 & 0xFF) + ',(int8_t)' + str((self.v7 >> 8) & 0xFF) + ',(int8_t)' + str((self.v7 >> 16) & 0xFF) + ',(int8_t)' + str((self.v7 >> 24) & 0xFF) + ',(int8_t)' + str((self.v7 >> 32) & 0xFF) + ',(int8_t)' + str((self.v7 >> 40) & 0xFF) + ',(int8_t)' + str((self.v7 >> 48) & 0xFF) + ',(int8_t)' + str(self.v7 >> 56) + '}; x') + elif index == 2: + return self.valobj.CreateValueFromExpression('u16x32', 'uint16_t x[32] = {' + str(self.v0 & 0xFFFF) + ',' + str((self.v0 >> 16) & 0xFFFF) + ',' + str((self.v0 >> 32) & 0xFFFF) + ',' + str(self.v0 >> 48) + ',' + str(self.v1 & 0xFFFF) + ',' + str((self.v1 >> 16) & 0xFFFF) + ',' + str((self.v1 >> 32) & 0xFFFF) + ',' + str(self.v1 >> 48) + ',' + str(self.v2 & 0xFFFF) + ',' + str((self.v2 >> 16) & 0xFFFF) + ',' + str((self.v2 >> 32) & 0xFFFF) + ',' + str(self.v2 >> 48) + ',' + str(self.v3 & 0xFFFF) + ',' + str((self.v3 >> 16) & 0xFFFF) + ',' + str((self.v3 >> 32) & 0xFFFF) + ',' + str(self.v3 >> 48) + ',' + str(self.v4 & 0xFFFF) + ',' + str((self.v4 >> 16) & 0xFFFF) + ',' + str((self.v4 >> 32) & 0xFFFF) + ',' + str(self.v4 >> 48) + ',' + str(self.v5 & 0xFFFF) + ',' + str((self.v5 >> 16) & 0xFFFF) + ',' + str((self.v5 >> 32) & 0xFFFF) + ',' + str(self.v5 >> 48) + ',' + str(self.v6 & 0xFFFF) + ',' + str((self.v6 >> 16) & 0xFFFF) + ',' + str((self.v6 >> 32) & 0xFFFF) + ',' + str(self.v6 >> 48) + ',' + str(self.v7 & 0xFFFF) + ',' + str((self.v7 >> 16) & 0xFFFF) + ',' + str((self.v7 >> 32) & 0xFFFF) + ',' + str(self.v7 >> 48) + '}; x') + elif index == 3: + return self.valobj.CreateValueFromExpression('i16x32', 'int16_t x[32] = {(int16_t)' + str(self.v0 & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v0 >> 48) + ',(int16_t)' + str(self.v1 & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v1 >> 48) + ',(int16_t)' + str(self.v2 & 0xFFFF) + ',(int16_t)' + str((self.v2 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v2 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v2 >> 48) + ',(int16_t)' + str(self.v3 & 0xFFFF) + ',(int16_t)' + str((self.v3 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v3 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v3 >> 48) + ',(int16_t)' + str(self.v4 & 0xFFFF) + ',(int16_t)' + str((self.v4 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v4 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v4 >> 48) + ',(int16_t)' + str(self.v5 & 0xFFFF) + ',(int16_t)' + str((self.v5 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v5 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v5 >> 48) + ',(int16_t)' + str(self.v6 & 0xFFFF) + ',(int16_t)' + str((self.v6 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v6 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v6 >> 48) + ',(int16_t)' + str(self.v7 & 0xFFFF) + ',(int16_t)' + str((self.v7 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v7 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v7 >> 48) + '}; x') + elif index == 4: + return self.valobj.CreateValueFromExpression('u32x16', 'uint32_t x[16] = {' + str(self.v0 & 0xFFFFFFFF) + ',' + str(self.v0 >> 32) + ',' + str(self.v1 & 0xFFFFFFFF) + ',' + str(self.v1 >> 32) + ',' + str(self.v2 & 0xFFFFFFFF) + ',' + str(self.v2 >> 32) + ',' + str(self.v3 & 0xFFFFFFFF) + ',' + str(self.v3 >> 32) + ',' + str(self.v4 & 0xFFFFFFFF) + ',' + str(self.v4 >> 32) + ',' + str(self.v5 & 0xFFFFFFFF) + ',' + str(self.v5 >> 32) + ',' + str(self.v6 & 0xFFFFFFFF) + ',' + str(self.v6 >> 32) + ',' + str(self.v7 & 0xFFFFFFFF) + ',' + str(self.v7 >> 32) + '}; x') + elif index == 5: + return self.valobj.CreateValueFromExpression('i32x16', 'int32_t x[16] = {(int32_t)' + str(self.v0 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v0 >> 32) + ',(int32_t)' + str(self.v1 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v1 >> 32) + ',(int32_t)' + str(self.v2 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v2 >> 32) + ',(int32_t)' + str(self.v3 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v3 >> 32) + ',(int32_t)' + str(self.v4 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v4 >> 32) + ',(int32_t)' + str(self.v5 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v5 >> 32) + ',(int32_t)' + str(self.v6 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v6 >> 32) + ',(int32_t)' + str(self.v7 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v7 >> 32) + '}; x') + elif index == 6: + return self.valobj.CreateValueFromExpression('u64x8', 'uint64_t x[8] = {' + str(self.v0) + ',' + str(self.v1) + ',' + str(self.v2) + ',' + str(self.v3) + ',' + str(self.v4) + ',' + str(self.v5) + ',' + str(self.v6) + ',' + str(self.v7) + '}; x') + elif index == 7: + return self.valobj.CreateValueFromExpression('i64x8', 'int64_t x[8] = {(int64_t)' + str(self.v0) + ',(int64_t)' + str(self.v1) + ',(int64_t)' + str(self.v2) + ',(int64_t)' + str(self.v3) + ',(int64_t)' + str(self.v4) + ',(int64_t)' + str(self.v5) + ',(int64_t)' + str(self.v6) + ',(int64_t)' + str(self.v7) + '}; x') + else: + return None + +def __lldb_init_module(debugger, dict): + debugger.HandleCommand('type synthetic add -w simd -l simd.Simd128Printer __m128i') + debugger.HandleCommand('type synthetic add -w simd -l simd.Simd256Printer __m256i') + debugger.HandleCommand('type synthetic add -w simd -l simd.Simd512Printer __m512i') + debugger.HandleCommand('type category enable simd') + debugger.HandleCommand('type category disable VectorTypes') diff --git a/lib/opengl/gl/glad/include/glad/glad.h b/lib/opengl/gl/glad/include/glad/glad.h index 300da24fe01..fe61d37c3bb 100644 --- a/lib/opengl/gl/glad/include/glad/glad.h +++ b/lib/opengl/gl/glad/include/glad/glad.h @@ -1,12 +1,13 @@ /* - OpenGL loader generated by glad 0.1.36 on Thu Jun 11 03:03:22 2026. + OpenGL loader generated by glad 0.1.36 on Fri Aug 14 23:50:50 2026. Language/Generator: C/C++ Specification: gl APIs: gl=4.3 Profile: core Extensions: + GL_ARB_ES3_compatibility, GL_ARB_buffer_storage, GL_ARB_debug_output, GL_ARB_draw_buffers_blend, @@ -27,9 +28,9 @@ Reproducible: False Commandline: - --profile="core" --api="gl=4.3" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_buffer_storage,GL_ARB_debug_output,GL_ARB_draw_buffers_blend,GL_ARB_get_program_binary,GL_ARB_gpu_shader5,GL_ARB_shader_texture_lod,GL_ARB_shader_viewport_layer_array,GL_ARB_texture_compression_bptc,GL_ARB_texture_storage,GL_ARB_timer_query,GL_ARB_vertex_attrib_binding,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug" + --profile="core" --api="gl=4.3" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_ES3_compatibility,GL_ARB_buffer_storage,GL_ARB_debug_output,GL_ARB_draw_buffers_blend,GL_ARB_get_program_binary,GL_ARB_gpu_shader5,GL_ARB_shader_texture_lod,GL_ARB_shader_viewport_layer_array,GL_ARB_texture_compression_bptc,GL_ARB_texture_storage,GL_ARB_timer_query,GL_ARB_vertex_attrib_binding,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug" Online: - https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.3&extensions=GL_ARB_buffer_storage&extensions=GL_ARB_debug_output&extensions=GL_ARB_draw_buffers_blend&extensions=GL_ARB_get_program_binary&extensions=GL_ARB_gpu_shader5&extensions=GL_ARB_shader_texture_lod&extensions=GL_ARB_shader_viewport_layer_array&extensions=GL_ARB_texture_compression_bptc&extensions=GL_ARB_texture_storage&extensions=GL_ARB_timer_query&extensions=GL_ARB_vertex_attrib_binding&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug + https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.3&extensions=GL_ARB_ES3_compatibility&extensions=GL_ARB_buffer_storage&extensions=GL_ARB_debug_output&extensions=GL_ARB_draw_buffers_blend&extensions=GL_ARB_get_program_binary&extensions=GL_ARB_gpu_shader5&extensions=GL_ARB_shader_texture_lod&extensions=GL_ARB_shader_viewport_layer_array&extensions=GL_ARB_texture_compression_bptc&extensions=GL_ARB_texture_storage&extensions=GL_ARB_timer_query&extensions=GL_ARB_vertex_attrib_binding&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug */ @@ -3283,6 +3284,10 @@ GLAPI PFNGLGETPOINTERVPROC glad_glGetPointerv; #define GL_CONTEXT_FLAG_DEBUG_BIT_KHR 0x00000002 #define GL_STACK_OVERFLOW_KHR 0x0503 #define GL_STACK_UNDERFLOW_KHR 0x0504 +#ifndef GL_ARB_ES3_compatibility +#define GL_ARB_ES3_compatibility 1 +GLAPI int GLAD_GL_ARB_ES3_compatibility; +#endif #ifndef GL_ARB_buffer_storage #define GL_ARB_buffer_storage 1 GLAPI int GLAD_GL_ARB_buffer_storage; diff --git a/lib/opengl/gl/glad/src/glad.c b/lib/opengl/gl/glad/src/glad.c index 0986c04d66d..51e4fbba46d 100644 --- a/lib/opengl/gl/glad/src/glad.c +++ b/lib/opengl/gl/glad/src/glad.c @@ -1,12 +1,13 @@ /* - OpenGL loader generated by glad 0.1.36 on Thu Jun 11 03:03:22 2026. + OpenGL loader generated by glad 0.1.36 on Fri Aug 14 23:50:50 2026. Language/Generator: C/C++ Specification: gl APIs: gl=4.3 Profile: core Extensions: + GL_ARB_ES3_compatibility, GL_ARB_buffer_storage, GL_ARB_debug_output, GL_ARB_draw_buffers_blend, @@ -27,9 +28,9 @@ Reproducible: False Commandline: - --profile="core" --api="gl=4.3" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_buffer_storage,GL_ARB_debug_output,GL_ARB_draw_buffers_blend,GL_ARB_get_program_binary,GL_ARB_gpu_shader5,GL_ARB_shader_texture_lod,GL_ARB_shader_viewport_layer_array,GL_ARB_texture_compression_bptc,GL_ARB_texture_storage,GL_ARB_timer_query,GL_ARB_vertex_attrib_binding,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug" + --profile="core" --api="gl=4.3" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_ES3_compatibility,GL_ARB_buffer_storage,GL_ARB_debug_output,GL_ARB_draw_buffers_blend,GL_ARB_get_program_binary,GL_ARB_gpu_shader5,GL_ARB_shader_texture_lod,GL_ARB_shader_viewport_layer_array,GL_ARB_texture_compression_bptc,GL_ARB_texture_storage,GL_ARB_timer_query,GL_ARB_vertex_attrib_binding,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug" Online: - https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.3&extensions=GL_ARB_buffer_storage&extensions=GL_ARB_debug_output&extensions=GL_ARB_draw_buffers_blend&extensions=GL_ARB_get_program_binary&extensions=GL_ARB_gpu_shader5&extensions=GL_ARB_shader_texture_lod&extensions=GL_ARB_shader_viewport_layer_array&extensions=GL_ARB_texture_compression_bptc&extensions=GL_ARB_texture_storage&extensions=GL_ARB_timer_query&extensions=GL_ARB_vertex_attrib_binding&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug + https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.3&extensions=GL_ARB_ES3_compatibility&extensions=GL_ARB_buffer_storage&extensions=GL_ARB_debug_output&extensions=GL_ARB_draw_buffers_blend&extensions=GL_ARB_get_program_binary&extensions=GL_ARB_gpu_shader5&extensions=GL_ARB_shader_texture_lod&extensions=GL_ARB_shader_viewport_layer_array&extensions=GL_ARB_texture_compression_bptc&extensions=GL_ARB_texture_storage&extensions=GL_ARB_timer_query&extensions=GL_ARB_vertex_attrib_binding&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug */ #include @@ -716,6 +717,7 @@ PFNGLVIEWPORTARRAYVPROC glad_glViewportArrayv = NULL; PFNGLVIEWPORTINDEXEDFPROC glad_glViewportIndexedf = NULL; PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv = NULL; PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +int GLAD_GL_ARB_ES3_compatibility = 0; int GLAD_GL_ARB_buffer_storage = 0; int GLAD_GL_ARB_debug_output = 0; int GLAD_GL_ARB_draw_buffers_blend = 0; @@ -1438,6 +1440,7 @@ static void load_GL_KHR_debug(GLADloadproc load) { } static int find_extensionsGL(void) { if (!get_exts()) return 0; + GLAD_GL_ARB_ES3_compatibility = has_ext("GL_ARB_ES3_compatibility"); GLAD_GL_ARB_buffer_storage = has_ext("GL_ARB_buffer_storage"); GLAD_GL_ARB_debug_output = has_ext("GL_ARB_debug_output"); GLAD_GL_ARB_draw_buffers_blend = has_ext("GL_ARB_draw_buffers_blend"); From 36317d306ce237df66aea6fdd06fd9476656a218 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 15 Aug 2026 14:37:19 -0300 Subject: [PATCH 03/14] downsize all textures for etc2 transcode --- code/ddsutils/ddsutils.cpp | 25 +++++++++++++++++-------- code/ddsutils/ddsutils_etc_cache.cpp | 4 ++-- code/ddsutils/ddsutils_etc_cache.h | 2 +- 3 files changed, 20 insertions(+), 11 deletions(-) diff --git a/code/ddsutils/ddsutils.cpp b/code/ddsutils/ddsutils.cpp index 2b37d5ed60e..ca0bbbee3e4 100644 --- a/code/ddsutils/ddsutils.cpp +++ b/code/ddsutils/ddsutils.cpp @@ -4,7 +4,6 @@ #include "cfile/cfile.h" #include "graphics/2d.h" #include "osapi/osregistry.h" -#include "cmdline/cmdline.h" #ifdef USE_OPENGL_ES #include "graphics/opengl/es_compatibility.h" #endif @@ -112,9 +111,10 @@ static size_t compute_etc2_rgba_size(const DDS_HEADER &dds_header) // of textures. // // NOTE: modifies header!! -// +// ETC2: For converting to ETC2 limit all to MAX_SIZE or half-size +// // returns: number of mipmap levels to skip -static uint conversion_resize(DDS_HEADER &dds_header) +static uint conversion_resize(DDS_HEADER& dds_header, dds_conv_target target) { const size_t MAX_SIZE = 1024; uint width, height, depth, offset = 0; @@ -142,6 +142,15 @@ static uint conversion_resize(DDS_HEADER &dds_header) ++offset; } + // For ETC2 conversion: if we are not limiting by MAX_SIZE, drop a level (50% size reduction) + if ((target == dds_conv_target::etc2) && (offset == 0) && (offset < dds_header.dwMipMapCount - 1) && (width > 4) && (height > 4)) { + width >>= 1; + height >>= 1; + depth >>= 1; + + ++offset; + } + // no change needed if ( !offset ) { return offset; @@ -394,7 +403,7 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh convert = (conv_target != dds_conv_target::none); if (conv_target == dds_conv_target::etc2) { - dds_header.dwMipMapCount -= conversion_resize(dds_header); + dds_header.dwMipMapCount -= conversion_resize(dds_header, dds_conv_target::etc2); dds_header.dwMipMapCount = std::max(1U, dds_header.dwMipMapCount); ct = DDS_ETC2_RGBA8; @@ -406,7 +415,7 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh dds_header.ddspf.dwRGBBitCount = 32; // NOTE: modifies header and returns offset for mipmap count - dds_header.dwMipMapCount -= conversion_resize(dds_header); + dds_header.dwMipMapCount -= conversion_resize(dds_header, dds_conv_target::bgra); dds_header.dwMipMapCount = std::max(1U, dds_header.dwMipMapCount); ct = (is_cubemap) ? DDS_CUBEMAP_UNCOMPRESSED : DDS_UNCOMPRESSED; @@ -506,7 +515,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) // NOTE: this alters the width, height, and depth values in the header, // so we have to jump through some hoops to get the proper values - const uint mipmap_offset = conversion_resize(dds_header); + const uint mipmap_offset = conversion_resize(dds_header, dds_conv_target::etc2); const uint out_mips = orig_mips - mipmap_offset; size_t etc2_size = 0; @@ -521,7 +530,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) if (!Cmdline_no_transcode_cache) { //Build the cache MD5 hash - key = etc2_cache_make_key(cfp, dds_header.ddspf.dwFourCC, DDS_ETC2_RGBA8, 1024); + key = etc2_cache_make_key(cfp, dds_header.ddspf.dwFourCC, DDS_ETC2_RGBA8, static_cast(etc2_size)); //Try to load from a cache file if (etc2_cache_try_load(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, DDS_ETC2_RGBA8, etc2_size, data)) { @@ -624,7 +633,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) // NOTE: this alters the width, height, and depth values in the header, // so we have to jump through some hoops to get the proper values - const uint mipmap_offset = conversion_resize(dds_header); + const uint mipmap_offset = conversion_resize(dds_header, dds_conv_target::bgra); const int num_faces = (dds_header.dwCaps2 & DDSCAPS2_CUBEMAP) ? 6 : 1; const bool has_depth = (dds_header.dwFlags & DDSD_DEPTH) == DDSD_DEPTH; diff --git a/code/ddsutils/ddsutils_etc_cache.cpp b/code/ddsutils/ddsutils_etc_cache.cpp index c1cbe1640bd..d7a9811d3ac 100644 --- a/code/ddsutils/ddsutils_etc_cache.cpp +++ b/code/ddsutils/ddsutils_etc_cache.cpp @@ -22,7 +22,7 @@ static SCP_string etc2_cache_temp_filename(const SCP_string &key) return SCP_string("etc2-") + key + ".cache.tmp"; } -SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint max_size) +SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint etc2_size) { const int saved_pos = cftell(dds); @@ -47,7 +47,7 @@ SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint md5.update(reinterpret_cast(&src_len), sizeof(src_len)); md5.update(reinterpret_cast(&src_fourcc), sizeof(src_fourcc)); md5.update(reinterpret_cast(&dst_format), sizeof(dst_format)); - md5.update(reinterpret_cast(&max_size), sizeof(max_size)); + md5.update(reinterpret_cast(&etc2_size), sizeof(etc2_size)); md5.finalize(); return md5.hexdigest(); diff --git a/code/ddsutils/ddsutils_etc_cache.h b/code/ddsutils/ddsutils_etc_cache.h index e3ad4357cae..f65298c3204 100644 --- a/code/ddsutils/ddsutils_etc_cache.h +++ b/code/ddsutils/ddsutils_etc_cache.h @@ -4,7 +4,7 @@ #include "globalincs/pstypes.h" #include "cfile/cfile.h" -SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint max_size); +SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint etc2_size); bool etc2_cache_try_load(const SCP_string &key, uint expected_width, From 986523dda2d1218740840e9d6ccd2e93270ac23b Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 15 Aug 2026 14:40:42 -0300 Subject: [PATCH 04/14] fix clang tidy error --- code/ddsutils/ddsutils_etc_cache.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/code/ddsutils/ddsutils_etc_cache.cpp b/code/ddsutils/ddsutils_etc_cache.cpp index d7a9811d3ac..e0d2ad46236 100644 --- a/code/ddsutils/ddsutils_etc_cache.cpp +++ b/code/ddsutils/ddsutils_etc_cache.cpp @@ -6,9 +6,9 @@ #include #define ETC2_CACHE_VERSION_TAG "etc2-v1" -#define ETC2_CACHE_MAGIC 0x32435445u -#define ETC2_CACHE_VERSION 1u -#define ETC2_CACHE_CHKSUM_WINDOW 65536 +static constexpr uint ETC2_CACHE_MAGIC = 0x32435445u; +static constexpr uint ETC2_CACHE_VERSION = 1u; +static constexpr int ETC2_CACHE_CHKSUM_WINDOW = 65536; static const uint32_t CACHE_LOCATION_FLAGS = CF_LOCATION_ROOT_USER | CF_LOCATION_TYPE_ROOT; From 8a25d23a8ad9133079a5d72c3e5aa791b2e401b3 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 15 Aug 2026 16:25:12 -0300 Subject: [PATCH 05/14] Use LZ4 compression for transcode cache --- code/ddsutils/ddsutils_etc_cache.cpp | 56 +++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 6 deletions(-) diff --git a/code/ddsutils/ddsutils_etc_cache.cpp b/code/ddsutils/ddsutils_etc_cache.cpp index e0d2ad46236..078281fa40d 100644 --- a/code/ddsutils/ddsutils_etc_cache.cpp +++ b/code/ddsutils/ddsutils_etc_cache.cpp @@ -1,13 +1,16 @@ #include "ddsutils/ddsutils_etc_cache.h" #include "cfile/cfile.h" +#include "lz4.h" #include #include +#include #define ETC2_CACHE_VERSION_TAG "etc2-v1" static constexpr uint ETC2_CACHE_MAGIC = 0x32435445u; static constexpr uint ETC2_CACHE_VERSION = 1u; +static constexpr uint ETC2_CACHE_FLAG_LZ4 = 0x1u; static constexpr int ETC2_CACHE_CHKSUM_WINDOW = 65536; static const uint32_t CACHE_LOCATION_FLAGS = CF_LOCATION_ROOT_USER | CF_LOCATION_TYPE_ROOT; @@ -71,15 +74,18 @@ bool etc2_cache_try_load(const SCP_string &key, const uint magic = cfread_uint(fp); const uint version = cfread_uint(fp); + const uint flags = cfread_uint(fp); const uint format = cfread_uint(fp); const uint width = cfread_uint(fp); const uint height = cfread_uint(fp); const uint mips = cfread_uint(fp); const uint payload_size = cfread_uint(fp); + const uint stored_size = cfread_uint(fp); const uint payload_crc = cfread_uint(fp); const bool header_ok = (magic == ETC2_CACHE_MAGIC) && (version == ETC2_CACHE_VERSION) && + ((flags & ~ETC2_CACHE_FLAG_LZ4) == 0) && (format == (uint)expected_format) && (width == expected_width) && (height == expected_height) && @@ -91,11 +97,29 @@ bool etc2_cache_try_load(const SCP_string &key, return false; } - const int got = cfread(out_data, 1, (int)payload_size, fp); + SCP_vector stored(stored_size); + const int got = cfread(stored.data(), 1, (int)stored_size, fp); cfclose(fp); - if (got != (int)payload_size) { + if (got != (int)stored_size) { + cf_delete(name.c_str(), CF_TYPE_CACHE); + return false; + } + + bool ok = false; + + if (flags & ETC2_CACHE_FLAG_LZ4) { + const int dec = LZ4_decompress_safe(reinterpret_cast(stored.data()), + reinterpret_cast(out_data), + (int)stored_size, (int)payload_size); + ok = (dec == (int)payload_size); + } else if (stored_size == payload_size) { + memcpy(out_data, stored.data(), payload_size); + ok = true; + } + + if (!ok) { cf_delete(name.c_str(), CF_TYPE_CACHE); return false; } @@ -122,6 +146,26 @@ void etc2_cache_store(const SCP_string &key, return; } + const uint payload_crc = cf_add_chksum_long(0, const_cast(payload), payload_size); + + const int bound = LZ4_compressBound((int)payload_size); + + SCP_vector compressed(bound > 0 ? (size_t)bound : 1); + + const int csize = LZ4_compress_fast(reinterpret_cast(payload), + reinterpret_cast(compressed.data()), + (int)payload_size, bound, 1); + + uint flags = 0; + const ubyte *out_buf = payload; + size_t out_size = payload_size; + + if ((csize > 0) && ((size_t)csize < payload_size)) { + flags = ETC2_CACHE_FLAG_LZ4; + out_buf = compressed.data(); + out_size = (size_t)csize; + } + const SCP_string temp_name = etc2_cache_temp_filename(key); const SCP_string final_name = etc2_cache_filename(key); @@ -131,22 +175,22 @@ void etc2_cache_store(const SCP_string &key, return; } - const uint payload_crc = cf_add_chksum_long(0, const_cast(payload), payload_size); - cfwrite_uint(ETC2_CACHE_MAGIC, fp); cfwrite_uint(ETC2_CACHE_VERSION, fp); + cfwrite_uint(flags, fp); cfwrite_uint((uint)format, fp); cfwrite_uint(width, fp); cfwrite_uint(height, fp); cfwrite_uint(mips, fp); cfwrite_uint((uint)payload_size, fp); + cfwrite_uint((uint)out_size, fp); cfwrite_uint(payload_crc, fp); - const int written = cfwrite(payload, 1, (int)payload_size, fp); + const int written = cfwrite(out_buf, 1, (int)out_size, fp); cfclose(fp); - if (written != (int)payload_size) { + if (written != (int)out_size) { cf_delete(temp_name.c_str(), CF_TYPE_CACHE); return; } From c11747b5e12513040165f3ad9e0a560e17537bb9 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 15 Aug 2026 16:50:56 -0300 Subject: [PATCH 06/14] fix clang-tidy errors --- code/cmdline/cmdline.cpp | 2 +- code/ddsutils/ddsutils.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/code/cmdline/cmdline.cpp b/code/cmdline/cmdline.cpp index 9077541732e..5b6a0da83c3 100644 --- a/code/cmdline/cmdline.cpp +++ b/code/cmdline/cmdline.cpp @@ -471,7 +471,7 @@ cmdline_parm no_large_shaders("-no_large_shaders", NULL, AT_NONE); #ifdef WIN32 cmdline_parm fix_registry("-fix_registry", NULL, AT_NONE); #endif -cmdline_parm no_transcode_cache_arg("-no_transcode_cache", NULL, AT_NONE); +cmdline_parm no_transcode_cache_arg("-no_transcode_cache", nullptr, AT_NONE); int Cmdline_load_all_weapons = 0; int Cmdline_nomovies = 0; diff --git a/code/ddsutils/ddsutils.cpp b/code/ddsutils/ddsutils.cpp index ca0bbbee3e4..c4dd8eb0782 100644 --- a/code/ddsutils/ddsutils.cpp +++ b/code/ddsutils/ddsutils.cpp @@ -566,12 +566,12 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) break; } - ubyte* comp_data = (ubyte*)vm_malloc(size); + auto comp_data = (ubyte*)vm_malloc(size); cfread(comp_data, 1, (int)size, cfp); const uint max_w = (dds_header.dwWidth + 3) & ~3u; const uint max_h = (dds_header.dwHeight + 3) & ~3u; - ubyte* rgba = (ubyte*)vm_malloc((size_t)max_w * max_h * 4); + auto rgba = (ubyte*)vm_malloc((size_t)max_w * max_h * 4); ubyte* src = comp_data; size_t out_offset = 0; From cc03da05560f8ff1a859a41079cf7f301873cc2e Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 15 Aug 2026 19:26:42 -0300 Subject: [PATCH 07/14] add missing location flags to cf_delete() --- code/ddsutils/ddsutils_etc_cache.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/code/ddsutils/ddsutils_etc_cache.cpp b/code/ddsutils/ddsutils_etc_cache.cpp index 078281fa40d..d44d5283d2e 100644 --- a/code/ddsutils/ddsutils_etc_cache.cpp +++ b/code/ddsutils/ddsutils_etc_cache.cpp @@ -103,7 +103,7 @@ bool etc2_cache_try_load(const SCP_string &key, cfclose(fp); if (got != (int)stored_size) { - cf_delete(name.c_str(), CF_TYPE_CACHE); + cf_delete(name.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); return false; } @@ -120,14 +120,14 @@ bool etc2_cache_try_load(const SCP_string &key, } if (!ok) { - cf_delete(name.c_str(), CF_TYPE_CACHE); + cf_delete(name.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); return false; } const uint crc = cf_add_chksum_long(0, out_data, payload_size); if (crc != payload_crc) { - cf_delete(name.c_str(), CF_TYPE_CACHE); + cf_delete(name.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); return false; } @@ -191,7 +191,7 @@ void etc2_cache_store(const SCP_string &key, cfclose(fp); if (written != (int)out_size) { - cf_delete(temp_name.c_str(), CF_TYPE_CACHE); + cf_delete(temp_name.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); return; } From fc0c8dda26a56916a0348a0343a849048d638262 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 15 Aug 2026 23:48:07 -0300 Subject: [PATCH 08/14] add cache prune --- code/cfile/cfile.h | 1 + code/cfile/cfilesystem.cpp | 2 + code/ddsutils/ddsutils_etc_cache.cpp | 88 +++++++++++++++++++++++----- code/ddsutils/ddsutils_etc_cache.h | 22 +++---- code/graphics/opengl/gropengl.cpp | 4 +- code/localization/localize.cpp | 2 +- freespace2/freespace.cpp | 3 +- 7 files changed, 90 insertions(+), 32 deletions(-) diff --git a/code/cfile/cfile.h b/code/cfile/cfile.h index fea27dededa..80eb28482c3 100644 --- a/code/cfile/cfile.h +++ b/code/cfile/cfile.h @@ -33,6 +33,7 @@ struct CFILE; // extra info that can be returned when getting a file listing typedef struct { time_t write_time; + size_t size; } file_list_info; diff --git a/code/cfile/cfilesystem.cpp b/code/cfile/cfilesystem.cpp index 545ab62d105..0ba89b26bdb 100644 --- a/code/cfile/cfilesystem.cpp +++ b/code/cfile/cfilesystem.cpp @@ -1800,6 +1800,7 @@ int cf_get_file_list(SCP_vector& list, int pathtype, const char* _fi if (info) { tinfo.write_time = file.m_time; + tinfo.size = file.size; info->push_back(tinfo); } } @@ -1873,6 +1874,7 @@ int cf_get_file_list(SCP_vector& list, int pathtype, const char* _fi if (info) { tinfo.write_time = file.m_time; + tinfo.size = file.size; info->push_back(tinfo); } } diff --git a/code/ddsutils/ddsutils_etc_cache.cpp b/code/ddsutils/ddsutils_etc_cache.cpp index d44d5283d2e..8369322b983 100644 --- a/code/ddsutils/ddsutils_etc_cache.cpp +++ b/code/ddsutils/ddsutils_etc_cache.cpp @@ -1,5 +1,6 @@ #include "ddsutils/ddsutils_etc_cache.h" #include "cfile/cfile.h" +#include "options/Option.h" #include "lz4.h" #include @@ -56,13 +57,7 @@ SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint return md5.hexdigest(); } -bool etc2_cache_try_load(const SCP_string &key, - uint expected_width, - uint expected_height, - uint expected_mips, - int expected_format, - size_t expected_size, - ubyte *out_data) +bool etc2_cache_try_load(const SCP_string &key, uint expected_width, uint expected_height, uint expected_mips, int expected_format, size_t expected_size, ubyte *out_data) { const SCP_string name = etc2_cache_filename(key); @@ -134,13 +129,7 @@ bool etc2_cache_try_load(const SCP_string &key, return true; } -void etc2_cache_store(const SCP_string &key, - uint width, - uint height, - uint mips, - int format, - const ubyte *payload, - size_t payload_size) +void etc2_cache_store(const SCP_string &key, uint width, uint height, uint mips, int format, const ubyte *payload, size_t payload_size) { if (payload == nullptr || payload_size == 0) { return; @@ -197,3 +186,74 @@ void etc2_cache_store(const SCP_string &key, cf_rename(temp_name.c_str(), final_name.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); } + +auto CacheSizeLimit = options::OptionBuilder("Graphics.EtcCacheSize", + std::pair{"ETC Transcode Cache", 1933}, + std::pair{"ETC2 transcode cache size in GBs. 0 for unlimited. Relevant for mobile GPUs lacking S3TC/BC7 support.", 1934}) + .category(std::make_pair("Graphics", 1825)) + .level(options::ExpertLevel::Advanced) + .range(0.0f, 20.0f) + .default_val(3.0f) + .importance(0) + .finish(); + +void etc2_cache_prune() +{ + auto max_bytes = (size_t)(CacheSizeLimit->getValue() * 1000000000); + + // unlimited cache + if (max_bytes <= 0) + return; + + // Clear any incomplete .tmp file + SCP_vector temps; + + cf_get_file_list(temps, CF_TYPE_CACHE, "etc2-*.cache.tmp", CF_SORT_NONE, nullptr, CACHE_LOCATION_FLAGS); + + for (size_t i = 0; i < temps.size(); ++i) { + const SCP_string tname = temps[i] + ".tmp"; + cf_delete(tname.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); + } + + // Check and clear cache + SCP_vector names; + SCP_vector info; + + cf_get_file_list(names, CF_TYPE_CACHE, "etc2-*.cache", CF_SORT_NONE, &info, CACHE_LOCATION_FLAGS); + + const size_t count = names.size(); + + if (count == 0) { + return; + } + + size_t total = 0; + for (size_t i = 0; i < count; ++i) { + total += info[i].size; + } + + if (total <= max_bytes) { + return; + } + + // Free a minimum of 20%, not the entire cache. + const size_t target = (max_bytes / 5) * 4; + + SCP_vector order(count); + for (size_t i = 0; i < count; ++i) { + order[i] = i; + } + + std::sort(order.begin(), order.end(), [&info](size_t a, size_t b) { + return info[a].write_time < info[b].write_time; + }); + + for (size_t k = 0; (k < count) && (total > target); ++k) { + const size_t idx = order[k]; + const SCP_string fname = names[idx] + ".cache"; + + if (cf_delete(fname.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS)) { + total -= info[idx].size; + } + } +} \ No newline at end of file diff --git a/code/ddsutils/ddsutils_etc_cache.h b/code/ddsutils/ddsutils_etc_cache.h index f65298c3204..f632a3a3ae2 100644 --- a/code/ddsutils/ddsutils_etc_cache.h +++ b/code/ddsutils/ddsutils_etc_cache.h @@ -4,22 +4,16 @@ #include "globalincs/pstypes.h" #include "cfile/cfile.h" +// Clear the transcode cache if the total file size is over the limit +void etc2_cache_prune(); + +// Get the MD5 file hash for the dds texture SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint etc2_size); -bool etc2_cache_try_load(const SCP_string &key, - uint expected_width, - uint expected_height, - uint expected_mips, - int expected_format, - size_t expected_size, - ubyte *out_data); +// Load a transcoded texture from cache if present +bool etc2_cache_try_load(const SCP_string &key, uint expected_width, uint expected_height, uint expected_mips, int expected_format, size_t expected_size, ubyte *out_data); -void etc2_cache_store(const SCP_string &key, - uint width, - uint height, - uint mips, - int format, - const ubyte *payload, - size_t payload_size); +// Save a texture to cache for later use +void etc2_cache_store(const SCP_string &key, uint width, uint height, uint mips, int format, const ubyte *payload, size_t payload_size); #endif diff --git a/code/graphics/opengl/gropengl.cpp b/code/graphics/opengl/gropengl.cpp index 01cfdede56e..7a77d1a0a12 100644 --- a/code/graphics/opengl/gropengl.cpp +++ b/code/graphics/opengl/gropengl.cpp @@ -1614,9 +1614,9 @@ bool gr_opengl_is_capable(gr_capability capability) case gr_capability::CAPABILITY_PERSISTENT_BUFFER_MAPPING: return GLAD_GL_ARB_buffer_storage != 0; case gr_capability::CAPABILITY_BPTC: - return GLAD_GL_ARB_texture_compression_bptc != 0; + return false;// GLAD_GL_ARB_texture_compression_bptc != 0; case gr_capability::CAPABILITY_S3TC: - return GLAD_GL_EXT_texture_compression_s3tc != 0; + return false;// GLAD_GL_EXT_texture_compression_s3tc != 0; case gr_capability::CAPABILITY_ETC2: #ifdef USE_OPENGL_ES return true; diff --git a/code/localization/localize.cpp b/code/localization/localize.cpp index 17bd9d20588..f13e7f2bf8d 100644 --- a/code/localization/localize.cpp +++ b/code/localization/localize.cpp @@ -65,7 +65,7 @@ bool *Lcl_unexpected_tstring_check = nullptr; // NOTE: with map storage of XSTR strings, the indexes no longer need to be contiguous, // but internal strings should still increment XSTR_SIZE to avoid collisions. // retail XSTR_SIZE = 1570 -// #define XSTR_SIZE 1933 // This is the next available ID +// #define XSTR_SIZE 1935 // This is the next available ID // struct to allow for strings.tbl-determined x offset // offset is 0 for english, by default diff --git a/freespace2/freespace.cpp b/freespace2/freespace.cpp index c4e1e53c5dc..9a0588987e6 100644 --- a/freespace2/freespace.cpp +++ b/freespace2/freespace.cpp @@ -204,7 +204,7 @@ #include "weapon/muzzleflash.h" #include "weapon/shockwave.h" #include "weapon/weapon.h" - +#include "ddsutils/ddsutils_etc_cache.h" #include @@ -1924,6 +1924,7 @@ void game_init() lcl_init( detect_lang() ); lcl_xstr_init(); + etc2_cache_prune(); // Clear ETC transcode cache if (Is_standalone) { // force off some cmdlines if they are on From a2a0738e5c8068200d1c847aa4acd29b761c09ef Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 15 Aug 2026 23:55:11 -0300 Subject: [PATCH 09/14] correct test change --- code/graphics/opengl/gropengl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/code/graphics/opengl/gropengl.cpp b/code/graphics/opengl/gropengl.cpp index 7a77d1a0a12..01cfdede56e 100644 --- a/code/graphics/opengl/gropengl.cpp +++ b/code/graphics/opengl/gropengl.cpp @@ -1614,9 +1614,9 @@ bool gr_opengl_is_capable(gr_capability capability) case gr_capability::CAPABILITY_PERSISTENT_BUFFER_MAPPING: return GLAD_GL_ARB_buffer_storage != 0; case gr_capability::CAPABILITY_BPTC: - return false;// GLAD_GL_ARB_texture_compression_bptc != 0; + return GLAD_GL_ARB_texture_compression_bptc != 0; case gr_capability::CAPABILITY_S3TC: - return false;// GLAD_GL_EXT_texture_compression_s3tc != 0; + return GLAD_GL_EXT_texture_compression_s3tc != 0; case gr_capability::CAPABILITY_ETC2: #ifdef USE_OPENGL_ES return true; From e991a4076b03e0b5479091533ba4529d9ba4aa14 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sun, 16 Aug 2026 00:40:30 -0300 Subject: [PATCH 10/14] fix clang-tidy error --- code/ddsutils/ddsutils_etc_cache.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/code/ddsutils/ddsutils_etc_cache.cpp b/code/ddsutils/ddsutils_etc_cache.cpp index 8369322b983..e8cb5be1006 100644 --- a/code/ddsutils/ddsutils_etc_cache.cpp +++ b/code/ddsutils/ddsutils_etc_cache.cpp @@ -210,8 +210,8 @@ void etc2_cache_prune() cf_get_file_list(temps, CF_TYPE_CACHE, "etc2-*.cache.tmp", CF_SORT_NONE, nullptr, CACHE_LOCATION_FLAGS); - for (size_t i = 0; i < temps.size(); ++i) { - const SCP_string tname = temps[i] + ".tmp"; + for (const auto& temp : temps) { + const SCP_string tname = temp + ".tmp"; cf_delete(tname.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); } From 51363280243686c933c58bb3ecbad07a12d35afe Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Mon, 17 Aug 2026 10:33:39 -0300 Subject: [PATCH 11/14] cleanup --- lib/etcpak/etcpak/Bitmap.cpp | 176 ---- lib/etcpak/etcpak/Bitmap.hpp | 44 - lib/etcpak/etcpak/BitmapDownsampled.cpp | 369 ------- lib/etcpak/etcpak/BitmapDownsampled.hpp | 13 - lib/etcpak/etcpak/BlockData.cpp | 400 ------- lib/etcpak/etcpak/BlockData.hpp | 52 - lib/etcpak/etcpak/ColorSpace.cpp | 114 -- lib/etcpak/etcpak/ColorSpace.hpp | 36 - lib/etcpak/etcpak/DataProvider.cpp | 78 -- lib/etcpak/etcpak/DataProvider.hpp | 42 - lib/etcpak/etcpak/Debug.cpp | 31 - lib/etcpak/etcpak/Debug.hpp | 27 - lib/etcpak/etcpak/Decode.cpp | 1286 ----------------------- lib/etcpak/etcpak/Decode.hpp | 19 - lib/etcpak/etcpak/Error.cpp | 48 - lib/etcpak/etcpak/Error.hpp | 9 - lib/etcpak/etcpak/MipMap.hpp | 11 - lib/etcpak/etcpak/ProcessDxtc.cpp | 1120 -------------------- lib/etcpak/etcpak/ProcessDxtc.hpp | 18 - lib/etcpak/etcpak/Semaphore.hpp | 46 - lib/etcpak/etcpak/System.cpp | 68 -- lib/etcpak/etcpak/System.hpp | 15 - lib/etcpak/etcpak/TaskDispatch.cpp | 115 -- lib/etcpak/etcpak/TaskDispatch.hpp | 34 - lib/etcpak/etcpak/TextureHeader.cpp | 129 --- lib/etcpak/etcpak/TextureHeader.hpp | 24 - lib/etcpak/etcpak/Timing.cpp | 8 - lib/etcpak/etcpak/Timing.hpp | 8 - lib/etcpak/etcpak/mmap.cpp | 38 - lib/etcpak/etcpak/mmap.hpp | 19 - lib/etcpak/etcpak/simd.py | 118 --- 31 files changed, 4515 deletions(-) delete mode 100644 lib/etcpak/etcpak/Bitmap.cpp delete mode 100644 lib/etcpak/etcpak/Bitmap.hpp delete mode 100644 lib/etcpak/etcpak/BitmapDownsampled.cpp delete mode 100644 lib/etcpak/etcpak/BitmapDownsampled.hpp delete mode 100644 lib/etcpak/etcpak/BlockData.cpp delete mode 100644 lib/etcpak/etcpak/BlockData.hpp delete mode 100644 lib/etcpak/etcpak/ColorSpace.cpp delete mode 100644 lib/etcpak/etcpak/ColorSpace.hpp delete mode 100644 lib/etcpak/etcpak/DataProvider.cpp delete mode 100644 lib/etcpak/etcpak/DataProvider.hpp delete mode 100644 lib/etcpak/etcpak/Debug.cpp delete mode 100644 lib/etcpak/etcpak/Debug.hpp delete mode 100644 lib/etcpak/etcpak/Decode.cpp delete mode 100644 lib/etcpak/etcpak/Decode.hpp delete mode 100644 lib/etcpak/etcpak/Error.cpp delete mode 100644 lib/etcpak/etcpak/Error.hpp delete mode 100644 lib/etcpak/etcpak/MipMap.hpp delete mode 100644 lib/etcpak/etcpak/ProcessDxtc.cpp delete mode 100644 lib/etcpak/etcpak/ProcessDxtc.hpp delete mode 100644 lib/etcpak/etcpak/Semaphore.hpp delete mode 100644 lib/etcpak/etcpak/System.cpp delete mode 100644 lib/etcpak/etcpak/System.hpp delete mode 100644 lib/etcpak/etcpak/TaskDispatch.cpp delete mode 100644 lib/etcpak/etcpak/TaskDispatch.hpp delete mode 100644 lib/etcpak/etcpak/TextureHeader.cpp delete mode 100644 lib/etcpak/etcpak/TextureHeader.hpp delete mode 100644 lib/etcpak/etcpak/Timing.cpp delete mode 100644 lib/etcpak/etcpak/Timing.hpp delete mode 100644 lib/etcpak/etcpak/mmap.cpp delete mode 100644 lib/etcpak/etcpak/mmap.hpp delete mode 100644 lib/etcpak/etcpak/simd.py diff --git a/lib/etcpak/etcpak/Bitmap.cpp b/lib/etcpak/etcpak/Bitmap.cpp deleted file mode 100644 index 0260e781eb1..00000000000 --- a/lib/etcpak/etcpak/Bitmap.cpp +++ /dev/null @@ -1,176 +0,0 @@ -#include -#include -#include -#include - -#include - -#include "Bitmap.hpp" -#include "Debug.hpp" - -Bitmap::Bitmap( const char* fn, unsigned int lines, bool bgr ) - : m_block( nullptr ) - , m_lines( lines ) - , m_alpha( true ) - , m_sema( 0 ) -{ - FILE* f = fopen( fn, "rb" ); - assert( f ); - - unsigned int sig_read = 0; - int bit_depth, color_type, interlace_type; - - png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL ); - png_infop info_ptr = png_create_info_struct( png_ptr ); - setjmp( png_jmpbuf( png_ptr ) ); - - png_init_io( png_ptr, f ); - png_set_sig_bytes( png_ptr, sig_read ); - - png_uint_32 w, h; - - png_read_info( png_ptr, info_ptr ); - png_get_IHDR( png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, &interlace_type, NULL, NULL ); - - m_size = v2i( w, h ); - - png_set_strip_16( png_ptr ); - if( color_type == PNG_COLOR_TYPE_PALETTE ) - { - png_set_palette_to_rgb( png_ptr ); - } - else if( color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8 ) - { - png_set_expand_gray_1_2_4_to_8( png_ptr ); - } - if( png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS ) ) - { - png_set_tRNS_to_alpha( png_ptr ); - } - if( color_type == PNG_COLOR_TYPE_GRAY_ALPHA ) - { - png_set_gray_to_rgb(png_ptr); - } - if( bgr ) - { - png_set_bgr(png_ptr); - } - - switch( color_type ) - { - case PNG_COLOR_TYPE_PALETTE: - if( !png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS ) ) - { - png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER ); - m_alpha = false; - } - break; - case PNG_COLOR_TYPE_GRAY_ALPHA: - png_set_gray_to_rgb( png_ptr ); - break; - case PNG_COLOR_TYPE_RGB: - png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER ); - m_alpha = false; - break; - default: - break; - } - - DBGPRINT( "Bitmap " << fn << " " << w << "x" << h ); - - assert( w % 4 == 0 ); - assert( h % 4 == 0 ); - - m_block = m_data = new uint32_t[w*h]; - m_linesLeft = h / 4; - - m_load = std::async( std::launch::async, [this, f, png_ptr, info_ptr]() mutable - { - auto ptr = m_data; - unsigned int lines = 0; - for( int i=0; i= m_lines ) - { - lines = 0; - m_sema.unlock(); - } - } - - if( lines != 0 ) - { - m_sema.unlock(); - } - - png_read_end( png_ptr, info_ptr ); - png_destroy_read_struct( &png_ptr, &info_ptr, NULL ); - fclose( f ); - } ); -} - -Bitmap::Bitmap( const v2i& size ) - : m_data( new uint32_t[size.x*size.y] ) - , m_block( nullptr ) - , m_lines( 1 ) - , m_linesLeft( size.y / 4 ) - , m_size( size ) - , m_sema( 0 ) -{ -} - -Bitmap::Bitmap( const Bitmap& src, unsigned int lines ) - : m_lines( lines ) - , m_alpha( src.Alpha() ) - , m_sema( 0 ) -{ -} - -Bitmap::~Bitmap() -{ - delete[] m_data; -} - -void Bitmap::Write( const char* fn ) -{ - FILE* f = fopen( fn, "wb" ); - assert( f ); - - png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL ); - png_infop info_ptr = png_create_info_struct( png_ptr ); - setjmp( png_jmpbuf( png_ptr ) ); - png_init_io( png_ptr, f ); - - png_set_IHDR( png_ptr, info_ptr, m_size.x, m_size.y, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE ); - - png_write_info( png_ptr, info_ptr ); - - uint32_t* ptr = m_data; - for( int i=0; i lock( m_lock ); - lines = std::min( m_lines, m_linesLeft ); - auto ret = m_block; - m_sema.lock(); - m_block += m_size.x * 4 * lines; - m_linesLeft -= lines; - done = m_linesLeft == 0; - return ret; -} diff --git a/lib/etcpak/etcpak/Bitmap.hpp b/lib/etcpak/etcpak/Bitmap.hpp deleted file mode 100644 index f197e7d2963..00000000000 --- a/lib/etcpak/etcpak/Bitmap.hpp +++ /dev/null @@ -1,44 +0,0 @@ -#ifndef __DARKRL__BITMAP_HPP__ -#define __DARKRL__BITMAP_HPP__ - -#include -#include -#include -#include - -#include "Semaphore.hpp" -#include "Vector.hpp" - -class Bitmap -{ -public: - Bitmap( const char* fn, unsigned int lines, bool bgr ); - Bitmap( const v2i& size ); - virtual ~Bitmap(); - - void Write( const char* fn ); - - uint32_t* Data() { if( m_load.valid() ) m_load.wait(); return m_data; } - const uint32_t* Data() const { if( m_load.valid() ) m_load.wait(); return m_data; } - const v2i& Size() const { return m_size; } - bool Alpha() const { return m_alpha; } - - const uint32_t* NextBlock( unsigned int& lines, bool& done ); - -protected: - Bitmap( const Bitmap& src, unsigned int lines ); - - uint32_t* m_data; - uint32_t* m_block; - unsigned int m_lines; - unsigned int m_linesLeft; - v2i m_size; - bool m_alpha; - Semaphore m_sema; - std::mutex m_lock; - std::future m_load; -}; - -typedef std::shared_ptr BitmapPtr; - -#endif diff --git a/lib/etcpak/etcpak/BitmapDownsampled.cpp b/lib/etcpak/etcpak/BitmapDownsampled.cpp deleted file mode 100644 index 4fb06cabc93..00000000000 --- a/lib/etcpak/etcpak/BitmapDownsampled.cpp +++ /dev/null @@ -1,369 +0,0 @@ -#include -#include - -#include "BitmapDownsampled.hpp" -#include "Debug.hpp" - -#if defined __AVX__ && !defined __SSE4_1__ -# define __SSE4_1__ -#endif - -#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER -# ifdef _MSC_VER -# include -# else -# include -# endif -#endif - - -static const float SrgbToLinear[256] = { - 0.00000000f, 0.00030353f, 0.00060705f, 0.00091058f, 0.00121411f, 0.00151763f, 0.00182116f, 0.00212469f, 0.00242822f, 0.00273174f, 0.00303527f, 0.00334654f, 0.00367651f, 0.00402472f, 0.00439144f, 0.00477695f, - 0.00518152f, 0.00560539f, 0.00604883f, 0.00651209f, 0.00699541f, 0.00749903f, 0.00802319f, 0.00856813f, 0.00913406f, 0.00972122f, 0.01032982f, 0.01096010f, 0.01161225f, 0.01228649f, 0.01298303f, 0.01370208f, - 0.01444385f, 0.01520852f, 0.01599630f, 0.01680738f, 0.01764196f, 0.01850022f, 0.01938237f, 0.02028857f, 0.02121901f, 0.02217389f, 0.02315337f, 0.02415763f, 0.02518686f, 0.02624123f, 0.02732090f, 0.02842604f, - 0.02955684f, 0.03071345f, 0.03189604f, 0.03310477f, 0.03433981f, 0.03560132f, 0.03688945f, 0.03820437f, 0.03954624f, 0.04091520f, 0.04231142f, 0.04373503f, 0.04518621f, 0.04666509f, 0.04817183f, 0.04970657f, - 0.05126947f, 0.05286066f, 0.05448029f, 0.05612850f, 0.05780544f, 0.05951125f, 0.06124608f, 0.06301004f, 0.06480329f, 0.06662596f, 0.06847819f, 0.07036012f, 0.07227187f, 0.07421359f, 0.07618540f, 0.07818744f, - 0.08021984f, 0.08228272f, 0.08437622f, 0.08650047f, 0.08865561f, 0.09084174f, 0.09305899f, 0.09530749f, 0.09758737f, 0.09989875f, 0.10224175f, 0.10461651f, 0.10702312f, 0.10946173f, 0.11193245f, 0.11443539f, - 0.11697068f, 0.11953844f, 0.12213881f, 0.12477185f, 0.12743771f, 0.13013650f, 0.13286835f, 0.13563335f, 0.13843164f, 0.14126332f, 0.14412849f, 0.14702728f, 0.14995980f, 0.15292618f, 0.15592648f, 0.15896088f, - 0.16202942f, 0.16513222f, 0.16826941f, 0.17144111f, 0.17464741f, 0.17788842f, 0.18116425f, 0.18447499f, 0.18782078f, 0.19120169f, 0.19461782f, 0.19806932f, 0.20155625f, 0.20507872f, 0.20863685f, 0.21223074f, - 0.21586055f, 0.21952623f, 0.22322799f, 0.22696590f, 0.23074009f, 0.23455067f, 0.23839766f, 0.24228121f, 0.24620141f, 0.25015837f, 0.25415218f, 0.25818294f, 0.26225075f, 0.26635569f, 0.27049786f, 0.27467740f, - 0.27889434f, 0.28314883f, 0.28744090f, 0.29177073f, 0.29613835f, 0.30054384f, 0.30498737f, 0.30946898f, 0.31398878f, 0.31854683f, 0.32314327f, 0.32777816f, 0.33245158f, 0.33716366f, 0.34191447f, 0.34670410f, - 0.35153273f, 0.35640025f, 0.36130691f, 0.36625272f, 0.37123778f, 0.37626222f, 0.38132611f, 0.38642955f, 0.39157256f, 0.39675534f, 0.40197787f, 0.40724030f, 0.41254270f, 0.41788515f, 0.42326775f, 0.42869058f, - 0.43415371f, 0.43965724f, 0.44520128f, 0.45078585f, 0.45641109f, 0.46207705f, 0.46778387f, 0.47353154f, 0.47932023f, 0.48515001f, 0.49102089f, 0.49693304f, 0.50288659f, 0.50888145f, 0.51491779f, 0.52099568f, - 0.52711529f, 0.53327656f, 0.53947961f, 0.54572457f, 0.55201155f, 0.55834049f, 0.56471163f, 0.57112491f, 0.57758057f, 0.58407855f, 0.59061897f, 0.59720188f, 0.60382742f, 0.61049569f, 0.61720663f, 0.62396049f, - 0.63075721f, 0.63759696f, 0.64447975f, 0.65140569f, 0.65837491f, 0.66538733f, 0.67244321f, 0.67954254f, 0.68668550f, 0.69387192f, 0.70110208f, 0.70837593f, 0.71569365f, 0.72305530f, 0.73046088f, 0.73791057f, - 0.74540436f, 0.75294232f, 0.76052463f, 0.76815128f, 0.77582234f, 0.78353792f, 0.79129803f, 0.79910284f, 0.80695236f, 0.81484669f, 0.82278585f, 0.83076996f, 0.83879912f, 0.84687334f, 0.85499269f, 0.86315727f, - 0.87136722f, 0.87962234f, 0.88792318f, 0.89626944f, 0.90466136f, 0.91309869f, 0.92158204f, 0.93011087f, 0.93868589f, 0.94730657f, 0.95597351f, 0.96468627f, 0.97344548f, 0.98225057f, 0.99110222f, 1.00000000f, -}; - - -static inline float rsqrt( float v ) -{ - return 1.f / sqrt( v ); -} - -static inline uint32_t LinearToSrgb( float v ) -{ - const float a = 0.00279491f; - const float b = 1.15907984f; - const float c = 0.15746343f; // b * rsqrt( 1 + a ) - 1; - - return uint32_t( 255 * ( ( b * rsqrt( v + a ) - c ) * v ) ); -} - - -BitmapDownsampled::BitmapDownsampled( const Bitmap& bmp, unsigned int lines, bool linearize ) - : Bitmap( bmp, lines ) -{ - m_size.x = std::max( 1, bmp.Size().x / 2 ); - m_size.y = std::max( 1, bmp.Size().y / 2 ); - - int w = std::max( m_size.x, 4 ); - int h = std::max( m_size.y, 4 ); - - DBGPRINT( "Subbitmap " << m_size.x << "x" << m_size.y ); - - m_block = m_data = new uint32_t[w*h]; - - if( m_size.x < w || m_size.y < h ) - { - memset( m_data, 0, w*h*sizeof( uint32_t ) ); - m_linesLeft = h / 4; - unsigned int lines = 0; - for( int i=0; i m_lines ) - { - lines = 0; - m_sema.unlock(); - } - } - } - if( lines != 0 ) - { - m_sema.unlock(); - } - } - else - { - m_linesLeft = h / 4; - if( linearize ) - { - m_load = std::async( std::launch::async, [this, &bmp, w, h]() mutable - { - auto ptr = m_data; - auto src1 = bmp.Data(); - auto src2 = src1 + bmp.Size().x; - unsigned int lines = 0; - for( int i=0; i 2 ) - { - k -= 2; - - __m128i p0 = _mm_loadu_si128( (__m128i*)src1 ); - __m128i p1 = _mm_loadu_si128( (__m128i*)src2 ); - src1 += 4; - src2 += 4; - - __m256i pxa = _mm256_cvtepu8_epi16( p0 ); - __m256i pxb = _mm256_cvtepu8_epi16( p1 ); - __m256i px0 = _mm256_unpacklo_epi16( pxa, _mm256_setzero_si256() ); - __m256i px1 = _mm256_unpackhi_epi16( pxa, _mm256_setzero_si256() ); - __m256i px2 = _mm256_unpacklo_epi16( pxb, _mm256_setzero_si256() ); - __m256i px3 = _mm256_unpackhi_epi16( pxb, _mm256_setzero_si256() ); - - __m256 f0 = _mm256_cvtepi32_ps( px0 ); - __m256 f1 = _mm256_cvtepi32_ps( px1 ); - __m256 f2 = _mm256_cvtepi32_ps( px2 ); - __m256 f3 = _mm256_cvtepi32_ps( px3 ); - - __m256 m0 = _mm256_mul_ps( f0, _mm256_set1_ps( 0.003921568f ) ); - __m256 m1 = _mm256_mul_ps( f1, _mm256_set1_ps( 0.003921568f ) ); - __m256 m2 = _mm256_mul_ps( f2, _mm256_set1_ps( 0.003921568f ) ); - __m256 m3 = _mm256_mul_ps( f3, _mm256_set1_ps( 0.003921568f ) ); - - __m256 l00 = _mm256_fmadd_ps( m0, _mm256_set1_ps( 0.305306011f ), _mm256_set1_ps( 0.682171111f ) ); - __m256 l01 = _mm256_fmadd_ps( m1, _mm256_set1_ps( 0.305306011f ), _mm256_set1_ps( 0.682171111f ) ); - __m256 l02 = _mm256_fmadd_ps( m2, _mm256_set1_ps( 0.305306011f ), _mm256_set1_ps( 0.682171111f ) ); - __m256 l03 = _mm256_fmadd_ps( m3, _mm256_set1_ps( 0.305306011f ), _mm256_set1_ps( 0.682171111f ) ); - - __m256 l10 = _mm256_fmadd_ps( m0, l00, _mm256_set1_ps( 0.012522878f ) ); - __m256 l11 = _mm256_fmadd_ps( m1, l01, _mm256_set1_ps( 0.012522878f ) ); - __m256 l12 = _mm256_fmadd_ps( m2, l02, _mm256_set1_ps( 0.012522878f ) ); - __m256 l13 = _mm256_fmadd_ps( m3, l03, _mm256_set1_ps( 0.012522878f ) ); - - __m256 l20 = _mm256_mul_ps( m0, l10 ); - __m256 l21 = _mm256_mul_ps( m1, l11 ); - __m256 l22 = _mm256_mul_ps( m2, l12 ); - __m256 l23 = _mm256_mul_ps( m3, l13 ); - - __m256 s0 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( l20 ), _mm256_castps_si256( m0 ), 0x88 ) ); - __m256 s1 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( l21 ), _mm256_castps_si256( m1 ), 0x88 ) ); - __m256 s2 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( l22 ), _mm256_castps_si256( m2 ), 0x88 ) ); - __m256 s3 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( l23 ), _mm256_castps_si256( m3 ), 0x88 ) ); - - __m256 a0 = _mm256_add_ps( s0, s1 ); - __m256 a1 = _mm256_add_ps( s2, s3 ); - __m256 a2 = _mm256_add_ps( a0, a1 ); - - __m256 v = _mm256_mul_ps( a2, _mm256_set1_ps( 0.25f ) ); - __m256 r0 = _mm256_add_ps( v, _mm256_set1_ps( 0.00279491f ) ); - __m256 r1 = _mm256_rsqrt_ps( r0 ); - __m256 r2 = _mm256_fmadd_ps( r1, _mm256_set1_ps( 1.15907984f ), _mm256_set1_ps( -0.15746343f ) ); - __m256 r3 = _mm256_mul_ps( r2, v ); - - __m256 b0 = _mm256_castsi256_ps( _mm256_blend_epi32( _mm256_castps_si256( r3 ), _mm256_castps_si256( v ), 0x88 ) ); - __m256 b1 = _mm256_mul_ps( b0, _mm256_set1_ps( 255 ) ); - __m256i b2 = _mm256_cvtps_epi32( b1 ); - __m256i b3 = _mm256_packus_epi32( b2, b2 ); - __m256i b4 = _mm256_packus_epi16( b3, b3 ); - - *ptr++ = _mm_cvtsi128_si32( _mm256_castsi256_si128( b4 ) ); - *ptr++ = _mm_cvtsi128_si32( _mm256_extracti128_si256( b4, 1 ) ); - } -#endif - while( k-- ) - { -#ifdef __SSE4_1__ - uint32_t px0 = *src1; - uint32_t px1 = *(src1+1); - uint32_t px2 = *src2; - uint32_t px3 = *(src2+1); - - float p0[4]; - float p1[4]; - float p2[4]; - float p3[4]; - - p0[0] = SrgbToLinear[px0 & 0x000000FF]; - p0[1] = SrgbToLinear[( px0 & 0x0000FF00 ) >> 8]; - p0[2] = SrgbToLinear[( px0 & 0x00FF0000 ) >> 16]; - p0[3] = px0 >> 24; - - p1[0] = SrgbToLinear[px1 & 0x000000FF]; - p1[1] = SrgbToLinear[( px1 & 0x0000FF00 ) >> 8]; - p1[2] = SrgbToLinear[( px1 & 0x00FF0000 ) >> 16]; - p1[3] = px1 >> 24; - - p2[0] = SrgbToLinear[px2 & 0x000000FF]; - p2[1] = SrgbToLinear[( px2 & 0x0000FF00 ) >> 8]; - p2[2] = SrgbToLinear[( px2 & 0x00FF0000 ) >> 16]; - p2[3] = px2 >> 24; - - p3[0] = SrgbToLinear[px3 & 0x000000FF]; - p3[1] = SrgbToLinear[( px3 & 0x0000FF00 ) >> 8]; - p3[2] = SrgbToLinear[( px3 & 0x00FF0000 ) >> 16]; - p3[3] = px3 >> 24; - - __m128 s0 = _mm_loadu_ps( p0 ); - __m128 s1 = _mm_loadu_ps( p1 ); - __m128 s2 = _mm_loadu_ps( p2 ); - __m128 s3 = _mm_loadu_ps( p3 ); - - __m128 a0 = _mm_add_ps( s0, s1 ); - __m128 a1 = _mm_add_ps( s2, s3 ); - __m128 a2 = _mm_add_ps( a0, a1 ); - - __m128 v = _mm_mul_ps( a2, _mm_set_ps1( 0.25f ) ); - __m128 r0 = _mm_add_ps( v, _mm_set_ps1( 0.00279491f ) ); - __m128 r1 = _mm_rsqrt_ps( r0 ); - __m128 r2 = _mm_mul_ps( r1, _mm_set_ps1( 1.15907984f ) ); - __m128 r3 = _mm_sub_ps( r2, _mm_set_ps1( 0.15746343f ) ); - __m128 r4 = _mm_mul_ps( r3, v ); - - __m128 b0 = _mm_blend_ps( r4, v, 8 ); - __m128 b1 = _mm_mul_ps( b0, _mm_set_ps1( 255 ) ); - __m128i b2 = _mm_cvtps_epi32( b1 ); - __m128i b3 = _mm_packus_epi32( b2, b2 ); - __m128i b4 = _mm_packus_epi16( b3, b3 ); - - *ptr++ = _mm_cvtsi128_si32( b4 ); - src1 += 2; - src2 += 2; -#else - uint32_t px0 = *src1; - uint32_t px1 = *(src1+1); - uint32_t px2 = *src2; - uint32_t px3 = *(src2+1); - - float r0 = SrgbToLinear[px0 & 0x000000FF]; - float r1 = SrgbToLinear[px1 & 0x000000FF]; - float r2 = SrgbToLinear[px2 & 0x000000FF]; - float r3 = SrgbToLinear[px3 & 0x000000FF]; - - float g0 = SrgbToLinear[( px0 & 0x0000FF00 ) >> 8]; - float g1 = SrgbToLinear[( px1 & 0x0000FF00 ) >> 8]; - float g2 = SrgbToLinear[( px2 & 0x0000FF00 ) >> 8]; - float g3 = SrgbToLinear[( px3 & 0x0000FF00 ) >> 8]; - - float b0 = SrgbToLinear[( px0 & 0x00FF0000 ) >> 16]; - float b1 = SrgbToLinear[( px1 & 0x00FF0000 ) >> 16]; - float b2 = SrgbToLinear[( px2 & 0x00FF0000 ) >> 16]; - float b3 = SrgbToLinear[( px3 & 0x00FF0000 ) >> 16]; - - uint32_t r = LinearToSrgb( ( r0+r1+r2+r3 ) / 4 ); - uint32_t g = LinearToSrgb( ( g0+g1+g2+g3 ) / 4 ) << 8; - uint32_t b = LinearToSrgb( ( b0+b1+b2+b3 ) / 4 ) << 16; - uint32_t a = ( ( ( ( ( *src1 & 0xFF000000 ) >> 8 ) + ( ( *(src1+1) & 0xFF000000 ) >> 8 ) + ( ( *src2 & 0xFF000000 ) >> 8 ) + ( ( *(src2+1) & 0xFF000000 ) >> 8 ) ) / 4 ) & 0x00FF0000 ) << 8; - - *ptr++ = r | g | b | a; - src1 += 2; - src2 += 2; -#endif - } - src1 += m_size.x * 2; - src2 += m_size.x * 2; - } - lines++; - if( lines >= m_lines ) - { - lines = 0; - m_sema.unlock(); - } - } - - if( lines != 0 ) - { - m_sema.unlock(); - } - } ); - } - else - { - m_load = std::async( std::launch::async, [this, &bmp, w, h]() mutable - { - auto ptr = m_data; - auto src1 = bmp.Data(); - auto src2 = src1 + bmp.Size().x; - unsigned int lines = 0; - for( int i=0; i 2 ) - { - k -= 2; - - __m128i p0 = _mm_loadu_si128( (__m128i*)src1 ); - __m128i p1 = _mm_loadu_si128( (__m128i*)src2 ); - src1 += 4; - src2 += 4; - - __m256i px0 = _mm256_cvtepu8_epi16( p0 ); - __m256i px1 = _mm256_cvtepu8_epi16( p1 ); - - __m256i s0 = _mm256_add_epi16( px0, px1 ); - __m256i s1 = _mm256_shuffle_epi32( s0, _MM_SHUFFLE( 1, 0, 3, 2 ) ); - __m256i s2 = _mm256_add_epi16( s0, s1 ); - - __m256i r0 = _mm256_srli_epi16( s2, 2 ); - __m256i r1 = _mm256_packus_epi16( r0, r0 ); - - *ptr++ = _mm_cvtsi128_si32( _mm256_castsi256_si128( r1 ) ); - *ptr++ = _mm_cvtsi128_si32( _mm256_extracti128_si256( r1, 1 ) ); - } -#endif - while( k-- ) - { -#ifdef __SSE4_1__ - uint64_t p0, p1; - memcpy( &p0, src1, 8 ); - memcpy( &p1, src2, 8 ); - src1 += 2; - src2 += 2; - - __m128i px = _mm_set_epi64x( p0, p1 ); - __m128i px0 = _mm_unpacklo_epi8( px, _mm_setzero_si128() ); - __m128i px1 = _mm_unpackhi_epi8( px, _mm_setzero_si128() ); - - __m128i s0 = _mm_add_epi16( px0, px1 ); - __m128i s1 = _mm_shuffle_epi32( s0, _MM_SHUFFLE( 1, 0, 3, 2 ) ); - __m128i s2 = _mm_add_epi16( s0, s1 ); - - __m128i r0 = _mm_srli_epi16( s2, 2 ); - __m128i r1 = _mm_packus_epi16( r0, r0 ); - - *ptr++ = _mm_cvtsi128_si32( r1 ); -#else - int r = ( ( *src1 & 0x000000FF ) + ( *(src1+1) & 0x000000FF ) + ( *src2 & 0x000000FF ) + ( *(src2+1) & 0x000000FF ) ) / 4; - int g = ( ( ( *src1 & 0x0000FF00 ) + ( *(src1+1) & 0x0000FF00 ) + ( *src2 & 0x0000FF00 ) + ( *(src2+1) & 0x0000FF00 ) ) / 4 ) & 0x0000FF00; - int b = ( ( ( *src1 & 0x00FF0000 ) + ( *(src1+1) & 0x00FF0000 ) + ( *src2 & 0x00FF0000 ) + ( *(src2+1) & 0x00FF0000 ) ) / 4 ) & 0x00FF0000; - int a = ( ( ( ( ( *src1 & 0xFF000000 ) >> 8 ) + ( ( *(src1+1) & 0xFF000000 ) >> 8 ) + ( ( *src2 & 0xFF000000 ) >> 8 ) + ( ( *(src2+1) & 0xFF000000 ) >> 8 ) ) / 4 ) & 0x00FF0000 ) << 8; - *ptr++ = r | g | b | a; - src1 += 2; - src2 += 2; -#endif - } - src1 += m_size.x * 2; - src2 += m_size.x * 2; - } - lines++; - if( lines >= m_lines ) - { - lines = 0; - m_sema.unlock(); - } - } - - if( lines != 0 ) - { - m_sema.unlock(); - } - } ); - } - } -} - -BitmapDownsampled::~BitmapDownsampled() -{ -} diff --git a/lib/etcpak/etcpak/BitmapDownsampled.hpp b/lib/etcpak/etcpak/BitmapDownsampled.hpp deleted file mode 100644 index a78037fbb65..00000000000 --- a/lib/etcpak/etcpak/BitmapDownsampled.hpp +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef __DARKRL__BITMAPDOWNSAMPLED_HPP__ -#define __DARKRL__BITMAPDOWNSAMPLED_HPP__ - -#include "Bitmap.hpp" - -class BitmapDownsampled : public Bitmap -{ -public: - BitmapDownsampled( const Bitmap& bmp, unsigned int lines, bool linearize ); - ~BitmapDownsampled(); -}; - -#endif diff --git a/lib/etcpak/etcpak/BlockData.cpp b/lib/etcpak/etcpak/BlockData.cpp deleted file mode 100644 index 4f9ec88eafc..00000000000 --- a/lib/etcpak/etcpak/BlockData.cpp +++ /dev/null @@ -1,400 +0,0 @@ -#include -#include - -#include "bcdec.h" -#include "BlockData.hpp" -#include "ColorSpace.hpp" -#include "Debug.hpp" -#include "MipMap.hpp" -#include "mmap.hpp" -#include "ProcessRGB.hpp" -#include "ProcessDxtc.hpp" -#include "Tables.hpp" -#include "TaskDispatch.hpp" -#include "Decode.hpp" - -#ifdef __ARM_NEON -# include -#endif - -#if defined __AVX__ && !defined __SSE4_1__ -# define __SSE4_1__ -#endif - -#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER -# ifdef _MSC_VER -# include -# include -# define _bswap(x) _byteswap_ulong(x) -# define _bswap64(x) _byteswap_uint64(x) -# else -# include -# endif -#endif - -#ifndef _bswap -# define _bswap(x) __builtin_bswap32(x) -# define _bswap64(x) __builtin_bswap64(x) -#endif - -static uint8_t table59T58H[8] = { 3,6,11,16,23,32,41,64 }; - -BlockData::BlockData( const char* fn ) - : m_file( fopen( fn, "rb" ) ) -{ - assert( m_file ); - fseek( m_file, 0, SEEK_END ); - m_maplen = ftell( m_file ); - fseek( m_file, 0, SEEK_SET ); - m_data = (uint8_t*)mmap( nullptr, m_maplen, PROT_READ, MAP_SHARED, fileno( m_file ), 0 ); - ProcessHeader(m_data, m_type, m_size.x, m_size.y, m_dataOffset); -} - -static void WritePvrHeader( uint32_t* dst, CodecType type, const v2i& size, int levels ) -{ - *dst++ = 0x03525650; // version - *dst++ = 0; // flags - switch( type ) // pixelformat[0] - { - case CodecType::Etc1: - *dst++ = 6; - break; - case CodecType::Etc2_RGB: - *dst++ = 22; - break; - case CodecType::Etc2_RGBA: - *dst++ = 23; - break; - case CodecType::Etc2_R11: - *dst++ = 25; - break; - case CodecType::Etc2_RG11: - *dst++ = 26; - break; - case CodecType::Bc1: - *dst++ = 7; - break; - case CodecType::Bc3: - *dst++ = 11; - break; - case CodecType::Bc4: - *dst++ = 12; - break; - case CodecType::Bc5: - *dst++ = 13; - break; - case CodecType::Bc7: - *dst++ = 15; - break; - default: - assert( false ); - break; - } - *dst++ = 0; // pixelformat[1] - *dst++ = 0; // colourspace - *dst++ = 0; // channel type - *dst++ = size.y; // height - *dst++ = size.x; // width - *dst++ = 1; // depth - *dst++ = 1; // num surfs - *dst++ = 1; // num faces - *dst++ = levels; // mipmap count - *dst++ = 0; // metadata size -} - -static void WriteDdsHeader( uint32_t* dst, CodecType type, const v2i& size, int levels ) -{ - const uint32_t flags = levels == 1 ? 0x1007 : 0x21007; - uint32_t pitch = size.x * size.y / 2; - if( type == CodecType::Etc2_RGBA || type == CodecType::Bc3 || type == CodecType::Bc5 || type == CodecType::Bc7 || type == CodecType::Etc2_RG11 ) pitch *= 2; - const uint32_t caps = levels == 1 ? 0x1000 : 0x401008; - - *dst++ = 0x20534444; // magic - *dst++ = 124; // size - *dst++ = flags; // flags - *dst++ = size.y; // height - *dst++ = size.x; // width - *dst++ = pitch; // pitch - *dst++ = 0; // depth - *dst++ = levels; // mipmap count - memset( dst, 0, 44 ); - dst += 11; - *dst++ = 32; // size - *dst++ = 4; // flags - switch( type ) - { - case CodecType::Bc1: - memcpy( dst++, "DXT1", 4 ); - break; - case CodecType::Bc3: - memcpy( dst++, "DXT5", 4 ); - break; - case CodecType::Bc4: - memcpy( dst++, "DX10", 4 ); - break; - case CodecType::Bc5: - memcpy( dst++, "DX10", 4 ); - break; - case CodecType::Bc7: - memcpy( dst++, "DX10", 4 ); - break; - default: - assert( false ); - break; - } - memset( dst, 0, 20 ); - dst += 5; - *dst++ = caps; - memset( dst, 0, 16 ); - dst+= 4; - - if( type == CodecType::Bc1 || type == CodecType::Bc3 ) return; - - switch( type ) - { - case CodecType::Bc4: - *dst++ = 80; // DXGI_FORMAT_BC4_UNORM - break; - case CodecType::Bc5: - *dst++ = 83; // DXGI_FORMAT_BC5_UNORM - break; - case CodecType::Bc7: - *dst++ = 98; // DXGI_FORMAT_BC7_UNORM - break; - default: - assert( false ); - break; - } - *dst++ = 3; // DXGI_FORMAT_DIMENSION_TEXTURE2D - *dst++ = 0; // miscFlag - *dst++ = 1; // arraySize - *dst++ = 0; // miscFlags2 -} - -static uint8_t* OpenForWriting( const char* fn, size_t len, const v2i& size, FILE** f, int levels, CodecType type, BlockData::Format format ) -{ - *f = fopen( fn, "wb+" ); - assert( *f ); - fseek( *f, len - 1, SEEK_SET ); - const char zero = 0; - fwrite( &zero, 1, 1, *f ); - fseek( *f, 0, SEEK_SET ); - - auto ret = (uint8_t*)mmap( nullptr, len, PROT_WRITE, MAP_SHARED, fileno( *f ), 0 ); - auto dst = (uint32_t*)ret; - - switch( format ) - { - case BlockData::Pvr: - WritePvrHeader( dst, type, size, levels ); - break; - case BlockData::Dds: - WriteDdsHeader( dst, type, size, levels ); - break; - default: - assert( false ); - break; - } - - return ret; -} - -static int AdjustSizeForMipmaps( const v2i& size, int levels ) -{ - int len = 0; - v2i current = size; - for( int i=1; i(m_size); - const uint64_t* src = (const uint64_t*)(m_data + m_dataOffset); - - switch( m_type ) - { - case Etc1: - case Etc2_RGB: - ::DecodeRGB(src, ret->Data(), m_size.x, m_size.y); - break; - case Etc2_RGBA: - ::DecodeRGBA(src, ret->Data(), m_size.x, m_size.y); - break; - case Etc2_R11: - ::DecodeR(src, ret->Data(), m_size.x, m_size.y); - break; - case Etc2_RG11: - ::DecodeRG(src, ret->Data(), m_size.x, m_size.y); - break; - case Bc1: - ::DecodeBc1(src, ret->Data(), m_size.x, m_size.y); - break; - case Bc3: - ::DecodeBc3(src, ret->Data(), m_size.x, m_size.y); - break; - case Bc4: - ::DecodeBc4(src, ret->Data(), m_size.x, m_size.y); - break; - case Bc5: - ::DecodeBc5(src, ret->Data(), m_size.x, m_size.y); - break; - case Bc7: - ::DecodeBc7(src, ret->Data(), m_size.x, m_size.y); - break; - default: - assert( false ); - return nullptr; - } - return ret; -} diff --git a/lib/etcpak/etcpak/BlockData.hpp b/lib/etcpak/etcpak/BlockData.hpp deleted file mode 100644 index 90071331d31..00000000000 --- a/lib/etcpak/etcpak/BlockData.hpp +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef __BLOCKDATA_HPP__ -#define __BLOCKDATA_HPP__ - -#include -#include -#include -#include -#include -#include -#include - -#include "Bitmap.hpp" -#include "ForceInline.hpp" -#include "Vector.hpp" -#include "TextureHeader.hpp" - -struct bc7enc_compress_block_params; - -class BlockData -{ -public: - - enum Format - { - Pvr, - Dds - }; - - BlockData( const char* fn ); - BlockData( const char* fn, const v2i& size, bool mipmap, CodecType type, Format format ); - BlockData( const v2i& size, bool mipmap, CodecType type ); - ~BlockData(); - - BitmapPtr Decode(); - - void Process( const uint32_t* src, uint32_t blocks, size_t offset, size_t width, bool dither, bool useHeuristics ); - void ProcessRGBA( const uint32_t* src, uint32_t blocks, size_t offset, size_t width, bool useHeuristics, const bc7enc_compress_block_params* params ); - - const v2i& Size() const { return m_size; } - -private: - uint8_t* m_data; - v2i m_size; - size_t m_dataOffset; - FILE* m_file; - size_t m_maplen; - CodecType m_type; -}; - -typedef std::shared_ptr BlockDataPtr; - -#endif diff --git a/lib/etcpak/etcpak/ColorSpace.cpp b/lib/etcpak/etcpak/ColorSpace.cpp deleted file mode 100644 index 04115410662..00000000000 --- a/lib/etcpak/etcpak/ColorSpace.cpp +++ /dev/null @@ -1,114 +0,0 @@ -#include -#include - -#include "Math.hpp" -#include "ColorSpace.hpp" - -namespace Color -{ - - static const XYZ white( v3b( 255, 255, 255 ) ); - static const v3f rwhite( 1.f / white.x, 1.f / white.y, 1.f / white.z ); - - - XYZ::XYZ( float _x, float _y, float _z ) - : x( _x ) - , y( _y ) - , z( _z ) - { - } - - XYZ::XYZ( const v3b& rgb ) - { - const float r = rgb.x / 255.f; - const float g = rgb.y / 255.f; - const float b = rgb.z / 255.f; - - const float rl = sRGB2linear( r ); - const float gl = sRGB2linear( g ); - const float bl = sRGB2linear( b ); - - x = 0.4124f * rl + 0.3576f * gl + 0.1805f * bl; - y = 0.2126f * rl + 0.7152f * gl + 0.0722f * bl; - z = 0.0193f * rl + 0.1192f * gl + 0.9505f * bl; - } - - static float revlab( float t ) - { - const float p1 = 6.f/29.f; - const float p2 = 4.f/29.f; - - if( t > p1 ) - { - return t*t*t; - } - else - { - return 3 * sq( p1 ) * ( t - p2 ); - } - } - - XYZ::XYZ( const Lab& lab ) - { - y = white.y * revlab( 1.f/116.f * ( lab.L + 16 ) ); - x = white.x * revlab( 1.f/116.f * ( lab.L + 16 ) + 1.f/500.f * lab.a ); - z = white.z * revlab( 1.f/116.f * ( lab.L + 16 ) - 1.f/200.f * lab.b ); - } - - v3i XYZ::RGB() const - { - const float rl = 3.2406f * x - 1.5372f * y - 0.4986f * z; - const float gl = -0.9689f * x + 1.8758f * y + 0.0415f * z; - const float bl = 0.0557f * x - 0.2040f * y + 1.0570f * z; - - const float r = linear2sRGB( rl ); - const float g = linear2sRGB( gl ); - const float b = linear2sRGB( bl ); - - return v3i( clampu8( int32_t( r * 255 ) ), clampu8( int32_t( g * 255 ) ), clampu8( int32_t( b * 255 ) ) ); - } - - - Lab::Lab() - : L( 0 ) - , a( 0 ) - , b( 0 ) - { - } - - Lab::Lab( float L, float a, float b ) - : L( L ) - , a( a ) - , b( b ) - { - } - - static float labfunc( float t ) - { - const float p1 = (6.f/29.f)*(6.f/29.f)*(6.f/29.f); - const float p2 = (1.f/3.f)*(29.f/6.f)*(29.f/6.f); - const float p3 = (4.f/29.f); - - if( t > p1 ) - { - return pow( t, 1.f/3.f ); - } - else - { - return p2 * t + p3; - } - } - - Lab::Lab( const XYZ& xyz ) - { - L = 116 * labfunc( xyz.y * rwhite.y ) - 16; - a = 500 * ( labfunc( xyz.x * rwhite.x ) - labfunc( xyz.y * rwhite.y ) ); - b = 200 * ( labfunc( xyz.y * rwhite.y ) - labfunc( xyz.z * rwhite.z ) ); - } - - Lab::Lab( const v3b& rgb ) - { - new(this) Lab( XYZ( rgb ) ); - } - -} diff --git a/lib/etcpak/etcpak/ColorSpace.hpp b/lib/etcpak/etcpak/ColorSpace.hpp deleted file mode 100644 index c9d0a9cf3f0..00000000000 --- a/lib/etcpak/etcpak/ColorSpace.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef __DARKRL__COLORSPACE_HPP__ -#define __DARKRL__COLORSPACE_HPP__ - -#include "Vector.hpp" - -namespace Color -{ - - class Lab; - - class XYZ - { - public: - XYZ( float x, float y, float z ); - XYZ( const v3b& rgb ); - XYZ( const Lab& lab ); - - v3i RGB() const; - - float x, y, z; - }; - - class Lab - { - public: - Lab(); - Lab( float L, float a, float b ); - Lab( const XYZ& xyz ); - Lab( const v3b& rgb ); - - float L, a, b; - }; - -} - -#endif diff --git a/lib/etcpak/etcpak/DataProvider.cpp b/lib/etcpak/etcpak/DataProvider.cpp deleted file mode 100644 index 3de3668ccf2..00000000000 --- a/lib/etcpak/etcpak/DataProvider.cpp +++ /dev/null @@ -1,78 +0,0 @@ -#include -#include - -#include "BitmapDownsampled.hpp" -#include "DataProvider.hpp" -#include "MipMap.hpp" - -DataProvider::DataProvider( const char* fn, bool mipmap, bool bgr, bool linearize ) - : m_offset( 0 ) - , m_lines( 32 ) - , m_mipmap( mipmap ) - , m_done( false ) - , m_linearize( linearize ) -{ - m_bmp.emplace_back( new Bitmap( fn, m_lines, bgr ) ); - m_current = m_bmp[0].get(); -} - -DataProvider::~DataProvider() -{ -} - -unsigned int DataProvider::NumberOfParts() const -{ - unsigned int parts = ( ( m_bmp[0]->Size().y / 4 ) + m_lines - 1 ) / m_lines; - - if( m_mipmap ) - { - v2i current = m_bmp[0]->Size(); - int levels = NumberOfMipLevels( current ); - unsigned int lines = m_lines; - for( int i=1; iNextBlock( lines, done ); - DataPart ret = { - ptr, - std::max( 4, m_current->Size().x ), - lines, - m_offset - }; - - m_offset += m_current->Size().x / 4 * lines; - - if( done ) - { - if( m_mipmap && ( m_current->Size().x != 1 || m_current->Size().y != 1 ) ) - { - m_lines *= 2; - m_bmp.emplace_back( new BitmapDownsampled( *m_current, m_lines, m_linearize ) ); - m_current = m_bmp[m_bmp.size()-1].get(); - } - else - { - m_done = true; - } - } - - return ret; -} diff --git a/lib/etcpak/etcpak/DataProvider.hpp b/lib/etcpak/etcpak/DataProvider.hpp deleted file mode 100644 index bdd3af2ee46..00000000000 --- a/lib/etcpak/etcpak/DataProvider.hpp +++ /dev/null @@ -1,42 +0,0 @@ -#ifndef __DATAPROVIDER_HPP__ -#define __DATAPROVIDER_HPP__ - -#include -#include -#include - -#include "Bitmap.hpp" - -struct DataPart -{ - const uint32_t* src; - unsigned int width; - unsigned int lines; - unsigned int offset; -}; - -class DataProvider -{ -public: - DataProvider( const char* fn, bool mipmap, bool bgr, bool linearize ); - ~DataProvider(); - - unsigned int NumberOfParts() const; - - DataPart NextPart(); - - bool Alpha() const { return m_bmp[0]->Alpha(); } - const v2i& Size() const { return m_bmp[0]->Size(); } - const Bitmap& ImageData() const { return *m_bmp[0]; } - -private: - std::vector> m_bmp; - Bitmap* m_current; - unsigned int m_offset; - unsigned int m_lines; - bool m_mipmap; - bool m_done; - bool m_linearize; -}; - -#endif diff --git a/lib/etcpak/etcpak/Debug.cpp b/lib/etcpak/etcpak/Debug.cpp deleted file mode 100644 index 72dc4e05268..00000000000 --- a/lib/etcpak/etcpak/Debug.cpp +++ /dev/null @@ -1,31 +0,0 @@ -#include -#include -#include "Debug.hpp" - -static std::vector s_callbacks; - -void DebugLog::Message( const char* msg ) -{ - for( auto it = s_callbacks.begin(); it != s_callbacks.end(); ++it ) - { - (*it)->OnDebugMessage( msg ); - } -} - -void DebugLog::AddCallback( Callback* c ) -{ - const auto it = std::find( s_callbacks.begin(), s_callbacks.end(), c ); - if( it == s_callbacks.end() ) - { - s_callbacks.push_back( c ); - } -} - -void DebugLog::RemoveCallback( Callback* c ) -{ - const auto it = std::find( s_callbacks.begin(), s_callbacks.end(), c ); - if( it != s_callbacks.end() ) - { - s_callbacks.erase( it ); - } -} diff --git a/lib/etcpak/etcpak/Debug.hpp b/lib/etcpak/etcpak/Debug.hpp deleted file mode 100644 index 524eaa7bafe..00000000000 --- a/lib/etcpak/etcpak/Debug.hpp +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef __DARKRL__DEBUG_HPP__ -#define __DARKRL__DEBUG_HPP__ - -#ifdef DEBUG -# include -# define DBGPRINT(msg) { std::stringstream __buf; __buf << msg; DebugLog::Message( __buf.str().c_str() ); } -#else -# define DBGPRINT(msg) ((void)0) -#endif - -class DebugLog -{ -public: - struct Callback - { - virtual void OnDebugMessage( const char* msg ) = 0; - }; - - static void Message( const char* msg ); - static void AddCallback( Callback* c ); - static void RemoveCallback( Callback* c ); - -private: - DebugLog() {} -}; - -#endif diff --git a/lib/etcpak/etcpak/Decode.cpp b/lib/etcpak/etcpak/Decode.cpp deleted file mode 100644 index dbc6be545d9..00000000000 --- a/lib/etcpak/etcpak/Decode.cpp +++ /dev/null @@ -1,1286 +0,0 @@ -#include -#include - -#include "bcdec.h" -#include "Decode.hpp" -#include "ForceInline.hpp" -#include "Tables.hpp" -#include "Math.hpp" - - -#ifdef __ARM_NEON -# include -#endif - -#if defined __AVX__ && !defined __SSE4_1__ -# define __SSE4_1__ -#endif - -#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER -# ifdef _MSC_VER -# include -# include -# define _bswap(x) _byteswap_ulong(x) -# define _bswap64(x) _byteswap_uint64(x) -# else -# include -# endif -#endif - -#ifndef _bswap -# define _bswap(x) __builtin_bswap32(x) -# define _bswap64(x) __builtin_bswap64(x) -#endif - -static uint8_t table59T58H[8] = { 3,6,11,16,23,32,41,64 }; - -namespace -{ - -static etcpak_force_inline int32_t expand6(uint32_t value) -{ - return (value << 2) | (value >> 4); -} - -static etcpak_force_inline int32_t expand7(uint32_t value) -{ - return (value << 1) | (value >> 6); -} - -static etcpak_force_inline void DecodeT( uint64_t block, uint32_t* dst, uint32_t w ) -{ - const auto r0 = ( block >> 24 ) & 0x1B; - const auto rh0 = ( r0 >> 3 ) & 0x3; - const auto rl0 = r0 & 0x3; - const auto g0 = ( block >> 20 ) & 0xF; - const auto b0 = ( block >> 16 ) & 0xF; - - const auto r1 = ( block >> 12 ) & 0xF; - const auto g1 = ( block >> 8 ) & 0xF; - const auto b1 = ( block >> 4 ) & 0xF; - - const auto cr0 = ( ( rh0 << 6 ) | ( rl0 << 4 ) | ( rh0 << 2 ) | rl0); - const auto cg0 = ( g0 << 4 ) | g0; - const auto cb0 = ( b0 << 4 ) | b0; - - const auto cr1 = ( r1 << 4 ) | r1; - const auto cg1 = ( g1 << 4 ) | g1; - const auto cb1 = ( b1 << 4 ) | b1; - - const auto codeword_hi = ( block >> 2 ) & 0x3; - const auto codeword_lo = block & 0x1; - const auto codeword = ( codeword_hi << 1 ) | codeword_lo; - - const auto c2r = clampu8( cr1 + table59T58H[codeword] ); - const auto c2g = clampu8( cg1 + table59T58H[codeword] ); - const auto c2b = clampu8( cb1 + table59T58H[codeword] ); - - const auto c3r = clampu8( cr1 - table59T58H[codeword] ); - const auto c3g = clampu8( cg1 - table59T58H[codeword] ); - const auto c3b = clampu8( cb1 - table59T58H[codeword] ); - - const uint32_t col_tab[4] = { - uint32_t( cr0 | ( cg0 << 8 ) | ( cb0 << 16 ) | 0xFF000000 ), - uint32_t( c2r | ( c2g << 8 ) | ( c2b << 16 ) | 0xFF000000 ), - uint32_t( cr1 | ( cg1 << 8 ) | ( cb1 << 16 ) | 0xFF000000 ), - uint32_t( c3r | ( c3g << 8 ) | ( c3b << 16 ) | 0xFF000000 ) - }; - - const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF; - for( uint8_t j = 0; j < 4; j++ ) - { - for( uint8_t i = 0; i < 4; i++ ) - { - //2bit indices distributed on two lane 16bit numbers - const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1) | ( ( indexes >> ( j + i * 4 ) ) & 0x1); - dst[j * w + i] = col_tab[index]; - } - } -} - -static etcpak_force_inline void DecodeTAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w ) -{ - const auto r0 = ( block >> 24 ) & 0x1B; - const auto rh0 = ( r0 >> 3 ) & 0x3; - const auto rl0 = r0 & 0x3; - const auto g0 = ( block >> 20 ) & 0xF; - const auto b0 = ( block >> 16 ) & 0xF; - - const auto r1 = ( block >> 12 ) & 0xF; - const auto g1 = ( block >> 8 ) & 0xF; - const auto b1 = ( block >> 4 ) & 0xF; - - const auto cr0 = ( ( rh0 << 6 ) | ( rl0 << 4 ) | ( rh0 << 2 ) | rl0); - const auto cg0 = ( g0 << 4 ) | g0; - const auto cb0 = ( b0 << 4 ) | b0; - - const auto cr1 = ( r1 << 4 ) | r1; - const auto cg1 = ( g1 << 4 ) | g1; - const auto cb1 = ( b1 << 4 ) | b1; - - const auto codeword_hi = ( block >> 2 ) & 0x3; - const auto codeword_lo = block & 0x1; - const auto codeword = (codeword_hi << 1) | codeword_lo; - - const int32_t base = alpha >> 56; - const int32_t mul = ( alpha >> 52 ) & 0xF; - const auto tbl = g_alpha[( alpha >> 48 ) & 0xF]; - - const auto c2r = clampu8( cr1 + table59T58H[codeword] ); - const auto c2g = clampu8( cg1 + table59T58H[codeword] ); - const auto c2b = clampu8( cb1 + table59T58H[codeword] ); - - const auto c3r = clampu8( cr1 - table59T58H[codeword] ); - const auto c3g = clampu8( cg1 - table59T58H[codeword] ); - const auto c3b = clampu8( cb1 - table59T58H[codeword] ); - - const uint32_t col_tab[4] = { - uint32_t( cr0 | ( cg0 << 8 ) | ( cb0 << 16 ) ), - uint32_t( c2r | ( c2g << 8 ) | ( c2b << 16 ) ), - uint32_t( cr1 | ( cg1 << 8 ) | ( cb1 << 16 ) ), - uint32_t( c3r | ( c3g << 8 ) | ( c3b << 16 ) ) - }; - - const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF; - for( uint8_t j = 0; j < 4; j++ ) - { - for( uint8_t i = 0; i < 4; i++ ) - { - //2bit indices distributed on two lane 16bit numbers - const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 ); - const auto amod = tbl[( alpha >> ( 45 - j * 3 - i * 12 ) ) & 0x7]; - const uint32_t a = clampu8( base + amod * mul ); - dst[j * w + i] = col_tab[index] | ( a << 24 ); - } - } -} - -static etcpak_force_inline void DecodeH( uint64_t block, uint32_t* dst, uint32_t w ) -{ - const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF; - - const auto r0444 = ( block >> 27 ) & 0xF; - const auto g0444 = ( ( block >> 20 ) & 0x1 ) | ( ( ( block >> 24 ) & 0x7 ) << 1 ); - const auto b0444 = ( ( block >> 15 ) & 0x7 ) | ( ( ( block >> 19 ) & 0x1 ) << 3 ); - - const auto r1444 = ( block >> 11 ) & 0xF; - const auto g1444 = ( block >> 7 ) & 0xF; - const auto b1444 = ( block >> 3 ) & 0xF; - - const auto r0 = ( r0444 << 4 ) | r0444; - const auto g0 = ( g0444 << 4 ) | g0444; - const auto b0 = ( b0444 << 4 ) | b0444; - - const auto r1 = ( r1444 << 4 ) | r1444; - const auto g1 = ( g1444 << 4 ) | g1444; - const auto b1 = ( b1444 << 4 ) | b1444; - - const auto codeword_hi = ( ( block & 0x1 ) << 1 ) | ( ( block & 0x4 ) ); - const auto c0 = ( r0444 << 8 ) | ( g0444 << 4 ) | ( b0444 << 0 ); - const auto c1 = ( block >> 3 ) & ( ( 1 << 12 ) - 1 ); - const auto codeword_lo = ( c0 >= c1 ) ? 1 : 0; - const auto codeword = codeword_hi | codeword_lo; - - const uint32_t col_tab[] = { - uint32_t( clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 ) ), - uint32_t( clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 ) ), - uint32_t( clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 ) ), - uint32_t( clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 ) ) - }; - - for( uint8_t j = 0; j < 4; j++ ) - { - for( uint8_t i = 0; i < 4; i++ ) - { - const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 ); - dst[j * w + i] = col_tab[index] | 0xFF000000; - } - } -} - -static etcpak_force_inline void DecodeHAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w ) -{ - const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF; - - const auto r0444 = ( block >> 27 ) & 0xF; - const auto g0444 = ( ( block >> 20 ) & 0x1 ) | ( ( ( block >> 24 ) & 0x7 ) << 1 ); - const auto b0444 = ( ( block >> 15 ) & 0x7 ) | ( ( ( block >> 19 ) & 0x1 ) << 3 ); - - const auto r1444 = ( block >> 11 ) & 0xF; - const auto g1444 = ( block >> 7 ) & 0xF; - const auto b1444 = ( block >> 3 ) & 0xF; - - const auto r0 = ( r0444 << 4 ) | r0444; - const auto g0 = ( g0444 << 4 ) | g0444; - const auto b0 = ( b0444 << 4 ) | b0444; - - const auto r1 = ( r1444 << 4 ) | r1444; - const auto g1 = ( g1444 << 4 ) | g1444; - const auto b1 = ( b1444 << 4 ) | b1444; - - const auto codeword_hi = ( ( block & 0x1 ) << 1 ) | ( ( block & 0x4 ) ); - const auto c0 = ( r0444 << 8 ) | ( g0444 << 4 ) | ( b0444 << 0 ); - const auto c1 = ( block >> 3 ) & ( ( 1 << 12 ) - 1 ); - const auto codeword_lo = ( c0 >= c1 ) ? 1 : 0; - const auto codeword = codeword_hi | codeword_lo; - - const int32_t base = alpha >> 56; - const int32_t mul = ( alpha >> 52 ) & 0xF; - const auto tbl = g_alpha[(alpha >> 48) & 0xF]; - - const uint32_t col_tab[] = { - uint32_t( clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 ) ), - uint32_t( clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 ) ), - uint32_t( clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 ) ), - uint32_t( clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 ) ) - }; - - for( uint8_t j = 0; j < 4; j++ ) - { - for( uint8_t i = 0; i < 4; i++ ) - { - const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 ); - const auto amod = tbl[( alpha >> ( 45 - j * 3 - i * 12) ) & 0x7]; - const uint32_t a = clampu8( base + amod * mul ); - dst[j * w + i] = col_tab[index] | ( a << 24 ); - } - } -} - -static etcpak_force_inline void DecodePlanar( uint64_t block, uint32_t* dst, uint32_t w ) -{ - const auto bv = expand6((block >> ( 0 + 32)) & 0x3F); - const auto gv = expand7((block >> ( 6 + 32)) & 0x7F); - const auto rv = expand6((block >> (13 + 32)) & 0x3F); - - const auto bh = expand6((block >> (19 + 32)) & 0x3F); - const auto gh = expand7((block >> (25 + 32)) & 0x7F); - - const auto rh0 = (block >> (32 - 32)) & 0x01; - const auto rh1 = ((block >> (34 - 32)) & 0x1F) << 1; - const auto rh = expand6(rh0 | rh1); - - const auto bo0 = (block >> (39 - 32)) & 0x07; - const auto bo1 = ((block >> (43 - 32)) & 0x3) << 3; - const auto bo2 = ((block >> (48 - 32)) & 0x1) << 5; - const auto bo = expand6(bo0 | bo1 | bo2); - const auto go0 = (block >> (49 - 32)) & 0x3F; - const auto go1 = ((block >> (56 - 32)) & 0x01) << 6; - const auto go = expand7(go0 | go1); - const auto ro = expand6((block >> (57 - 32)) & 0x3F); - -#ifdef __ARM_NEON - uint64_t init = uint64_t(uint16_t(rh-ro)) | ( uint64_t(uint16_t(gh-go)) << 16 ) | ( uint64_t(uint16_t(bh-bo)) << 32 ); - int16x8_t chco = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); - init = uint64_t(uint16_t( (rv-ro) - 4 * (rh-ro) )) | ( uint64_t(uint16_t( (gv-go) - 4 * (gh-go) )) << 16 ) | ( uint64_t(uint16_t( (bv-bo) - 4 * (bh-bo) )) << 32 ); - int16x8_t cvco = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); - init = uint64_t(4*ro+2) | ( uint64_t(4*go+2) << 16 ) | ( uint64_t(4*bo+2) << 32 ) | ( uint64_t(0xFFF) << 48 ); - int16x8_t col = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); - - for( int j=0; j<4; j++ ) - { - for( int i=0; i<4; i++ ) - { - uint8x8_t c = vqshrun_n_s16( col, 2 ); - vst1_lane_u32( dst+j*w+i, vreinterpret_u32_u8( c ), 0 ); - col = vaddq_s16( col, chco ); - } - col = vaddq_s16( col, cvco ); - } -#elif defined __AVX2__ - const auto R0 = 4*ro+2; - const auto G0 = 4*go+2; - const auto B0 = 4*bo+2; - const auto RHO = rh-ro; - const auto GHO = gh-go; - const auto BHO = bh-bo; - - __m256i cvco = _mm256_setr_epi16( rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0 ); - __m256i col = _mm256_setr_epi16( R0, G0, B0, 0xFFF, R0+RHO, G0+GHO, B0+BHO, 0xFFF, R0+2*RHO, G0+2*GHO, B0+2*BHO, 0xFFF, R0+3*RHO, G0+3*GHO, B0+3*BHO, 0xFFF ); - - for( int j=0; j<4; j++ ) - { - __m256i c = _mm256_srai_epi16( col, 2 ); - __m128i s = _mm_packus_epi16( _mm256_castsi256_si128( c ), _mm256_extracti128_si256( c, 1 ) ); - _mm_storeu_si128( (__m128i*)(dst+j*w), s ); - col = _mm256_add_epi16( col, cvco ); - } -#elif defined __SSE4_1__ - __m128i chco = _mm_setr_epi16( rh - ro, gh - go, bh - bo, 0, 0, 0, 0, 0 ); - __m128i cvco = _mm_setr_epi16( (rv - ro) - 4 * (rh - ro), (gv - go) - 4 * (gh - go), (bv - bo) - 4 * (bh - bo), 0, 0, 0, 0, 0 ); - __m128i col = _mm_setr_epi16( 4*ro+2, 4*go+2, 4*bo+2, 0xFFF, 0, 0, 0, 0 ); - - for( int j=0; j<4; j++ ) - { - for( int i=0; i<4; i++ ) - { - __m128i c = _mm_srai_epi16( col, 2 ); - __m128i s = _mm_packus_epi16( c, c ); - dst[j*w+i] = _mm_cvtsi128_si32( s ); - col = _mm_add_epi16( col, chco ); - } - col = _mm_add_epi16( col, cvco ); - } -#else - for( int j=0; j<4; j++ ) - { - for( int i=0; i<4; i++ ) - { - const uint32_t r = (i * (rh - ro) + j * (rv - ro) + 4 * ro + 2) >> 2; - const uint32_t g = (i * (gh - go) + j * (gv - go) + 4 * go + 2) >> 2; - const uint32_t b = (i * (bh - bo) + j * (bv - bo) + 4 * bo + 2) >> 2; - if( ( ( r | g | b ) & ~0xFF ) == 0 ) - { - dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000; - } - else - { - const auto rc = clampu8( r ); - const auto gc = clampu8( g ); - const auto bc = clampu8( b ); - dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000; - } - } - } -#endif -} - -static etcpak_force_inline void DecodePlanarAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w ) -{ - const auto bv = expand6((block >> ( 0 + 32)) & 0x3F); - const auto gv = expand7((block >> ( 6 + 32)) & 0x7F); - const auto rv = expand6((block >> (13 + 32)) & 0x3F); - - const auto bh = expand6((block >> (19 + 32)) & 0x3F); - const auto gh = expand7((block >> (25 + 32)) & 0x7F); - - const auto rh0 = (block >> (32 - 32)) & 0x01; - const auto rh1 = ((block >> (34 - 32)) & 0x1F) << 1; - const auto rh = expand6(rh0 | rh1); - - const auto bo0 = (block >> (39 - 32)) & 0x07; - const auto bo1 = ((block >> (43 - 32)) & 0x3) << 3; - const auto bo2 = ((block >> (48 - 32)) & 0x1) << 5; - const auto bo = expand6(bo0 | bo1 | bo2); - const auto go0 = (block >> (49 - 32)) & 0x3F; - const auto go1 = ((block >> (56 - 32)) & 0x01) << 6; - const auto go = expand7(go0 | go1); - const auto ro = expand6((block >> (57 - 32)) & 0x3F); - - const int32_t base = alpha >> 56; - const int32_t mul = ( alpha >> 52 ) & 0xF; - const auto tbl = g_alpha[( alpha >> 48 ) & 0xF]; - -#ifdef __ARM_NEON - uint64_t init = uint64_t(uint16_t(rh-ro)) | ( uint64_t(uint16_t(gh-go)) << 16 ) | ( uint64_t(uint16_t(bh-bo)) << 32 ); - int16x8_t chco = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); - init = uint64_t(uint16_t( (rv-ro) - 4 * (rh-ro) )) | ( uint64_t(uint16_t( (gv-go) - 4 * (gh-go) )) << 16 ) | ( uint64_t(uint16_t( (bv-bo) - 4 * (bh-bo) )) << 32 ); - int16x8_t cvco = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); - init = uint64_t(4*ro+2) | ( uint64_t(4*go+2) << 16 ) | ( uint64_t(4*bo+2) << 32 ); - int16x8_t col = vreinterpretq_s16_u64( vdupq_n_u64( init ) ); - - for( int j=0; j<4; j++ ) - { - for( int i=0; i<4; i++ ) - { - const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; - const uint32_t a = clampu8( base + amod * mul ); - uint8x8_t c = vqshrun_n_s16( col, 2 ); - dst[j*w+i] = vget_lane_u32( vreinterpret_u32_u8( c ), 0 ) | ( a << 24 ); - col = vaddq_s16( col, chco ); - } - col = vaddq_s16( col, cvco ); - } -#elif defined __SSE4_1__ - __m128i chco = _mm_setr_epi16( rh - ro, gh - go, bh - bo, 0, 0, 0, 0, 0 ); - __m128i cvco = _mm_setr_epi16( (rv - ro) - 4 * (rh - ro), (gv - go) - 4 * (gh - go), (bv - bo) - 4 * (bh - bo), 0, 0, 0, 0, 0 ); - __m128i col = _mm_setr_epi16( 4*ro+2, 4*go+2, 4*bo+2, 0, 0, 0, 0, 0 ); - - for( int j=0; j<4; j++ ) - { - for( int i=0; i<4; i++ ) - { - const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; - const uint32_t a = clampu8( base + amod * mul ); - __m128i c = _mm_srai_epi16( col, 2 ); - __m128i s = _mm_packus_epi16( c, c ); - dst[j*w+i] = _mm_cvtsi128_si32( s ) | ( a << 24 ); - col = _mm_add_epi16( col, chco ); - } - col = _mm_add_epi16( col, cvco ); - } -#else - for (auto j = 0; j < 4; j++) - { - for (auto i = 0; i < 4; i++) - { - const uint32_t r = (i * (rh - ro) + j * (rv - ro) + 4 * ro + 2) >> 2; - const uint32_t g = (i * (gh - go) + j * (gv - go) + 4 * go + 2) >> 2; - const uint32_t b = (i * (bh - bo) + j * (bv - bo) + 4 * bo + 2) >> 2; - const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; - const uint32_t a = clampu8( base + amod * mul ); - if( ( ( r | g | b ) & ~0xFF ) == 0 ) - { - dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 ); - } - else - { - const auto rc = clampu8( r ); - const auto gc = clampu8( g ); - const auto bc = clampu8( b ); - dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 ); - } - } - } -#endif -} - -static etcpak_force_inline uint64_t ConvertByteOrder( uint64_t d ) -{ - uint32_t word[2]; - memcpy( word, &d, 8 ); - word[0] = _bswap( word[0] ); - word[1] = _bswap( word[1] ); - memcpy( &d, word, 8 ); - return d; -} - -static etcpak_force_inline void DecodeRGBPart( uint64_t d, uint32_t* dst, uint32_t w ) -{ - d = ConvertByteOrder( d ); - - uint32_t br[2], bg[2], bb[2]; - - if( d & 0x2 ) - { - int32_t dr, dg, db; - - uint32_t r0 = ( d & 0xF8000000 ) >> 27; - uint32_t g0 = ( d & 0x00F80000 ) >> 19; - uint32_t b0 = ( d & 0x0000F800 ) >> 11; - - dr = ( int32_t(d) << 5 ) >> 29; - dg = ( int32_t(d) << 13 ) >> 29; - db = ( int32_t(d) << 21 ) >> 29; - - int32_t r1 = int32_t(r0) + dr; - int32_t g1 = int32_t(g0) + dg; - int32_t b1 = int32_t(b0) + db; - - // T mode - if ( (r1 < 0) || (r1 > 31) ) - { - DecodeT( d, dst, w ); - return; - } - - // H mode - if ((g1 < 0) || (g1 > 31)) - { - DecodeH( d, dst, w ); - return; - } - - // P mode - if( (b1 < 0) || (b1 > 31) ) - { - DecodePlanar( d, dst, w ); - return; - } - - br[0] = ( r0 << 3 ) | ( r0 >> 2 ); - br[1] = ( r1 << 3 ) | ( r1 >> 2 ); - bg[0] = ( g0 << 3 ) | ( g0 >> 2 ); - bg[1] = ( g1 << 3 ) | ( g1 >> 2 ); - bb[0] = ( b0 << 3 ) | ( b0 >> 2 ); - bb[1] = ( b1 << 3 ) | ( b1 >> 2 ); - } - else - { - br[0] = ( ( d & 0xF0000000 ) >> 24 ) | ( ( d & 0xF0000000 ) >> 28 ); - br[1] = ( ( d & 0x0F000000 ) >> 20 ) | ( ( d & 0x0F000000 ) >> 24 ); - bg[0] = ( ( d & 0x00F00000 ) >> 16 ) | ( ( d & 0x00F00000 ) >> 20 ); - bg[1] = ( ( d & 0x000F0000 ) >> 12 ) | ( ( d & 0x000F0000 ) >> 16 ); - bb[0] = ( ( d & 0x0000F000 ) >> 8 ) | ( ( d & 0x0000F000 ) >> 12 ); - bb[1] = ( ( d & 0x00000F00 ) >> 4 ) | ( ( d & 0x00000F00 ) >> 8 ); - } - - unsigned int tcw[2]; - tcw[0] = ( d & 0xE0 ) >> 5; - tcw[1] = ( d & 0x1C ) >> 2; - - uint32_t b1 = ( d >> 32 ) & 0xFFFF; - uint32_t b2 = ( d >> 48 ); - - b1 = ( b1 | ( b1 << 8 ) ) & 0x00FF00FF; - b1 = ( b1 | ( b1 << 4 ) ) & 0x0F0F0F0F; - b1 = ( b1 | ( b1 << 2 ) ) & 0x33333333; - b1 = ( b1 | ( b1 << 1 ) ) & 0x55555555; - - b2 = ( b2 | ( b2 << 8 ) ) & 0x00FF00FF; - b2 = ( b2 | ( b2 << 4 ) ) & 0x0F0F0F0F; - b2 = ( b2 | ( b2 << 2 ) ) & 0x33333333; - b2 = ( b2 | ( b2 << 1 ) ) & 0x55555555; - - uint32_t idx = b1 | ( b2 << 1 ); - - if( d & 0x1 ) - { - for( int i=0; i<4; i++ ) - { - for( int j=0; j<4; j++ ) - { - const auto mod = g_table[tcw[j/2]][idx & 0x3]; - const auto r = br[j/2] + mod; - const auto g = bg[j/2] + mod; - const auto b = bb[j/2] + mod; - if( ( ( r | g | b ) & ~0xFF ) == 0 ) - { - dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000; - } - else - { - const auto rc = clampu8( r ); - const auto gc = clampu8( g ); - const auto bc = clampu8( b ); - dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000; - } - idx >>= 2; - } - } - } - else - { - for( int i=0; i<4; i++ ) - { - const auto tbl = g_table[tcw[i/2]]; - const auto cr = br[i/2]; - const auto cg = bg[i/2]; - const auto cb = bb[i/2]; - - for( int j=0; j<4; j++ ) - { - const auto mod = tbl[idx & 0x3]; - const auto r = cr + mod; - const auto g = cg + mod; - const auto b = cb + mod; - if( ( ( r | g | b ) & ~0xFF ) == 0 ) - { - dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000; - } - else - { - const auto rc = clampu8( r ); - const auto gc = clampu8( g ); - const auto bc = clampu8( b ); - dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000; - } - idx >>= 2; - } - } - } -} - -static etcpak_force_inline void DecodeRGBAPart( uint64_t d, uint64_t alpha, uint32_t* dst, uint32_t w ) -{ - d = ConvertByteOrder( d ); - alpha = _bswap64( alpha ); - - uint32_t br[2], bg[2], bb[2]; - - if( d & 0x2 ) - { - int32_t dr, dg, db; - - uint32_t r0 = ( d & 0xF8000000 ) >> 27; - uint32_t g0 = ( d & 0x00F80000 ) >> 19; - uint32_t b0 = ( d & 0x0000F800 ) >> 11; - - dr = ( int32_t(d) << 5 ) >> 29; - dg = ( int32_t(d) << 13 ) >> 29; - db = ( int32_t(d) << 21 ) >> 29; - - int32_t r1 = int32_t(r0) + dr; - int32_t g1 = int32_t(g0) + dg; - int32_t b1 = int32_t(b0) + db; - - // T mode - if ( (r1 < 0) || (r1 > 31) ) - { - DecodeTAlpha( d, alpha, dst, w ); - return; - } - - // H mode - if ( (g1 < 0) || (g1 > 31) ) - { - DecodeHAlpha( d, alpha, dst, w ); - return; - } - - // P mode - if ( (b1 < 0) || (b1 > 31) ) - { - DecodePlanarAlpha( d, alpha, dst, w ); - return; - } - - br[0] = ( r0 << 3 ) | ( r0 >> 2 ); - br[1] = ( r1 << 3 ) | ( r1 >> 2 ); - bg[0] = ( g0 << 3 ) | ( g0 >> 2 ); - bg[1] = ( g1 << 3 ) | ( g1 >> 2 ); - bb[0] = ( b0 << 3 ) | ( b0 >> 2 ); - bb[1] = ( b1 << 3 ) | ( b1 >> 2 ); - } - else - { - br[0] = ( ( d & 0xF0000000 ) >> 24 ) | ( ( d & 0xF0000000 ) >> 28 ); - br[1] = ( ( d & 0x0F000000 ) >> 20 ) | ( ( d & 0x0F000000 ) >> 24 ); - bg[0] = ( ( d & 0x00F00000 ) >> 16 ) | ( ( d & 0x00F00000 ) >> 20 ); - bg[1] = ( ( d & 0x000F0000 ) >> 12 ) | ( ( d & 0x000F0000 ) >> 16 ); - bb[0] = ( ( d & 0x0000F000 ) >> 8 ) | ( ( d & 0x0000F000 ) >> 12 ); - bb[1] = ( ( d & 0x00000F00 ) >> 4 ) | ( ( d & 0x00000F00 ) >> 8 ); - } - - unsigned int tcw[2]; - tcw[0] = ( d & 0xE0 ) >> 5; - tcw[1] = ( d & 0x1C ) >> 2; - - uint32_t b1 = ( d >> 32 ) & 0xFFFF; - uint32_t b2 = ( d >> 48 ); - - b1 = ( b1 | ( b1 << 8 ) ) & 0x00FF00FF; - b1 = ( b1 | ( b1 << 4 ) ) & 0x0F0F0F0F; - b1 = ( b1 | ( b1 << 2 ) ) & 0x33333333; - b1 = ( b1 | ( b1 << 1 ) ) & 0x55555555; - - b2 = ( b2 | ( b2 << 8 ) ) & 0x00FF00FF; - b2 = ( b2 | ( b2 << 4 ) ) & 0x0F0F0F0F; - b2 = ( b2 | ( b2 << 2 ) ) & 0x33333333; - b2 = ( b2 | ( b2 << 1 ) ) & 0x55555555; - - uint32_t idx = b1 | ( b2 << 1 ); - - const int32_t base = alpha >> 56; - const int32_t mul = ( alpha >> 52 ) & 0xF; - const auto atbl = g_alpha[( alpha >> 48 ) & 0xF]; - - if( d & 0x1 ) - { - for( int i=0; i<4; i++ ) - { - for( int j=0; j<4; j++ ) - { - const auto mod = g_table[tcw[j/2]][idx & 0x3]; - const auto r = br[j/2] + mod; - const auto g = bg[j/2] + mod; - const auto b = bb[j/2] + mod; - const auto amod = atbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; - const uint32_t a = clampu8( base + amod * mul ); - if( ( ( r | g | b ) & ~0xFF ) == 0 ) - { - dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 ); - } - else - { - const auto rc = clampu8( r ); - const auto gc = clampu8( g ); - const auto bc = clampu8( b ); - dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 ); - } - idx >>= 2; - } - } - } - else - { - for( int i=0; i<4; i++ ) - { - const auto tbl = g_table[tcw[i/2]]; - const auto cr = br[i/2]; - const auto cg = bg[i/2]; - const auto cb = bb[i/2]; - - for( int j=0; j<4; j++ ) - { - const auto mod = tbl[idx & 0x3]; - const auto r = cr + mod; - const auto g = cg + mod; - const auto b = cb + mod; - const auto amod = atbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7]; - const uint32_t a = clampu8( base + amod * mul ); - if( ( ( r | g | b ) & ~0xFF ) == 0 ) - { - dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 ); - } - else - { - const auto rc = clampu8( r ); - const auto gc = clampu8( g ); - const auto bc = clampu8( b ); - dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 ); - } - idx >>= 2; - } - } - } -} - -static etcpak_force_inline void DecodeRPart( uint64_t r, uint32_t* dst, uint32_t w, bool isSigned = false ) -{ - r = _bswap64( r ); - - const int32_t base_byte = ( r >> 56 ); - int32_t base; - if (isSigned) { - int32_t signed_base = (int8_t)base_byte; - if (signed_base == -128) signed_base = -127; - base = signed_base * 8; - } else { - base = base_byte * 8 + 4; - } - const int32_t mul = ( r >> 52 ) & 0xF; - const auto atbl = g_alpha[( r >> 48 ) & 0xF]; - - for( int i=0; i<4; i++ ) - { - for ( int j=0; j<4; j++ ) - { - const auto amod = atbl[(r >> ( 45 - j*3 - i*12 )) & 0x7]; - const int32_t val = ( base + amod * g_alpha11Mul[mul] )/8; - const uint32_t rc = clampu8( isSigned ? val + 128 : val ); - dst[j*w+i] = rc | 0xFF000000; - } - } -} - -static etcpak_force_inline void DecodeRGPart( uint64_t r, uint64_t g, uint32_t* dst, uint32_t w, bool isSigned = false ) -{ - r = _bswap64( r ); - g = _bswap64( g ); - - const int32_t rbase_byte = ( r >> 56 ); - int32_t rbase; - if (isSigned) { - int32_t signed_rbase = (int8_t)rbase_byte; - if (signed_rbase == -128) signed_rbase = -127; - rbase = signed_rbase * 8; - } else { - rbase = rbase_byte * 8 + 4; - } - const int32_t rmul = ( r >> 52 ) & 0xF; - const auto rtbl = g_alpha[( r >> 48 ) & 0xF]; - - const int32_t gbase_byte = ( g >> 56 ); - int32_t gbase; - if (isSigned) { - int32_t signed_gbase = (int8_t)gbase_byte; - if (signed_gbase == -128) signed_gbase = -127; - gbase = signed_gbase * 8; - } else { - gbase = gbase_byte * 8 + 4; - } - const int32_t gmul = ( g >> 52 ) & 0xF; - const auto gtbl = g_alpha[( g >> 48 ) & 0xF]; - - for( int i=0; i<4; i++ ) - { - for( int j=0; j<4; j++ ) - { - const auto rmod = rtbl[(r >> ( 45 - j*3 - i*12 )) & 0x7]; - const int32_t rval = ( rbase + rmod * g_alpha11Mul[rmul] )/8; - const uint32_t rc = clampu8( isSigned ? rval + 128 : rval ); - - const auto gmod = gtbl[(g >> ( 45 - j*3 - i*12 )) & 0x7]; - const int32_t gval = ( gbase + gmod * g_alpha11Mul[gmul] )/8; - const uint32_t gc = clampu8( isSigned ? gval + 128 : gval ); - - dst[j*w+i] = rc | (gc << 8) | 0xFF000000; - } - } -} - -static etcpak_force_inline void DecodeBc1Part( uint64_t d, uint32_t* dst, uint32_t w ) -{ - uint8_t* in = (uint8_t*)&d; - uint16_t c0, c1; - uint32_t idx; - memcpy( &c0, in, 2 ); - memcpy( &c1, in+2, 2 ); - memcpy( &idx, in+4, 4 ); - - uint8_t r0 = ( ( c0 & 0xF800 ) >> 8 ) | ( ( c0 & 0xF800 ) >> 13 ); - uint8_t g0 = ( ( c0 & 0x07E0 ) >> 3 ) | ( ( c0 & 0x07E0 ) >> 9 ); - uint8_t b0 = ( ( c0 & 0x001F ) << 3 ) | ( ( c0 & 0x001F ) >> 2 ); - - uint8_t r1 = ( ( c1 & 0xF800 ) >> 8 ) | ( ( c1 & 0xF800 ) >> 13 ); - uint8_t g1 = ( ( c1 & 0x07E0 ) >> 3 ) | ( ( c1 & 0x07E0 ) >> 9 ); - uint8_t b1 = ( ( c1 & 0x001F ) << 3 ) | ( ( c1 & 0x001F ) >> 2 ); - - uint32_t dict[4]; - - dict[0] = 0xFF000000 | ( b0 << 16 ) | ( g0 << 8 ) | r0; - dict[1] = 0xFF000000 | ( b1 << 16 ) | ( g1 << 8 ) | r1; - - uint32_t r, g, b; - if( c0 > c1 ) - { - r = (2*r0+r1)/3; - g = (2*g0+g1)/3; - b = (2*b0+b1)/3; - dict[2] = 0xFF000000 | ( b << 16 ) | ( g << 8 ) | r; - r = (2*r1+r0)/3; - g = (2*g1+g0)/3; - b = (2*b1+b0)/3; - dict[3] = 0xFF000000 | ( b << 16 ) | ( g << 8 ) | r; - } - else - { - r = (int(r0)+r1)/2; - g = (int(g0)+g1)/2; - b = (int(b0)+b1)/2; - dict[2] = 0xFF000000 | ( b << 16 ) | ( g << 8 ) | r; - dict[3] = 0xFF000000; - } - - memcpy( dst+0, dict + (idx & 0x3), 4 ); - idx >>= 2; - memcpy( dst+1, dict + (idx & 0x3), 4 ); - idx >>= 2; - memcpy( dst+2, dict + (idx & 0x3), 4 ); - idx >>= 2; - memcpy( dst+3, dict + (idx & 0x3), 4 ); -} - -static etcpak_force_inline void DecodeBc3Part( uint64_t a, uint64_t d, uint32_t* dst, uint32_t w ) -{ - uint8_t* ain = (uint8_t*)&a; - uint8_t a0, a1; - uint64_t aidx = 0; - memcpy( &a0, ain, 1 ); - memcpy( &a1, ain+1, 1 ); - memcpy( &aidx, ain+2, 6 ); - - uint8_t* in = (uint8_t*)&d; - uint16_t c0, c1; - uint32_t idx; - memcpy( &c0, in, 2 ); - memcpy( &c1, in+2, 2 ); - memcpy( &idx, in+4, 4 ); - - uint32_t adict[8]; - adict[0] = a0 << 24; - adict[1] = a1 << 24; - if( a0 > a1 ) - { - adict[2] = ( (6*a0+1*a1)/7 ) << 24; - adict[3] = ( (5*a0+2*a1)/7 ) << 24; - adict[4] = ( (4*a0+3*a1)/7 ) << 24; - adict[5] = ( (3*a0+4*a1)/7 ) << 24; - adict[6] = ( (2*a0+5*a1)/7 ) << 24; - adict[7] = ( (1*a0+6*a1)/7 ) << 24; - } - else - { - adict[2] = ( (4*a0+1*a1)/5 ) << 24; - adict[3] = ( (3*a0+2*a1)/5 ) << 24; - adict[4] = ( (2*a0+3*a1)/5 ) << 24; - adict[5] = ( (1*a0+4*a1)/5 ) << 24; - adict[6] = 0; - adict[7] = 0xFF000000; - } - - uint8_t r0 = ( ( c0 & 0xF800 ) >> 8 ) | ( ( c0 & 0xF800 ) >> 13 ); - uint8_t g0 = ( ( c0 & 0x07E0 ) >> 3 ) | ( ( c0 & 0x07E0 ) >> 9 ); - uint8_t b0 = ( ( c0 & 0x001F ) << 3 ) | ( ( c0 & 0x001F ) >> 2 ); - - uint8_t r1 = ( ( c1 & 0xF800 ) >> 8 ) | ( ( c1 & 0xF800 ) >> 13 ); - uint8_t g1 = ( ( c1 & 0x07E0 ) >> 3 ) | ( ( c1 & 0x07E0 ) >> 9 ); - uint8_t b1 = ( ( c1 & 0x001F ) << 3 ) | ( ( c1 & 0x001F ) >> 2 ); - - uint32_t dict[4]; - - dict[0] = ( b0 << 16 ) | ( g0 << 8 ) | r0; - dict[1] = ( b1 << 16 ) | ( g1 << 8 ) | r1; - - uint32_t r, g, b; - if( c0 > c1 ) - { - r = (2*r0+r1)/3; - g = (2*g0+g1)/3; - b = (2*b0+b1)/3; - dict[2] = ( b << 16 ) | ( g << 8 ) | r; - r = (2*r1+r0)/3; - g = (2*g1+g0)/3; - b = (2*b1+b0)/3; - dict[3] = ( b << 16 ) | ( g << 8 ) | r; - } - else - { - r = (int(r0)+r1)/2; - g = (int(g0)+g1)/2; - b = (int(b0)+b1)/2; - dict[2] = ( b << 16 ) | ( g << 8 ) | r; - dict[3] = 0; - } - - dst[0] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[1] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[2] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[3] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst += w; - - dst[0] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[1] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[2] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[3] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst += w; - - dst[0] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[1] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[2] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[3] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst += w; - - dst[0] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[1] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[2] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; - dst[3] = dict[idx & 0x3] | adict[aidx & 0x7]; - idx >>= 2; - aidx >>= 3; -} - -static etcpak_force_inline void DecodeBc4Part( uint64_t a, uint32_t* dst, uint32_t w ) -{ - uint8_t* ain = (uint8_t*)&a; - uint8_t a0, a1; - uint64_t aidx = 0; - memcpy( &a0, ain, 1 ); - memcpy( &a1, ain+1, 1 ); - memcpy( &aidx, ain+2, 6 ); - - uint32_t adict[8]; - adict[0] = a0; - adict[1] = a1; - if(a0 > a1) - { - adict[2] = ( (6*a0+1*a1)/7 ); - adict[3] = ( (5*a0+2*a1)/7 ); - adict[4] = ( (4*a0+3*a1)/7 ); - adict[5] = ( (3*a0+4*a1)/7 ); - adict[6] = ( (2*a0+5*a1)/7 ); - adict[7] = ( (1*a0+6*a1)/7 ); - } - else - { - adict[2] = ( (4*a0+1*a1)/5 ); - adict[3] = ( (3*a0+2*a1)/5 ); - adict[4] = ( (2*a0+3*a1)/5 ); - adict[5] = ( (1*a0+4*a1)/5 ); - adict[6] = 0; - adict[7] = 0xFF; - } - - dst[0] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[1] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[2] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[3] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst += w; - - dst[0] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[1] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[2] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[3] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst += w; - - dst[0] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[1] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[2] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[3] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst += w; - - dst[0] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[1] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[2] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst[3] = adict[aidx & 0x7] | 0xFF000000; - aidx >>= 3; - dst += w; -} - -static etcpak_force_inline void DecodeBc5Part( uint64_t r, uint64_t g, uint32_t* dst, uint32_t w ) -{ - uint8_t* rin = (uint8_t*)&r; - uint8_t r0, r1; - uint64_t ridx = 0; - memcpy( &r0, rin, 1 ); - memcpy( &r1, rin+1, 1 ); - memcpy( &ridx, rin+2, 6 ); - - uint8_t* gin = (uint8_t*)&g; - uint8_t g0, g1; - uint64_t gidx = 0; - memcpy( &g0, gin, 1 ); - memcpy( &g1, gin+1, 1 ); - memcpy( &gidx, gin+2, 6 ); - - uint32_t rdict[8]; - rdict[0] = r0; - rdict[1] = r1; - if(r0 > r1) - { - rdict[2] = ( (6*r0+1*r1)/7 ); - rdict[3] = ( (5*r0+2*r1)/7 ); - rdict[4] = ( (4*r0+3*r1)/7 ); - rdict[5] = ( (3*r0+4*r1)/7 ); - rdict[6] = ( (2*r0+5*r1)/7 ); - rdict[7] = ( (1*r0+6*r1)/7 ); - } - else - { - rdict[2] = ( (4*r0+1*r1)/5 ); - rdict[3] = ( (3*r0+2*r1)/5 ); - rdict[4] = ( (2*r0+3*r1)/5 ); - rdict[5] = ( (1*r0+4*r1)/5 ); - rdict[6] = 0; - rdict[7] = 0xFF; - } - - uint32_t gdict[8]; - gdict[0] = g0 << 8; - gdict[1] = g1 << 8; - if(g0 > g1) - { - gdict[2] = ( (6*g0+1*g1)/7 ) << 8; - gdict[3] = ( (5*g0+2*g1)/7 ) << 8; - gdict[4] = ( (4*g0+3*g1)/7 ) << 8; - gdict[5] = ( (3*g0+4*g1)/7 ) << 8; - gdict[6] = ( (2*g0+5*g1)/7 ) << 8; - gdict[7] = ( (1*g0+6*g1)/7 ) << 8; - } - else - { - gdict[2] = ( (4*g0+1*g1)/5 ) << 8; - gdict[3] = ( (3*g0+2*g1)/5 ) << 8; - gdict[4] = ( (2*g0+3*g1)/5 ) << 8; - gdict[5] = ( (1*g0+4*g1)/5 ) << 8; - gdict[6] = 0; - gdict[7] = 0xFF00; - } - - dst[0] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[1] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[2] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[3] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst += w; - - dst[0] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[1] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[2] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[3] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst += w; - - dst[0] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[1] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[2] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; - dst[3] = rdict[ridx & 0x7] | gdict[gidx & 0x7] | 0xFF000000; - ridx >>= 3; - gidx >>= 3; -} - -} -void DecodeBc1(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height) -{ - for( int y=0; y - -// Public interface for decoding functions -etcpak_no_inline void DecodeBc1(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); -etcpak_no_inline void DecodeBc3(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); -etcpak_no_inline void DecodeBc4(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); -etcpak_no_inline void DecodeBc5(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); -etcpak_no_inline void DecodeBc7(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); -etcpak_no_inline void DecodeRGB(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); -etcpak_no_inline void DecodeRGBA(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height); -etcpak_no_inline void DecodeR(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height, bool isSigned = false); -etcpak_no_inline void DecodeRG(const uint64_t* src, uint32_t* dst, int32_t width, int32_t height, bool isSigned = false); - -#endif - diff --git a/lib/etcpak/etcpak/Error.cpp b/lib/etcpak/etcpak/Error.cpp deleted file mode 100644 index 014ecdab667..00000000000 --- a/lib/etcpak/etcpak/Error.cpp +++ /dev/null @@ -1,48 +0,0 @@ -#include - -#include "Error.hpp" -#include "Math.hpp" - -float CalcMSE3( const Bitmap& bmp, const Bitmap& out ) -{ - float err = 0; - - const uint32_t* p1 = bmp.Data(); - const uint32_t* p2 = out.Data(); - size_t cnt = bmp.Size().x * bmp.Size().y; - - for( size_t i=0; i> 8 ) - ( ( c2 & 0x0000FF00 ) >> 8 ) ); - err += sq( ( ( c1 & 0x00FF0000 ) >> 16 ) - ( ( c2 & 0x00FF0000 ) >> 16 ) ); - } - - err /= cnt * 3; - - return err; -} - -float CalcMSE1( const Bitmap& bmp, const Bitmap& out ) -{ - float err = 0; - - const uint32_t* p1 = bmp.Data(); - const uint32_t* p2 = out.Data(); - size_t cnt = bmp.Size().x * bmp.Size().y; - - for( size_t i=0; i> 24 ) - ( c2 & 0xFF ) ); - } - - err /= cnt; - - return err; -} diff --git a/lib/etcpak/etcpak/Error.hpp b/lib/etcpak/etcpak/Error.hpp deleted file mode 100644 index 9817754b741..00000000000 --- a/lib/etcpak/etcpak/Error.hpp +++ /dev/null @@ -1,9 +0,0 @@ -#ifndef __ERROR_HPP__ -#define __ERROR_HPP__ - -#include "Bitmap.hpp" - -float CalcMSE3( const Bitmap& bmp, const Bitmap& out ); -float CalcMSE1( const Bitmap& bmp, const Bitmap& out ); - -#endif diff --git a/lib/etcpak/etcpak/MipMap.hpp b/lib/etcpak/etcpak/MipMap.hpp deleted file mode 100644 index d3b4bc9e7cf..00000000000 --- a/lib/etcpak/etcpak/MipMap.hpp +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef __MIPMAP_HPP__ -#define __MIPMAP_HPP__ - -#include "Vector.hpp" - -inline int NumberOfMipLevels( const v2i& size ) -{ - return (int)floor( log2( std::max( size.x, size.y ) ) ) + 1; -} - -#endif diff --git a/lib/etcpak/etcpak/ProcessDxtc.cpp b/lib/etcpak/etcpak/ProcessDxtc.cpp deleted file mode 100644 index 23a3326a898..00000000000 --- a/lib/etcpak/etcpak/ProcessDxtc.cpp +++ /dev/null @@ -1,1120 +0,0 @@ -#include "bc7enc.h" -#include "Dither.hpp" -#include "ForceInline.hpp" -#include "ProcessDxtc.hpp" - -#include -#include -#include - -#ifdef __ARM_NEON -# include -#endif - -#if defined __AVX__ && !defined __SSE4_1__ -# define __SSE4_1__ -#endif - -#if defined __SSE4_1__ || defined __AVX2__ -# ifdef _MSC_VER -# include -# else -# include -# ifndef _mm256_cvtsi256_si32 -# define _mm256_cvtsi256_si32( v ) ( _mm_cvtsi128_si32( _mm256_castsi256_si128( v ) ) ) -# endif -# endif -#endif - - -static etcpak_force_inline uint16_t to565( uint8_t r, uint8_t g, uint8_t b ) -{ - return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( b >> 3 ); -} - -static etcpak_force_inline uint16_t to565( uint32_t c ) -{ - return - ( ( c & 0xF80000 ) >> 19 ) | - ( ( c & 0x00FC00 ) >> 5 ) | - ( ( c & 0x0000F8 ) << 8 ); -} - -static const uint8_t DxtcIndexTable[256] = { - 85, 87, 86, 84, 93, 95, 94, 92, 89, 91, 90, 88, 81, 83, 82, 80, - 117, 119, 118, 116, 125, 127, 126, 124, 121, 123, 122, 120, 113, 115, 114, 112, - 101, 103, 102, 100, 109, 111, 110, 108, 105, 107, 106, 104, 97, 99, 98, 96, - 69, 71, 70, 68, 77, 79, 78, 76, 73, 75, 74, 72, 65, 67, 66, 64, - 213, 215, 214, 212, 221, 223, 222, 220, 217, 219, 218, 216, 209, 211, 210, 208, - 245, 247, 246, 244, 253, 255, 254, 252, 249, 251, 250, 248, 241, 243, 242, 240, - 229, 231, 230, 228, 237, 239, 238, 236, 233, 235, 234, 232, 225, 227, 226, 224, - 197, 199, 198, 196, 205, 207, 206, 204, 201, 203, 202, 200, 193, 195, 194, 192, - 149, 151, 150, 148, 157, 159, 158, 156, 153, 155, 154, 152, 145, 147, 146, 144, - 181, 183, 182, 180, 189, 191, 190, 188, 185, 187, 186, 184, 177, 179, 178, 176, - 165, 167, 166, 164, 173, 175, 174, 172, 169, 171, 170, 168, 161, 163, 162, 160, - 133, 135, 134, 132, 141, 143, 142, 140, 137, 139, 138, 136, 129, 131, 130, 128, - 21, 23, 22, 20, 29, 31, 30, 28, 25, 27, 26, 24, 17, 19, 18, 16, - 53, 55, 54, 52, 61, 63, 62, 60, 57, 59, 58, 56, 49, 51, 50, 48, - 37, 39, 38, 36, 45, 47, 46, 44, 41, 43, 42, 40, 33, 35, 34, 32, - 5, 7, 6, 4, 13, 15, 14, 12, 9, 11, 10, 8, 1, 3, 2, 0 -}; - -static const uint8_t AlphaIndexTable_SSE[64] = { - 9, 15, 14, 13, 12, 11, 10, 8, 57, 63, 62, 61, 60, 59, 58, 56, - 49, 55, 54, 53, 52, 51, 50, 48, 41, 47, 46, 45, 44, 43, 42, 40, - 33, 39, 38, 37, 36, 35, 34, 32, 25, 31, 30, 29, 28, 27, 26, 24, - 17, 23, 22, 21, 20, 19, 18, 16, 1, 7, 6, 5, 4, 3, 2, 0, -}; - -static const uint16_t DivTable[255*3+1] = { - 0xffff, 0xffff, 0xffff, 0xffff, 0xcccc, 0xaaaa, 0x9249, 0x8000, 0x71c7, 0x6666, 0x5d17, 0x5555, 0x4ec4, 0x4924, 0x4444, 0x4000, - 0x3c3c, 0x38e3, 0x35e5, 0x3333, 0x30c3, 0x2e8b, 0x2c85, 0x2aaa, 0x28f5, 0x2762, 0x25ed, 0x2492, 0x234f, 0x2222, 0x2108, 0x2000, - 0x1f07, 0x1e1e, 0x1d41, 0x1c71, 0x1bac, 0x1af2, 0x1a41, 0x1999, 0x18f9, 0x1861, 0x17d0, 0x1745, 0x16c1, 0x1642, 0x15c9, 0x1555, - 0x14e5, 0x147a, 0x1414, 0x13b1, 0x1352, 0x12f6, 0x129e, 0x1249, 0x11f7, 0x11a7, 0x115b, 0x1111, 0x10c9, 0x1084, 0x1041, 0x1000, - 0x0fc0, 0x0f83, 0x0f48, 0x0f0f, 0x0ed7, 0x0ea0, 0x0e6c, 0x0e38, 0x0e07, 0x0dd6, 0x0da7, 0x0d79, 0x0d4c, 0x0d20, 0x0cf6, 0x0ccc, - 0x0ca4, 0x0c7c, 0x0c56, 0x0c30, 0x0c0c, 0x0be8, 0x0bc5, 0x0ba2, 0x0b81, 0x0b60, 0x0b40, 0x0b21, 0x0b02, 0x0ae4, 0x0ac7, 0x0aaa, - 0x0a8e, 0x0a72, 0x0a57, 0x0a3d, 0x0a23, 0x0a0a, 0x09f1, 0x09d8, 0x09c0, 0x09a9, 0x0991, 0x097b, 0x0964, 0x094f, 0x0939, 0x0924, - 0x090f, 0x08fb, 0x08e7, 0x08d3, 0x08c0, 0x08ad, 0x089a, 0x0888, 0x0876, 0x0864, 0x0853, 0x0842, 0x0831, 0x0820, 0x0810, 0x0800, - 0x07f0, 0x07e0, 0x07d1, 0x07c1, 0x07b3, 0x07a4, 0x0795, 0x0787, 0x0779, 0x076b, 0x075d, 0x0750, 0x0743, 0x0736, 0x0729, 0x071c, - 0x070f, 0x0703, 0x06f7, 0x06eb, 0x06df, 0x06d3, 0x06c8, 0x06bc, 0x06b1, 0x06a6, 0x069b, 0x0690, 0x0685, 0x067b, 0x0670, 0x0666, - 0x065c, 0x0652, 0x0648, 0x063e, 0x0634, 0x062b, 0x0621, 0x0618, 0x060f, 0x0606, 0x05fd, 0x05f4, 0x05eb, 0x05e2, 0x05d9, 0x05d1, - 0x05c9, 0x05c0, 0x05b8, 0x05b0, 0x05a8, 0x05a0, 0x0598, 0x0590, 0x0588, 0x0581, 0x0579, 0x0572, 0x056b, 0x0563, 0x055c, 0x0555, - 0x054e, 0x0547, 0x0540, 0x0539, 0x0532, 0x052b, 0x0525, 0x051e, 0x0518, 0x0511, 0x050b, 0x0505, 0x04fe, 0x04f8, 0x04f2, 0x04ec, - 0x04e6, 0x04e0, 0x04da, 0x04d4, 0x04ce, 0x04c8, 0x04c3, 0x04bd, 0x04b8, 0x04b2, 0x04ad, 0x04a7, 0x04a2, 0x049c, 0x0497, 0x0492, - 0x048d, 0x0487, 0x0482, 0x047d, 0x0478, 0x0473, 0x046e, 0x0469, 0x0465, 0x0460, 0x045b, 0x0456, 0x0452, 0x044d, 0x0448, 0x0444, - 0x043f, 0x043b, 0x0436, 0x0432, 0x042d, 0x0429, 0x0425, 0x0421, 0x041c, 0x0418, 0x0414, 0x0410, 0x040c, 0x0408, 0x0404, 0x0400, - 0x03fc, 0x03f8, 0x03f4, 0x03f0, 0x03ec, 0x03e8, 0x03e4, 0x03e0, 0x03dd, 0x03d9, 0x03d5, 0x03d2, 0x03ce, 0x03ca, 0x03c7, 0x03c3, - 0x03c0, 0x03bc, 0x03b9, 0x03b5, 0x03b2, 0x03ae, 0x03ab, 0x03a8, 0x03a4, 0x03a1, 0x039e, 0x039b, 0x0397, 0x0394, 0x0391, 0x038e, - 0x038b, 0x0387, 0x0384, 0x0381, 0x037e, 0x037b, 0x0378, 0x0375, 0x0372, 0x036f, 0x036c, 0x0369, 0x0366, 0x0364, 0x0361, 0x035e, - 0x035b, 0x0358, 0x0355, 0x0353, 0x0350, 0x034d, 0x034a, 0x0348, 0x0345, 0x0342, 0x0340, 0x033d, 0x033a, 0x0338, 0x0335, 0x0333, - 0x0330, 0x032e, 0x032b, 0x0329, 0x0326, 0x0324, 0x0321, 0x031f, 0x031c, 0x031a, 0x0317, 0x0315, 0x0313, 0x0310, 0x030e, 0x030c, - 0x0309, 0x0307, 0x0305, 0x0303, 0x0300, 0x02fe, 0x02fc, 0x02fa, 0x02f7, 0x02f5, 0x02f3, 0x02f1, 0x02ef, 0x02ec, 0x02ea, 0x02e8, - 0x02e6, 0x02e4, 0x02e2, 0x02e0, 0x02de, 0x02dc, 0x02da, 0x02d8, 0x02d6, 0x02d4, 0x02d2, 0x02d0, 0x02ce, 0x02cc, 0x02ca, 0x02c8, - 0x02c6, 0x02c4, 0x02c2, 0x02c0, 0x02be, 0x02bc, 0x02bb, 0x02b9, 0x02b7, 0x02b5, 0x02b3, 0x02b1, 0x02b0, 0x02ae, 0x02ac, 0x02aa, - 0x02a8, 0x02a7, 0x02a5, 0x02a3, 0x02a1, 0x02a0, 0x029e, 0x029c, 0x029b, 0x0299, 0x0297, 0x0295, 0x0294, 0x0292, 0x0291, 0x028f, - 0x028d, 0x028c, 0x028a, 0x0288, 0x0287, 0x0285, 0x0284, 0x0282, 0x0280, 0x027f, 0x027d, 0x027c, 0x027a, 0x0279, 0x0277, 0x0276, - 0x0274, 0x0273, 0x0271, 0x0270, 0x026e, 0x026d, 0x026b, 0x026a, 0x0268, 0x0267, 0x0265, 0x0264, 0x0263, 0x0261, 0x0260, 0x025e, - 0x025d, 0x025c, 0x025a, 0x0259, 0x0257, 0x0256, 0x0255, 0x0253, 0x0252, 0x0251, 0x024f, 0x024e, 0x024d, 0x024b, 0x024a, 0x0249, - 0x0247, 0x0246, 0x0245, 0x0243, 0x0242, 0x0241, 0x0240, 0x023e, 0x023d, 0x023c, 0x023b, 0x0239, 0x0238, 0x0237, 0x0236, 0x0234, - 0x0233, 0x0232, 0x0231, 0x0230, 0x022e, 0x022d, 0x022c, 0x022b, 0x022a, 0x0229, 0x0227, 0x0226, 0x0225, 0x0224, 0x0223, 0x0222, - 0x0220, 0x021f, 0x021e, 0x021d, 0x021c, 0x021b, 0x021a, 0x0219, 0x0218, 0x0216, 0x0215, 0x0214, 0x0213, 0x0212, 0x0211, 0x0210, - 0x020f, 0x020e, 0x020d, 0x020c, 0x020b, 0x020a, 0x0209, 0x0208, 0x0207, 0x0206, 0x0205, 0x0204, 0x0203, 0x0202, 0x0201, 0x0200, - 0x01ff, 0x01fe, 0x01fd, 0x01fc, 0x01fb, 0x01fa, 0x01f9, 0x01f8, 0x01f7, 0x01f6, 0x01f5, 0x01f4, 0x01f3, 0x01f2, 0x01f1, 0x01f0, - 0x01ef, 0x01ee, 0x01ed, 0x01ec, 0x01eb, 0x01ea, 0x01e9, 0x01e9, 0x01e8, 0x01e7, 0x01e6, 0x01e5, 0x01e4, 0x01e3, 0x01e2, 0x01e1, - 0x01e0, 0x01e0, 0x01df, 0x01de, 0x01dd, 0x01dc, 0x01db, 0x01da, 0x01da, 0x01d9, 0x01d8, 0x01d7, 0x01d6, 0x01d5, 0x01d4, 0x01d4, - 0x01d3, 0x01d2, 0x01d1, 0x01d0, 0x01cf, 0x01cf, 0x01ce, 0x01cd, 0x01cc, 0x01cb, 0x01cb, 0x01ca, 0x01c9, 0x01c8, 0x01c7, 0x01c7, - 0x01c6, 0x01c5, 0x01c4, 0x01c3, 0x01c3, 0x01c2, 0x01c1, 0x01c0, 0x01c0, 0x01bf, 0x01be, 0x01bd, 0x01bd, 0x01bc, 0x01bb, 0x01ba, - 0x01ba, 0x01b9, 0x01b8, 0x01b7, 0x01b7, 0x01b6, 0x01b5, 0x01b4, 0x01b4, 0x01b3, 0x01b2, 0x01b2, 0x01b1, 0x01b0, 0x01af, 0x01af, - 0x01ae, 0x01ad, 0x01ad, 0x01ac, 0x01ab, 0x01aa, 0x01aa, 0x01a9, 0x01a8, 0x01a8, 0x01a7, 0x01a6, 0x01a6, 0x01a5, 0x01a4, 0x01a4, - 0x01a3, 0x01a2, 0x01a2, 0x01a1, 0x01a0, 0x01a0, 0x019f, 0x019e, 0x019e, 0x019d, 0x019c, 0x019c, 0x019b, 0x019a, 0x019a, 0x0199, - 0x0198, 0x0198, 0x0197, 0x0197, 0x0196, 0x0195, 0x0195, 0x0194, 0x0193, 0x0193, 0x0192, 0x0192, 0x0191, 0x0190, 0x0190, 0x018f, - 0x018f, 0x018e, 0x018d, 0x018d, 0x018c, 0x018b, 0x018b, 0x018a, 0x018a, 0x0189, 0x0189, 0x0188, 0x0187, 0x0187, 0x0186, 0x0186, - 0x0185, 0x0184, 0x0184, 0x0183, 0x0183, 0x0182, 0x0182, 0x0181, 0x0180, 0x0180, 0x017f, 0x017f, 0x017e, 0x017e, 0x017d, 0x017d, - 0x017c, 0x017b, 0x017b, 0x017a, 0x017a, 0x0179, 0x0179, 0x0178, 0x0178, 0x0177, 0x0177, 0x0176, 0x0175, 0x0175, 0x0174, 0x0174, - 0x0173, 0x0173, 0x0172, 0x0172, 0x0171, 0x0171, 0x0170, 0x0170, 0x016f, 0x016f, 0x016e, 0x016e, 0x016d, 0x016d, 0x016c, 0x016c, - 0x016b, 0x016b, 0x016a, 0x016a, 0x0169, 0x0169, 0x0168, 0x0168, 0x0167, 0x0167, 0x0166, 0x0166, 0x0165, 0x0165, 0x0164, 0x0164, - 0x0163, 0x0163, 0x0162, 0x0162, 0x0161, 0x0161, 0x0160, 0x0160, 0x015f, 0x015f, 0x015e, 0x015e, 0x015d, 0x015d, 0x015d, 0x015c, - 0x015c, 0x015b, 0x015b, 0x015a, 0x015a, 0x0159, 0x0159, 0x0158, 0x0158, 0x0158, 0x0157, 0x0157, 0x0156, 0x0156 -}; -static const uint16_t DivTableNEON[255*3+1] = { - 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - 0x0000, 0x1c71, 0x1af2, 0x1999, 0x1861, 0x1745, 0x1642, 0x1555, 0x147a, 0x13b1, 0x12f6, 0x1249, 0x11a7, 0x1111, 0x1084, 0x1000, - 0x0f83, 0x0f0f, 0x0ea0, 0x0e38, 0x0dd6, 0x0d79, 0x0d20, 0x0ccc, 0x0c7c, 0x0c30, 0x0be8, 0x0ba2, 0x0b60, 0x0b21, 0x0ae4, 0x0aaa, - 0x0a72, 0x0a3d, 0x0a0a, 0x09d8, 0x09a9, 0x097b, 0x094f, 0x0924, 0x08fb, 0x08d3, 0x08ad, 0x0888, 0x0864, 0x0842, 0x0820, 0x0800, - 0x07e0, 0x07c1, 0x07a4, 0x0787, 0x076b, 0x0750, 0x0736, 0x071c, 0x0703, 0x06eb, 0x06d3, 0x06bc, 0x06a6, 0x0690, 0x067b, 0x0666, - 0x0652, 0x063e, 0x062b, 0x0618, 0x0606, 0x05f4, 0x05e2, 0x05d1, 0x05c0, 0x05b0, 0x05a0, 0x0590, 0x0581, 0x0572, 0x0563, 0x0555, - 0x0547, 0x0539, 0x052b, 0x051e, 0x0511, 0x0505, 0x04f8, 0x04ec, 0x04e0, 0x04d4, 0x04c8, 0x04bd, 0x04b2, 0x04a7, 0x049c, 0x0492, - 0x0487, 0x047d, 0x0473, 0x0469, 0x0460, 0x0456, 0x044d, 0x0444, 0x043b, 0x0432, 0x0429, 0x0421, 0x0418, 0x0410, 0x0408, 0x0400, - 0x03f8, 0x03f0, 0x03e8, 0x03e0, 0x03d9, 0x03d2, 0x03ca, 0x03c3, 0x03bc, 0x03b5, 0x03ae, 0x03a8, 0x03a1, 0x039b, 0x0394, 0x038e, - 0x0387, 0x0381, 0x037b, 0x0375, 0x036f, 0x0369, 0x0364, 0x035e, 0x0358, 0x0353, 0x034d, 0x0348, 0x0342, 0x033d, 0x0338, 0x0333, - 0x032e, 0x0329, 0x0324, 0x031f, 0x031a, 0x0315, 0x0310, 0x030c, 0x0307, 0x0303, 0x02fe, 0x02fa, 0x02f5, 0x02f1, 0x02ec, 0x02e8, - 0x02e4, 0x02e0, 0x02dc, 0x02d8, 0x02d4, 0x02d0, 0x02cc, 0x02c8, 0x02c4, 0x02c0, 0x02bc, 0x02b9, 0x02b5, 0x02b1, 0x02ae, 0x02aa, - 0x02a7, 0x02a3, 0x02a0, 0x029c, 0x0299, 0x0295, 0x0292, 0x028f, 0x028c, 0x0288, 0x0285, 0x0282, 0x027f, 0x027c, 0x0279, 0x0276, - 0x0273, 0x0270, 0x026d, 0x026a, 0x0267, 0x0264, 0x0261, 0x025e, 0x025c, 0x0259, 0x0256, 0x0253, 0x0251, 0x024e, 0x024b, 0x0249, - 0x0246, 0x0243, 0x0241, 0x023e, 0x023c, 0x0239, 0x0237, 0x0234, 0x0232, 0x0230, 0x022d, 0x022b, 0x0229, 0x0226, 0x0224, 0x0222, - 0x021f, 0x021d, 0x021b, 0x0219, 0x0216, 0x0214, 0x0212, 0x0210, 0x020e, 0x020c, 0x020a, 0x0208, 0x0206, 0x0204, 0x0202, 0x0200, - 0x01fe, 0x01fc, 0x01fa, 0x01f8, 0x01f6, 0x01f4, 0x01f2, 0x01f0, 0x01ee, 0x01ec, 0x01ea, 0x01e9, 0x01e7, 0x01e5, 0x01e3, 0x01e1, - 0x01e0, 0x01de, 0x01dc, 0x01da, 0x01d9, 0x01d7, 0x01d5, 0x01d4, 0x01d2, 0x01d0, 0x01cf, 0x01cd, 0x01cb, 0x01ca, 0x01c8, 0x01c7, - 0x01c5, 0x01c3, 0x01c2, 0x01c0, 0x01bf, 0x01bd, 0x01bc, 0x01ba, 0x01b9, 0x01b7, 0x01b6, 0x01b4, 0x01b3, 0x01b2, 0x01b0, 0x01af, - 0x01ad, 0x01ac, 0x01aa, 0x01a9, 0x01a8, 0x01a6, 0x01a5, 0x01a4, 0x01a2, 0x01a1, 0x01a0, 0x019e, 0x019d, 0x019c, 0x019a, 0x0199, - 0x0198, 0x0197, 0x0195, 0x0194, 0x0193, 0x0192, 0x0190, 0x018f, 0x018e, 0x018d, 0x018b, 0x018a, 0x0189, 0x0188, 0x0187, 0x0186, - 0x0184, 0x0183, 0x0182, 0x0181, 0x0180, 0x017f, 0x017e, 0x017d, 0x017b, 0x017a, 0x0179, 0x0178, 0x0177, 0x0176, 0x0175, 0x0174, - 0x0173, 0x0172, 0x0171, 0x0170, 0x016f, 0x016e, 0x016d, 0x016c, 0x016b, 0x016a, 0x0169, 0x0168, 0x0167, 0x0166, 0x0165, 0x0164, - 0x0163, 0x0162, 0x0161, 0x0160, 0x015f, 0x015e, 0x015d, 0x015c, 0x015b, 0x015a, 0x0159, 0x0158, 0x0158, 0x0157, 0x0156, 0x0155, - 0x0154, 0x0153, 0x0152, 0x0151, 0x0150, 0x0150, 0x014f, 0x014e, 0x014d, 0x014c, 0x014b, 0x014a, 0x014a, 0x0149, 0x0148, 0x0147, - 0x0146, 0x0146, 0x0145, 0x0144, 0x0143, 0x0142, 0x0142, 0x0141, 0x0140, 0x013f, 0x013e, 0x013e, 0x013d, 0x013c, 0x013b, 0x013b, - 0x013a, 0x0139, 0x0138, 0x0138, 0x0137, 0x0136, 0x0135, 0x0135, 0x0134, 0x0133, 0x0132, 0x0132, 0x0131, 0x0130, 0x0130, 0x012f, - 0x012e, 0x012e, 0x012d, 0x012c, 0x012b, 0x012b, 0x012a, 0x0129, 0x0129, 0x0128, 0x0127, 0x0127, 0x0126, 0x0125, 0x0125, 0x0124, - 0x0123, 0x0123, 0x0122, 0x0121, 0x0121, 0x0120, 0x0120, 0x011f, 0x011e, 0x011e, 0x011d, 0x011c, 0x011c, 0x011b, 0x011b, 0x011a, - 0x0119, 0x0119, 0x0118, 0x0118, 0x0117, 0x0116, 0x0116, 0x0115, 0x0115, 0x0114, 0x0113, 0x0113, 0x0112, 0x0112, 0x0111, 0x0111, - 0x0110, 0x010f, 0x010f, 0x010e, 0x010e, 0x010d, 0x010d, 0x010c, 0x010c, 0x010b, 0x010a, 0x010a, 0x0109, 0x0109, 0x0108, 0x0108, - 0x0107, 0x0107, 0x0106, 0x0106, 0x0105, 0x0105, 0x0104, 0x0104, 0x0103, 0x0103, 0x0102, 0x0102, 0x0101, 0x0101, 0x0100, 0x0100, - 0x00ff, 0x00ff, 0x00fe, 0x00fe, 0x00fd, 0x00fd, 0x00fc, 0x00fc, 0x00fb, 0x00fb, 0x00fa, 0x00fa, 0x00f9, 0x00f9, 0x00f8, 0x00f8, - 0x00f7, 0x00f7, 0x00f6, 0x00f6, 0x00f5, 0x00f5, 0x00f4, 0x00f4, 0x00f4, 0x00f3, 0x00f3, 0x00f2, 0x00f2, 0x00f1, 0x00f1, 0x00f0, - 0x00f0, 0x00f0, 0x00ef, 0x00ef, 0x00ee, 0x00ee, 0x00ed, 0x00ed, 0x00ed, 0x00ec, 0x00ec, 0x00eb, 0x00eb, 0x00ea, 0x00ea, 0x00ea, - 0x00e9, 0x00e9, 0x00e8, 0x00e8, 0x00e7, 0x00e7, 0x00e7, 0x00e6, 0x00e6, 0x00e5, 0x00e5, 0x00e5, 0x00e4, 0x00e4, 0x00e3, 0x00e3, - 0x00e3, 0x00e2, 0x00e2, 0x00e1, 0x00e1, 0x00e1, 0x00e0, 0x00e0, 0x00e0, 0x00df, 0x00df, 0x00de, 0x00de, 0x00de, 0x00dd, 0x00dd, - 0x00dd, 0x00dc, 0x00dc, 0x00db, 0x00db, 0x00db, 0x00da, 0x00da, 0x00da, 0x00d9, 0x00d9, 0x00d9, 0x00d8, 0x00d8, 0x00d7, 0x00d7, - 0x00d7, 0x00d6, 0x00d6, 0x00d6, 0x00d5, 0x00d5, 0x00d5, 0x00d4, 0x00d4, 0x00d4, 0x00d3, 0x00d3, 0x00d3, 0x00d2, 0x00d2, 0x00d2, - 0x00d1, 0x00d1, 0x00d1, 0x00d0, 0x00d0, 0x00d0, 0x00cf, 0x00cf, 0x00cf, 0x00ce, 0x00ce, 0x00ce, 0x00cd, 0x00cd, 0x00cd, 0x00cc, - 0x00cc, 0x00cc, 0x00cb, 0x00cb, 0x00cb, 0x00ca, 0x00ca, 0x00ca, 0x00c9, 0x00c9, 0x00c9, 0x00c9, 0x00c8, 0x00c8, 0x00c8, 0x00c7, - 0x00c7, 0x00c7, 0x00c6, 0x00c6, 0x00c6, 0x00c5, 0x00c5, 0x00c5, 0x00c5, 0x00c4, 0x00c4, 0x00c4, 0x00c3, 0x00c3, 0x00c3, 0x00c3, - 0x00c2, 0x00c2, 0x00c2, 0x00c1, 0x00c1, 0x00c1, 0x00c1, 0x00c0, 0x00c0, 0x00c0, 0x00bf, 0x00bf, 0x00bf, 0x00bf, 0x00be, 0x00be, - 0x00be, 0x00bd, 0x00bd, 0x00bd, 0x00bd, 0x00bc, 0x00bc, 0x00bc, 0x00bc, 0x00bb, 0x00bb, 0x00bb, 0x00ba, 0x00ba, 0x00ba, 0x00ba, - 0x00b9, 0x00b9, 0x00b9, 0x00b9, 0x00b8, 0x00b8, 0x00b8, 0x00b8, 0x00b7, 0x00b7, 0x00b7, 0x00b7, 0x00b6, 0x00b6, 0x00b6, 0x00b6, - 0x00b5, 0x00b5, 0x00b5, 0x00b5, 0x00b4, 0x00b4, 0x00b4, 0x00b4, 0x00b3, 0x00b3, 0x00b3, 0x00b3, 0x00b2, 0x00b2, 0x00b2, 0x00b2, - 0x00b1, 0x00b1, 0x00b1, 0x00b1, 0x00b0, 0x00b0, 0x00b0, 0x00b0, 0x00af, 0x00af, 0x00af, 0x00af, 0x00ae, 0x00ae, 0x00ae, 0x00ae, - 0x00ae, 0x00ad, 0x00ad, 0x00ad, 0x00ad, 0x00ac, 0x00ac, 0x00ac, 0x00ac, 0x00ac, 0x00ab, 0x00ab, 0x00ab, 0x00ab, -}; - -static const uint16_t DivTableAlpha[256] = { - 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xe38e, 0xcccc, 0xba2e, 0xaaaa, 0x9d89, 0x9249, 0x8888, 0x8000, - 0x7878, 0x71c7, 0x6bca, 0x6666, 0x6186, 0x5d17, 0x590b, 0x5555, 0x51eb, 0x4ec4, 0x4bda, 0x4924, 0x469e, 0x4444, 0x4210, 0x4000, - 0x3e0f, 0x3c3c, 0x3a83, 0x38e3, 0x3759, 0x35e5, 0x3483, 0x3333, 0x31f3, 0x30c3, 0x2fa0, 0x2e8b, 0x2d82, 0x2c85, 0x2b93, 0x2aaa, - 0x29cb, 0x28f5, 0x2828, 0x2762, 0x26a4, 0x25ed, 0x253c, 0x2492, 0x23ee, 0x234f, 0x22b6, 0x2222, 0x2192, 0x2108, 0x2082, 0x2000, - 0x1f81, 0x1f07, 0x1e91, 0x1e1e, 0x1dae, 0x1d41, 0x1cd8, 0x1c71, 0x1c0e, 0x1bac, 0x1b4e, 0x1af2, 0x1a98, 0x1a41, 0x19ec, 0x1999, - 0x1948, 0x18f9, 0x18ac, 0x1861, 0x1818, 0x17d0, 0x178a, 0x1745, 0x1702, 0x16c1, 0x1681, 0x1642, 0x1605, 0x15c9, 0x158e, 0x1555, - 0x151d, 0x14e5, 0x14af, 0x147a, 0x1446, 0x1414, 0x13e2, 0x13b1, 0x1381, 0x1352, 0x1323, 0x12f6, 0x12c9, 0x129e, 0x1273, 0x1249, - 0x121f, 0x11f7, 0x11cf, 0x11a7, 0x1181, 0x115b, 0x1135, 0x1111, 0x10ec, 0x10c9, 0x10a6, 0x1084, 0x1062, 0x1041, 0x1020, 0x1000, - 0x0fe0, 0x0fc0, 0x0fa2, 0x0f83, 0x0f66, 0x0f48, 0x0f2b, 0x0f0f, 0x0ef2, 0x0ed7, 0x0ebb, 0x0ea0, 0x0e86, 0x0e6c, 0x0e52, 0x0e38, - 0x0e1f, 0x0e07, 0x0dee, 0x0dd6, 0x0dbe, 0x0da7, 0x0d90, 0x0d79, 0x0d62, 0x0d4c, 0x0d36, 0x0d20, 0x0d0b, 0x0cf6, 0x0ce1, 0x0ccc, - 0x0cb8, 0x0ca4, 0x0c90, 0x0c7c, 0x0c69, 0x0c56, 0x0c43, 0x0c30, 0x0c1e, 0x0c0c, 0x0bfa, 0x0be8, 0x0bd6, 0x0bc5, 0x0bb3, 0x0ba2, - 0x0b92, 0x0b81, 0x0b70, 0x0b60, 0x0b50, 0x0b40, 0x0b30, 0x0b21, 0x0b11, 0x0b02, 0x0af3, 0x0ae4, 0x0ad6, 0x0ac7, 0x0ab8, 0x0aaa, - 0x0a9c, 0x0a8e, 0x0a80, 0x0a72, 0x0a65, 0x0a57, 0x0a4a, 0x0a3d, 0x0a30, 0x0a23, 0x0a16, 0x0a0a, 0x09fd, 0x09f1, 0x09e4, 0x09d8, - 0x09cc, 0x09c0, 0x09b4, 0x09a9, 0x099d, 0x0991, 0x0986, 0x097b, 0x0970, 0x0964, 0x095a, 0x094f, 0x0944, 0x0939, 0x092f, 0x0924, - 0x091a, 0x090f, 0x0905, 0x08fb, 0x08f1, 0x08e7, 0x08dd, 0x08d3, 0x08ca, 0x08c0, 0x08b7, 0x08ad, 0x08a4, 0x089a, 0x0891, 0x0888, - 0x087f, 0x0876, 0x086d, 0x0864, 0x085b, 0x0853, 0x084a, 0x0842, 0x0839, 0x0831, 0x0828, 0x0820, 0x0818, 0x0810, 0x0808, 0x0800, -}; - -static etcpak_force_inline uint64_t ProcessRGB( const uint8_t* src ) -{ -#ifdef __SSE4_1__ - __m128i px0 = _mm_loadu_si128(((__m128i*)src) + 0); - __m128i px1 = _mm_loadu_si128(((__m128i*)src) + 1); - __m128i px2 = _mm_loadu_si128(((__m128i*)src) + 2); - __m128i px3 = _mm_loadu_si128(((__m128i*)src) + 3); - - __m128i smask = _mm_set1_epi32( 0xF8FCF8 ); - __m128i sd0 = _mm_and_si128( px0, smask ); - __m128i sd1 = _mm_and_si128( px1, smask ); - __m128i sd2 = _mm_and_si128( px2, smask ); - __m128i sd3 = _mm_and_si128( px3, smask ); - - __m128i sc = _mm_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); - - __m128i sc0 = _mm_cmpeq_epi8(sd0, sc); - __m128i sc1 = _mm_cmpeq_epi8(sd1, sc); - __m128i sc2 = _mm_cmpeq_epi8(sd2, sc); - __m128i sc3 = _mm_cmpeq_epi8(sd3, sc); - - __m128i sm0 = _mm_and_si128(sc0, sc1); - __m128i sm1 = _mm_and_si128(sc2, sc3); - __m128i sm = _mm_and_si128(sm0, sm1); - - if( _mm_testc_si128(sm, _mm_set1_epi32(-1)) ) - { - uint32_t c; - memcpy( &c, src, 4 ); - return uint64_t( to565( c ) ) << 16; - } - - __m128i min0 = _mm_min_epu8( px0, px1 ); - __m128i min1 = _mm_min_epu8( px2, px3 ); - __m128i min2 = _mm_min_epu8( min0, min1 ); - - __m128i max0 = _mm_max_epu8( px0, px1 ); - __m128i max1 = _mm_max_epu8( px2, px3 ); - __m128i max2 = _mm_max_epu8( max0, max1 ); - - __m128i min3 = _mm_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); - __m128i max3 = _mm_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); - __m128i min4 = _mm_min_epu8( min2, min3 ); - __m128i max4 = _mm_max_epu8( max2, max3 ); - - __m128i min5 = _mm_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); - __m128i max5 = _mm_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); - __m128i rmin = _mm_min_epu8( min4, min5 ); - __m128i rmax = _mm_max_epu8( max4, max5 ); - - __m128i range1 = _mm_subs_epu8( rmax, rmin ); - __m128i range2 = _mm_sad_epu8( rmax, rmin ); - - uint32_t vrange = _mm_cvtsi128_si32( range2 ) >> 1; - __m128i range = _mm_set1_epi16( DivTable[vrange] ); - - __m128i inset1 = _mm_srli_epi16( range1, 4 ); - __m128i inset = _mm_and_si128( inset1, _mm_set1_epi8( 0xF ) ); - __m128i min = _mm_adds_epu8( rmin, inset ); - __m128i max = _mm_subs_epu8( rmax, inset ); - - __m128i c0 = _mm_subs_epu8( px0, rmin ); - __m128i c1 = _mm_subs_epu8( px1, rmin ); - __m128i c2 = _mm_subs_epu8( px2, rmin ); - __m128i c3 = _mm_subs_epu8( px3, rmin ); - - __m128i is0 = _mm_maddubs_epi16( c0, _mm_set1_epi8( 1 ) ); - __m128i is1 = _mm_maddubs_epi16( c1, _mm_set1_epi8( 1 ) ); - __m128i is2 = _mm_maddubs_epi16( c2, _mm_set1_epi8( 1 ) ); - __m128i is3 = _mm_maddubs_epi16( c3, _mm_set1_epi8( 1 ) ); - - __m128i s0 = _mm_hadd_epi16( is0, is1 ); - __m128i s1 = _mm_hadd_epi16( is2, is3 ); - - __m128i m0 = _mm_mulhi_epu16( s0, range ); - __m128i m1 = _mm_mulhi_epu16( s1, range ); - - __m128i p0 = _mm_packus_epi16( m0, m1 ); - - __m128i p1 = _mm_or_si128( _mm_srai_epi32( p0, 6 ), _mm_srai_epi32( p0, 12 ) ); - __m128i p2 = _mm_or_si128( _mm_srai_epi32( p0, 18 ), p0 ); - __m128i p3 = _mm_or_si128( p1, p2 ); - __m128i p =_mm_shuffle_epi8( p3, _mm_set1_epi32( 0x0C080400 ) ); - - uint32_t vmin = _mm_cvtsi128_si32( min ); - uint32_t vmax = _mm_cvtsi128_si32( max ); - uint32_t vp = _mm_cvtsi128_si32( p ); - - return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); -#elif defined __ARM_NEON -# ifdef __aarch64__ - uint8x16x4_t px = vld4q_u8( src ); - - uint8x16_t lr = px.val[0]; - uint8x16_t lg = px.val[1]; - uint8x16_t lb = px.val[2]; - - uint8_t rmaxr = vmaxvq_u8( lr ); - uint8_t rmaxg = vmaxvq_u8( lg ); - uint8_t rmaxb = vmaxvq_u8( lb ); - - uint8_t rminr = vminvq_u8( lr ); - uint8_t rming = vminvq_u8( lg ); - uint8_t rminb = vminvq_u8( lb ); - - int rr = rmaxr - rminr; - int rg = rmaxg - rming; - int rb = rmaxb - rminb; - - int vrange1 = rr + rg + rb; - uint16_t vrange2 = DivTableNEON[vrange1]; - - uint8_t insetr = rr >> 4; - uint8_t insetg = rg >> 4; - uint8_t insetb = rb >> 4; - - uint8_t minr = rminr + insetr; - uint8_t ming = rming + insetg; - uint8_t minb = rminb + insetb; - - uint8_t maxr = rmaxr - insetr; - uint8_t maxg = rmaxg - insetg; - uint8_t maxb = rmaxb - insetb; - - uint8x16_t cr = vsubq_u8( lr, vdupq_n_u8( rminr ) ); - uint8x16_t cg = vsubq_u8( lg, vdupq_n_u8( rming ) ); - uint8x16_t cb = vsubq_u8( lb, vdupq_n_u8( rminb ) ); - - uint16x8_t is0l = vaddl_u8( vget_low_u8( cr ), vget_low_u8( cg ) ); - uint16x8_t is0h = vaddl_u8( vget_high_u8( cr ), vget_high_u8( cg ) ); - uint16x8_t is1l = vaddw_u8( is0l, vget_low_u8( cb ) ); - uint16x8_t is1h = vaddw_u8( is0h, vget_high_u8( cb ) ); - - int16x8_t range = vdupq_n_s16( vrange2 ); - uint16x8_t m0 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( is1l ), range ) ); - uint16x8_t m1 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( is1h ), range ) ); - - uint8x8_t p00 = vmovn_u16( m0 ); - uint8x8_t p01 = vmovn_u16( m1 ); - uint8x16_t p0 = vcombine_u8( p00, p01 ); - - uint32x4_t p1 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 6 ), vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 12 ) ); - uint32x4_t p2 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 18 ), vreinterpretq_u32_u8( p0 ) ); - uint32x4_t p3 = vaddq_u32( p1, p2 ); - - uint16x4x2_t p4 = vuzp_u16( vget_low_u16( vreinterpretq_u16_u32( p3 ) ), vget_high_u16( vreinterpretq_u16_u32( p3 ) ) ); - uint8x8x2_t p = vuzp_u8( vreinterpret_u8_u16( p4.val[0] ), vreinterpret_u8_u16( p4.val[0] ) ); - - uint32_t vp; - vst1_lane_u32( &vp, vreinterpret_u32_u8( p.val[0] ), 0 ); - - return uint64_t( ( uint64_t( to565( minr, ming, minb ) ) << 16 ) | to565( maxr, maxg, maxb ) | ( uint64_t( vp ) << 32 ) ); -# else - uint32x4_t px0 = vld1q_u32( (uint32_t*)src ); - uint32x4_t px1 = vld1q_u32( (uint32_t*)src + 4 ); - uint32x4_t px2 = vld1q_u32( (uint32_t*)src + 8 ); - uint32x4_t px3 = vld1q_u32( (uint32_t*)src + 12 ); - - uint32x4_t smask = vdupq_n_u32( 0xF8FCF8 ); - uint32x4_t sd0 = vandq_u32( smask, px0 ); - uint32x4_t sd1 = vandq_u32( smask, px1 ); - uint32x4_t sd2 = vandq_u32( smask, px2 ); - uint32x4_t sd3 = vandq_u32( smask, px3 ); - - uint32x4_t sc = vdupq_n_u32( sd0[0] ); - - uint32x4_t sc0 = vceqq_u32( sd0, sc ); - uint32x4_t sc1 = vceqq_u32( sd1, sc ); - uint32x4_t sc2 = vceqq_u32( sd2, sc ); - uint32x4_t sc3 = vceqq_u32( sd3, sc ); - - uint32x4_t sm0 = vandq_u32( sc0, sc1 ); - uint32x4_t sm1 = vandq_u32( sc2, sc3 ); - int64x2_t sm = vreinterpretq_s64_u32( vandq_u32( sm0, sm1 ) ); - - if( sm[0] == -1 && sm[1] == -1 ) - { - return uint64_t( to565( src[0], src[1], src[2] ) ) << 16; - } - - uint32x4_t mask = vdupq_n_u32( 0xFFFFFF ); - uint8x16_t l0 = vreinterpretq_u8_u32( vandq_u32( mask, px0 ) ); - uint8x16_t l1 = vreinterpretq_u8_u32( vandq_u32( mask, px1 ) ); - uint8x16_t l2 = vreinterpretq_u8_u32( vandq_u32( mask, px2 ) ); - uint8x16_t l3 = vreinterpretq_u8_u32( vandq_u32( mask, px3 ) ); - - uint8x16_t min0 = vminq_u8( l0, l1 ); - uint8x16_t min1 = vminq_u8( l2, l3 ); - uint8x16_t min2 = vminq_u8( min0, min1 ); - - uint8x16_t max0 = vmaxq_u8( l0, l1 ); - uint8x16_t max1 = vmaxq_u8( l2, l3 ); - uint8x16_t max2 = vmaxq_u8( max0, max1 ); - - uint8x16_t min3 = vreinterpretq_u8_u32( vrev64q_u32( vreinterpretq_u32_u8( min2 ) ) ); - uint8x16_t max3 = vreinterpretq_u8_u32( vrev64q_u32( vreinterpretq_u32_u8( max2 ) ) ); - - uint8x16_t min4 = vminq_u8( min2, min3 ); - uint8x16_t max4 = vmaxq_u8( max2, max3 ); - - uint8x16_t min5 = vcombine_u8( vget_high_u8( min4 ), vget_low_u8( min4 ) ); - uint8x16_t max5 = vcombine_u8( vget_high_u8( max4 ), vget_low_u8( max4 ) ); - - uint8x16_t rmin = vminq_u8( min4, min5 ); - uint8x16_t rmax = vmaxq_u8( max4, max5 ); - - uint8x16_t range1 = vsubq_u8( rmax, rmin ); - uint8x8_t range2 = vget_low_u8( range1 ); - uint8x8x2_t range3 = vzip_u8( range2, vdup_n_u8( 0 ) ); - uint16x4_t range4 = vreinterpret_u16_u8( range3.val[0] ); - - uint16_t vrange1; - uint16x4_t range5 = vpadd_u16( range4, range4 ); - uint16x4_t range6 = vpadd_u16( range5, range5 ); - vst1_lane_u16( &vrange1, range6, 0 ); - - uint32_t vrange2 = ( 2 << 16 ) / uint32_t( vrange1 + 1 ); - uint16x8_t range = vdupq_n_u16( vrange2 ); - - uint8x16_t inset = vshrq_n_u8( range1, 4 ); - uint8x16_t min = vaddq_u8( rmin, inset ); - uint8x16_t max = vsubq_u8( rmax, inset ); - - uint8x16_t c0 = vsubq_u8( l0, rmin ); - uint8x16_t c1 = vsubq_u8( l1, rmin ); - uint8x16_t c2 = vsubq_u8( l2, rmin ); - uint8x16_t c3 = vsubq_u8( l3, rmin ); - - uint16x8_t is0 = vpaddlq_u8( c0 ); - uint16x8_t is1 = vpaddlq_u8( c1 ); - uint16x8_t is2 = vpaddlq_u8( c2 ); - uint16x8_t is3 = vpaddlq_u8( c3 ); - - uint16x4_t is4 = vpadd_u16( vget_low_u16( is0 ), vget_high_u16( is0 ) ); - uint16x4_t is5 = vpadd_u16( vget_low_u16( is1 ), vget_high_u16( is1 ) ); - uint16x4_t is6 = vpadd_u16( vget_low_u16( is2 ), vget_high_u16( is2 ) ); - uint16x4_t is7 = vpadd_u16( vget_low_u16( is3 ), vget_high_u16( is3 ) ); - - uint16x8_t s0 = vcombine_u16( is4, is5 ); - uint16x8_t s1 = vcombine_u16( is6, is7 ); - - uint16x8_t m0 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( s0 ), vreinterpretq_s16_u16( range ) ) ); - uint16x8_t m1 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( s1 ), vreinterpretq_s16_u16( range ) ) ); - - uint8x8_t p00 = vmovn_u16( m0 ); - uint8x8_t p01 = vmovn_u16( m1 ); - uint8x16_t p0 = vcombine_u8( p00, p01 ); - - uint32x4_t p1 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 6 ), vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 12 ) ); - uint32x4_t p2 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 18 ), vreinterpretq_u32_u8( p0 ) ); - uint32x4_t p3 = vaddq_u32( p1, p2 ); - - uint16x4x2_t p4 = vuzp_u16( vget_low_u16( vreinterpretq_u16_u32( p3 ) ), vget_high_u16( vreinterpretq_u16_u32( p3 ) ) ); - uint8x8x2_t p = vuzp_u8( vreinterpret_u8_u16( p4.val[0] ), vreinterpret_u8_u16( p4.val[0] ) ); - - uint32_t vmin, vmax, vp; - vst1q_lane_u32( &vmin, vreinterpretq_u32_u8( min ), 0 ); - vst1q_lane_u32( &vmax, vreinterpretq_u32_u8( max ), 0 ); - vst1_lane_u32( &vp, vreinterpret_u32_u8( p.val[0] ), 0 ); - - return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); -# endif -#else - uint32_t ref; - memcpy( &ref, src, 4 ); - uint32_t refMask = ref & 0xF8FCF8; - auto stmp = src + 4; - for( int i=1; i<16; i++ ) - { - uint32_t px; - memcpy( &px, stmp, 4 ); - if( ( px & 0xF8FCF8 ) != refMask ) break; - stmp += 4; - } - if( stmp == src + 64 ) - { - return uint64_t( to565( ref ) ) << 16; - } - - uint8_t min[3] = { src[0], src[1], src[2] }; - uint8_t max[3] = { src[0], src[1], src[2] }; - auto tmp = src + 4; - for( int i=1; i<16; i++ ) - { - for( int j=0; j<3; j++ ) - { - if( tmp[j] < min[j] ) min[j] = tmp[j]; - else if( tmp[j] > max[j] ) max[j] = tmp[j]; - } - tmp += 4; - } - - const uint32_t range = DivTable[max[0] - min[0] + max[1] - min[1] + max[2] - min[2]]; - const uint32_t rmin = min[0] + min[1] + min[2]; - for( int i=0; i<3; i++ ) - { - const uint8_t inset = ( max[i] - min[i] ) >> 4; - min[i] += inset; - max[i] -= inset; - } - - uint32_t data = 0; - for( int i=0; i<16; i++ ) - { - const uint32_t c = src[0] + src[1] + src[2] - rmin; - const uint8_t idx = ( c * range ) >> 16; - data |= idx << (i*2); - src += 4; - } - - return uint64_t( ( uint64_t( to565( min[0], min[1], min[2] ) ) << 16 ) | to565( max[0], max[1], max[2] ) | ( uint64_t( data ) << 32 ) ); -#endif -} - -#ifdef __AVX2__ -static etcpak_force_inline void ProcessRGB_AVX( const uint8_t* src, char*& dst ) -{ - __m256i px0 = _mm256_loadu_si256(((__m256i*)src) + 0); - __m256i px1 = _mm256_loadu_si256(((__m256i*)src) + 1); - __m256i px2 = _mm256_loadu_si256(((__m256i*)src) + 2); - __m256i px3 = _mm256_loadu_si256(((__m256i*)src) + 3); - - __m256i smask = _mm256_set1_epi32( 0xF8FCF8 ); - __m256i sd0 = _mm256_and_si256( px0, smask ); - __m256i sd1 = _mm256_and_si256( px1, smask ); - __m256i sd2 = _mm256_and_si256( px2, smask ); - __m256i sd3 = _mm256_and_si256( px3, smask ); - - __m256i sc = _mm256_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); - - __m256i sc0 = _mm256_cmpeq_epi8(sd0, sc); - __m256i sc1 = _mm256_cmpeq_epi8(sd1, sc); - __m256i sc2 = _mm256_cmpeq_epi8(sd2, sc); - __m256i sc3 = _mm256_cmpeq_epi8(sd3, sc); - - __m256i sm0 = _mm256_and_si256(sc0, sc1); - __m256i sm1 = _mm256_and_si256(sc2, sc3); - __m256i sm = _mm256_and_si256(sm0, sm1); - - const int64_t solid0 = 1 - _mm_testc_si128( _mm256_castsi256_si128( sm ), _mm_set1_epi32( -1 ) ); - const int64_t solid1 = 1 - _mm_testc_si128( _mm256_extracti128_si256( sm, 1 ), _mm_set1_epi32( -1 ) ); - - if( solid0 + solid1 == 0 ) - { - const auto c0 = uint64_t( to565( src[0], src[1], src[2] ) ); - const auto c1 = uint64_t( to565( src[16], src[17], src[18] ) ); - memcpy( dst, &c0, 8 ); - memcpy( dst+8, &c1, 8 ); - dst += 16; - return; - } - - __m256i min0 = _mm256_min_epu8( px0, px1 ); - __m256i min1 = _mm256_min_epu8( px2, px3 ); - __m256i min2 = _mm256_min_epu8( min0, min1 ); - - __m256i max0 = _mm256_max_epu8( px0, px1 ); - __m256i max1 = _mm256_max_epu8( px2, px3 ); - __m256i max2 = _mm256_max_epu8( max0, max1 ); - - __m256i min3 = _mm256_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); - __m256i max3 = _mm256_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); - __m256i min4 = _mm256_min_epu8( min2, min3 ); - __m256i max4 = _mm256_max_epu8( max2, max3 ); - - __m256i min5 = _mm256_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); - __m256i max5 = _mm256_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); - __m256i rmin = _mm256_min_epu8( min4, min5 ); - __m256i rmax = _mm256_max_epu8( max4, max5 ); - - __m256i range1 = _mm256_subs_epu8( rmax, rmin ); - __m256i range2 = _mm256_sad_epu8( rmax, rmin ); - - uint16_t vrange0 = DivTable[_mm256_cvtsi256_si32( range2 ) >> 1]; - uint16_t vrange1 = DivTable[_mm256_extract_epi16( range2, 8 ) >> 1]; - __m256i range00 = _mm256_set1_epi16( vrange0 ); - __m256i range = _mm256_inserti128_si256( range00, _mm_set1_epi16( vrange1 ), 1 ); - - __m256i inset1 = _mm256_srli_epi16( range1, 4 ); - __m256i inset = _mm256_and_si256( inset1, _mm256_set1_epi8( 0xF ) ); - __m256i min = _mm256_adds_epu8( rmin, inset ); - __m256i max = _mm256_subs_epu8( rmax, inset ); - - __m256i c0 = _mm256_subs_epu8( px0, rmin ); - __m256i c1 = _mm256_subs_epu8( px1, rmin ); - __m256i c2 = _mm256_subs_epu8( px2, rmin ); - __m256i c3 = _mm256_subs_epu8( px3, rmin ); - - __m256i is0 = _mm256_maddubs_epi16( c0, _mm256_set1_epi8( 1 ) ); - __m256i is1 = _mm256_maddubs_epi16( c1, _mm256_set1_epi8( 1 ) ); - __m256i is2 = _mm256_maddubs_epi16( c2, _mm256_set1_epi8( 1 ) ); - __m256i is3 = _mm256_maddubs_epi16( c3, _mm256_set1_epi8( 1 ) ); - - __m256i s0 = _mm256_hadd_epi16( is0, is1 ); - __m256i s1 = _mm256_hadd_epi16( is2, is3 ); - - __m256i m0 = _mm256_mulhi_epu16( s0, range ); - __m256i m1 = _mm256_mulhi_epu16( s1, range ); - - __m256i p0 = _mm256_packus_epi16( m0, m1 ); - - __m256i p1 = _mm256_or_si256( _mm256_srai_epi32( p0, 6 ), _mm256_srai_epi32( p0, 12 ) ); - __m256i p2 = _mm256_or_si256( _mm256_srai_epi32( p0, 18 ), p0 ); - __m256i p3 = _mm256_or_si256( p1, p2 ); - __m256i p =_mm256_shuffle_epi8( p3, _mm256_set1_epi32( 0x0C080400 ) ); - - __m256i mm0 = _mm256_unpacklo_epi8( _mm256_setzero_si256(), min ); - __m256i mm1 = _mm256_unpacklo_epi8( _mm256_setzero_si256(), max ); - __m256i mm2 = _mm256_unpacklo_epi64( mm1, mm0 ); - __m256i mmr = _mm256_slli_epi64( _mm256_srli_epi64( mm2, 11 ), 11 ); - __m256i mmg = _mm256_slli_epi64( _mm256_srli_epi64( mm2, 26 ), 5 ); - __m256i mmb = _mm256_srli_epi64( _mm256_slli_epi64( mm2, 16 ), 59 ); - __m256i mm3 = _mm256_or_si256( mmr, mmg ); - __m256i mm4 = _mm256_or_si256( mm3, mmb ); - __m256i mm5 = _mm256_shuffle_epi8( mm4, _mm256_set1_epi32( 0x09080100 ) ); - - __m256i d0 = _mm256_unpacklo_epi32( mm5, p ); - __m256i d1 = _mm256_permute4x64_epi64( d0, _MM_SHUFFLE( 3, 2, 2, 0 ) ); - __m128i d2 = _mm256_castsi256_si128( d1 ); - - __m128i mask = _mm_set_epi64x( 0xFFFF0000 | -solid1, 0xFFFF0000 | -solid0 ); - __m128i d3 = _mm_and_si128( d2, mask ); - - __m128i x0 = _mm_andnot_si128( d3, _mm_set1_epi32( 0x55555555 ) ); - __m128i x1 = _mm_andnot_si128( d3, _mm_set1_epi32( 0xAAAAAAAA ) ); - __m128i x2 = _mm_slli_epi32( x0, 1 ); - __m128i x3 = _mm_srli_epi32( x1, 1 ); - __m128i x4 = _mm_xor_si128( x1, x2 ); - __m128i x5 = _mm_or_si128( x3, x4 ); - __m128i x6 = _mm_and_si128( d3, _mm_set1_epi64x( 0xFFFFFFFF ) ); - __m128i x7 = _mm_and_si128( x5, _mm_set1_epi64x( 0xFFFFFFFF00000000 ) ); - __m128i x8 = _mm_or_si128( x6, x7 ); - - _mm_storeu_si128( (__m128i*)dst, x8 ); - dst += 16; -} -#endif - -static const uint8_t AlphaIndexTable[8] = { 1, 7, 6, 5, 4, 3, 2, 0 }; - -static etcpak_force_inline uint64_t ProcessAlpha( const uint8_t* src ) -{ - uint8_t solid8 = *src; - uint16_t solid16 = uint16_t( solid8 ) | ( uint16_t( solid8 ) << 8 ); - uint32_t solid32 = uint32_t( solid16 ) | ( uint32_t( solid16 ) << 16 ); - uint64_t solid64 = uint64_t( solid32 ) | ( uint64_t( solid32 ) << 32 ); - if( memcmp( src, &solid64, 8 ) == 0 && memcmp( src+8, &solid64, 8 ) == 0 ) - { - return solid8; - } - - uint8_t min = src[0]; - uint8_t max = min; - for( int i=1; i<16; i++ ) - { - const auto v = src[i]; - if( v > max ) max = v; - else if( v < min ) min = v; - } - - uint32_t range = ( 8 << 13 ) / ( 1 + max - min ); - uint64_t data = 0; - for( int i=0; i<16; i++ ) - { - uint8_t a = src[i] - min; - uint64_t idx = AlphaIndexTable[( a * range ) >> 13]; - data |= idx << (i*3); - } - - return max | ( min << 8 ) | ( data << 16 ); -} - -#ifdef __SSE4_1__ -static etcpak_force_inline uint64_t ProcessRGB_SSE( __m128i px0, __m128i px1, __m128i px2, __m128i px3 ) -{ - __m128i smask = _mm_set1_epi32( 0xF8FCF8 ); - __m128i sd0 = _mm_and_si128( px0, smask ); - __m128i sd1 = _mm_and_si128( px1, smask ); - __m128i sd2 = _mm_and_si128( px2, smask ); - __m128i sd3 = _mm_and_si128( px3, smask ); - - __m128i sc = _mm_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); - - __m128i sc0 = _mm_cmpeq_epi8(sd0, sc); - __m128i sc1 = _mm_cmpeq_epi8(sd1, sc); - __m128i sc2 = _mm_cmpeq_epi8(sd2, sc); - __m128i sc3 = _mm_cmpeq_epi8(sd3, sc); - - __m128i sm0 = _mm_and_si128(sc0, sc1); - __m128i sm1 = _mm_and_si128(sc2, sc3); - __m128i sm = _mm_and_si128(sm0, sm1); - - if( _mm_testc_si128(sm, _mm_set1_epi32(-1)) ) - { - return uint64_t( to565( _mm_cvtsi128_si32( px0 ) ) ) << 16; - } - - px0 = _mm_and_si128( px0, _mm_set1_epi32( 0xFFFFFF ) ); - px1 = _mm_and_si128( px1, _mm_set1_epi32( 0xFFFFFF ) ); - px2 = _mm_and_si128( px2, _mm_set1_epi32( 0xFFFFFF ) ); - px3 = _mm_and_si128( px3, _mm_set1_epi32( 0xFFFFFF ) ); - - __m128i min0 = _mm_min_epu8( px0, px1 ); - __m128i min1 = _mm_min_epu8( px2, px3 ); - __m128i min2 = _mm_min_epu8( min0, min1 ); - - __m128i max0 = _mm_max_epu8( px0, px1 ); - __m128i max1 = _mm_max_epu8( px2, px3 ); - __m128i max2 = _mm_max_epu8( max0, max1 ); - - __m128i min3 = _mm_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); - __m128i max3 = _mm_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); - __m128i min4 = _mm_min_epu8( min2, min3 ); - __m128i max4 = _mm_max_epu8( max2, max3 ); - - __m128i min5 = _mm_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); - __m128i max5 = _mm_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); - __m128i rmin = _mm_min_epu8( min4, min5 ); - __m128i rmax = _mm_max_epu8( max4, max5 ); - - __m128i range1 = _mm_subs_epu8( rmax, rmin ); - __m128i range2 = _mm_sad_epu8( rmax, rmin ); - - uint32_t vrange = _mm_cvtsi128_si32( range2 ) >> 1; - __m128i range = _mm_set1_epi16( DivTable[vrange] ); - - __m128i inset1 = _mm_srli_epi16( range1, 4 ); - __m128i inset = _mm_and_si128( inset1, _mm_set1_epi8( 0xF ) ); - __m128i min = _mm_adds_epu8( rmin, inset ); - __m128i max = _mm_subs_epu8( rmax, inset ); - - __m128i c0 = _mm_subs_epu8( px0, rmin ); - __m128i c1 = _mm_subs_epu8( px1, rmin ); - __m128i c2 = _mm_subs_epu8( px2, rmin ); - __m128i c3 = _mm_subs_epu8( px3, rmin ); - - __m128i is0 = _mm_maddubs_epi16( c0, _mm_set1_epi8( 1 ) ); - __m128i is1 = _mm_maddubs_epi16( c1, _mm_set1_epi8( 1 ) ); - __m128i is2 = _mm_maddubs_epi16( c2, _mm_set1_epi8( 1 ) ); - __m128i is3 = _mm_maddubs_epi16( c3, _mm_set1_epi8( 1 ) ); - - __m128i s0 = _mm_hadd_epi16( is0, is1 ); - __m128i s1 = _mm_hadd_epi16( is2, is3 ); - - __m128i m0 = _mm_mulhi_epu16( s0, range ); - __m128i m1 = _mm_mulhi_epu16( s1, range ); - - __m128i p0 = _mm_packus_epi16( m0, m1 ); - - __m128i p1 = _mm_or_si128( _mm_srai_epi32( p0, 6 ), _mm_srai_epi32( p0, 12 ) ); - __m128i p2 = _mm_or_si128( _mm_srai_epi32( p0, 18 ), p0 ); - __m128i p3 = _mm_or_si128( p1, p2 ); - __m128i p =_mm_shuffle_epi8( p3, _mm_set1_epi32( 0x0C080400 ) ); - - uint32_t vmin = _mm_cvtsi128_si32( min ); - uint32_t vmax = _mm_cvtsi128_si32( max ); - uint32_t vp = _mm_cvtsi128_si32( p ); - - return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); -} - -static etcpak_force_inline uint64_t ProcessOneChannel_SSE( __m128i a ) -{ - __m128i solidCmp = _mm_shuffle_epi8( a, _mm_setzero_si128() ); - __m128i cmpRes = _mm_cmpeq_epi8( a, solidCmp ); - if( _mm_testc_si128( cmpRes, _mm_set1_epi32( -1 ) ) ) - { - return _mm_cvtsi128_si32( a ) & 0xFF; - } - - __m128i a1 = _mm_shuffle_epi32( a, _MM_SHUFFLE( 2, 3, 0, 1 ) ); - __m128i max1 = _mm_max_epu8( a, a1 ); - __m128i min1 = _mm_min_epu8( a, a1 ); - __m128i amax2 = _mm_shuffle_epi32( max1, _MM_SHUFFLE( 0, 0, 2, 2 ) ); - __m128i amin2 = _mm_shuffle_epi32( min1, _MM_SHUFFLE( 0, 0, 2, 2 ) ); - __m128i max2 = _mm_max_epu8( max1, amax2 ); - __m128i min2 = _mm_min_epu8( min1, amin2 ); - __m128i amax3 = _mm_alignr_epi8( max2, max2, 2 ); - __m128i amin3 = _mm_alignr_epi8( min2, min2, 2 ); - __m128i max3 = _mm_max_epu8( max2, amax3 ); - __m128i min3 = _mm_min_epu8( min2, amin3 ); - __m128i amax4 = _mm_alignr_epi8( max3, max3, 1 ); - __m128i amin4 = _mm_alignr_epi8( min3, min3, 1 ); - __m128i max = _mm_max_epu8( max3, amax4 ); - __m128i min = _mm_min_epu8( min3, amin4 ); - __m128i minmax = _mm_unpacklo_epi8( max, min ); - - __m128i r = _mm_sub_epi8( max, min ); - int range = _mm_cvtsi128_si32( r ) & 0xFF; - __m128i rv = _mm_set1_epi16( DivTableAlpha[range] ); - - __m128i v = _mm_sub_epi8( a, min ); - - __m128i lo16 = _mm_unpacklo_epi8( v, _mm_setzero_si128() ); - __m128i hi16 = _mm_unpackhi_epi8( v, _mm_setzero_si128() ); - - __m128i lomul = _mm_mulhi_epu16( lo16, rv ); - __m128i himul = _mm_mulhi_epu16( hi16, rv ); - - __m128i p0 = _mm_packus_epi16( lomul, himul ); - __m128i p1 = _mm_or_si128( _mm_and_si128( p0, _mm_set1_epi16( 0x3F ) ), _mm_srai_epi16( _mm_and_si128( p0, _mm_set1_epi16( 0x3F00 ) ), 5 ) ); - __m128i p2 = _mm_packus_epi16( p1, p1 ); - - uint64_t pi = _mm_cvtsi128_si64( p2 ); - uint64_t data = 0; - for( int i=0; i<8; i++ ) - { - uint64_t idx = AlphaIndexTable_SSE[(pi>>(i*8)) & 0x3F]; - data |= idx << (i*6); - } - return (uint64_t)(uint16_t)_mm_cvtsi128_si32( minmax ) | ( data << 16 ); -} - -static etcpak_force_inline uint64_t ProcessAlpha_SSE( __m128i px0, __m128i px1, __m128i px2, __m128i px3 ) -{ - __m128i mask = _mm_setr_epi32( 0x0f0b0703, -1, -1, -1 ); - - __m128i m0 = _mm_shuffle_epi8( px0, mask ); - __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); - __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); - __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); - __m128i m4 = _mm_or_si128( m0, m1 ); - __m128i m5 = _mm_or_si128( m2, m3 ); - __m128i a = _mm_or_si128( m4, m5 ); - - return ProcessOneChannel_SSE( a ); -} -#endif - -void CompressBc1( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) -{ -#ifdef __AVX2__ - if( width%8 == 0 ) - { - blocks /= 2; - uint32_t buf[8*4]; - int i = 0; - char* dst8 = (char*)dst; - - do - { - auto tmp = (char*)buf; - memcpy( tmp, src + width * 0, 8*4 ); - memcpy( tmp + 8*4, src + width * 1, 8*4 ); - memcpy( tmp + 16*4, src + width * 2, 8*4 ); - memcpy( tmp + 24*4, src + width * 3, 8*4 ); - src += 8; - if( ++i == width/8 ) - { - src += width * 3; - i = 0; - } - - ProcessRGB_AVX( (uint8_t*)buf, dst8 ); - } - while( --blocks ); - } - else -#endif - { - uint32_t buf[4*4]; - int i = 0; - - auto ptr = dst; - do - { - auto tmp = (char*)buf; - memcpy( tmp, src + width * 0, 4*4 ); - memcpy( tmp + 4*4, src + width * 1, 4*4 ); - memcpy( tmp + 8*4, src + width * 2, 4*4 ); - memcpy( tmp + 12*4, src + width * 3, 4*4 ); - src += 4; - if( ++i == width/4 ) - { - src += width * 3; - i = 0; - } - - const auto c = ProcessRGB( (uint8_t*)buf ); - uint8_t fix[8]; - memcpy( fix, &c, 8 ); - for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; - memcpy( ptr, fix, sizeof( uint64_t ) ); - ptr++; - } - while( --blocks ); - } -} - -void CompressBc1Dither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) -{ - uint32_t buf[4*4]; - int i = 0; - - auto ptr = dst; - do - { - auto tmp = (char*)buf; - memcpy( tmp, src + width * 0, 4*4 ); - memcpy( tmp + 4*4, src + width * 1, 4*4 ); - memcpy( tmp + 8*4, src + width * 2, 4*4 ); - memcpy( tmp + 12*4, src + width * 3, 4*4 ); - src += 4; - if( ++i == width/4 ) - { - src += width * 3; - i = 0; - } - - Dither( (uint8_t*)buf ); - - const auto c = ProcessRGB( (uint8_t*)buf ); - uint8_t fix[8]; - memcpy( fix, &c, 8 ); - for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; - memcpy( ptr, fix, sizeof( uint64_t ) ); - ptr++; - } - while( --blocks ); -} - -void CompressBc3( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) -{ - int i = 0; - auto ptr = dst; - do - { -#ifdef __SSE4_1__ - __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); - __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); - __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); - __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); - - src += 4; - if( ++i == width/4 ) - { - src += width * 3; - i = 0; - } - - *ptr++ = ProcessAlpha_SSE( px0, px1, px2, px3 ); - - const auto c = ProcessRGB_SSE( px0, px1, px2, px3 ); - uint8_t fix[8]; - memcpy( fix, &c, 8 ); - for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; - memcpy( ptr, fix, sizeof( uint64_t ) ); - ptr++; -#else - uint32_t rgba[4*4]; - uint8_t alpha[4*4]; - - auto tmp = (char*)rgba; - memcpy( tmp, src + width * 0, 4*4 ); - memcpy( tmp + 4*4, src + width * 1, 4*4 ); - memcpy( tmp + 8*4, src + width * 2, 4*4 ); - memcpy( tmp + 12*4, src + width * 3, 4*4 ); - src += 4; - if( ++i == width/4 ) - { - src += width * 3; - i = 0; - } - - for( int i=0; i<16; i++ ) - { - alpha[i] = rgba[i] >> 24; - rgba[i] &= 0xFFFFFF; - } - *ptr++ = ProcessAlpha( alpha ); - - const auto c = ProcessRGB( (uint8_t*)rgba ); - uint8_t fix[8]; - memcpy( fix, &c, 8 ); - for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; - memcpy( ptr, fix, sizeof( uint64_t ) ); - ptr++; -#endif - } - while( --blocks ); -} - -void CompressBc4( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) -{ - int i = 0; - auto ptr = dst; - do - { -#ifdef __SSE4_1__ - __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); - __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); - __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); - __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); - - src += 4; - if( ++i == width/4 ) - { - src += width * 3; - i = 0; - } - - __m128i mask = _mm_setr_epi32( 0x0c080400, -1, -1, -1 ); - - __m128i m0 = _mm_shuffle_epi8( px0, mask ); - __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); - __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); - __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); - __m128i m4 = _mm_or_si128( m0, m1 ); - __m128i m5 = _mm_or_si128( m2, m3 ); - - *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); -#else - uint8_t r[4*4]; - auto rgba = src; - for( int i=0; i<4; i++ ) - { - r[i*4] = rgba[0] & 0xff; - r[i*4+1] = rgba[1] & 0xff; - r[i*4+2] = rgba[2] & 0xff; - r[i*4+3] = rgba[3] & 0xff; - - rgba += width; - } - - src += 4; - if( ++i == width/4 ) - { - src += width * 3; - i = 0; - } - - *ptr++ = ProcessAlpha( r ); -#endif - } while( --blocks ); -} - -void CompressBc5( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) -{ - int i = 0; - auto ptr = dst; - do - { -#ifdef __SSE4_1__ - __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); - __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); - __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); - __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); - - src += 4; - if( ++i == width/4 ) - { - src += width*3; - i = 0; - } - - __m128i mask = _mm_setr_epi32( 0x0c080400, -1, -1, -1 ); - - __m128i m0 = _mm_shuffle_epi8( px0, mask ); - __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); - __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); - __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); - __m128i m4 = _mm_or_si128( m0, m1 ); - __m128i m5 = _mm_or_si128( m2, m3 ); - - *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); - - mask = _mm_setr_epi32( 0x0d090501, -1, -1, -1 ); - - m0 = _mm_shuffle_epi8( px0, mask ); - m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); - m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); - m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); - m4 = _mm_or_si128( m0, m1 ); - m5 = _mm_or_si128( m2, m3 ); - - *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); -#else - uint8_t rg[4*4*2]; - auto rgba = src; - for( int i=0; i<4; i++ ) - { - rg[i*4] = rgba[0] & 0xff; - rg[i*4+1] = rgba[1] & 0xff; - rg[i*4+2] = rgba[2] & 0xff; - rg[i*4+3] = rgba[3] & 0xff; - - rg[16+i*4] = (rgba[0] & 0xff00) >> 8; - rg[16+i*4+1] = (rgba[1] & 0xff00) >> 8; - rg[16+i*4+2] = (rgba[2] & 0xff00) >> 8; - rg[16+i*4+3] = (rgba[3] & 0xff00) >> 8; - - rgba += width; - } - - src += 4; - if( ++i == width/4 ) - { - src += width*3; - i = 0; - } - - *ptr++ = ProcessAlpha( rg ); - *ptr++ = ProcessAlpha( &rg[16] ); -#endif - } while( --blocks ); -} - -void CompressBc7( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, const bc7enc_compress_block_params* params ) -{ - int i = 0; - auto ptr = dst; - do - { - uint32_t rgba[4*4]; - - auto tmp = (char*)rgba; - memcpy( tmp, src + width * 0, 4*4 ); - memcpy( tmp + 4*4, src + width * 1, 4*4 ); - memcpy( tmp + 8*4, src + width * 2, 4*4 ); - memcpy( tmp + 12*4, src + width * 3, 4*4 ); - src += 4; - if( ++i == width/4 ) - { - src += width * 3; - i = 0; - } - - bc7enc_compress_block( ptr, rgba, params ); - ptr += 2; - } - while( --blocks ); -} diff --git a/lib/etcpak/etcpak/ProcessDxtc.hpp b/lib/etcpak/etcpak/ProcessDxtc.hpp deleted file mode 100644 index 7655bb33bea..00000000000 --- a/lib/etcpak/etcpak/ProcessDxtc.hpp +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef __PROCESSDXT1_HPP__ -#define __PROCESSDXT1_HPP__ - -#include -#include - -void CompressBc1( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); -void CompressBc1Dither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); -void CompressBc3( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); - -void CompressBc4( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); -void CompressBc5( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); - -struct bc7enc_compress_block_params; - -void CompressBc7( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, const bc7enc_compress_block_params* params ); - -#endif diff --git a/lib/etcpak/etcpak/Semaphore.hpp b/lib/etcpak/etcpak/Semaphore.hpp deleted file mode 100644 index 9e42dbb9e00..00000000000 --- a/lib/etcpak/etcpak/Semaphore.hpp +++ /dev/null @@ -1,46 +0,0 @@ -#ifndef __DARKRL__SEMAPHORE_HPP__ -#define __DARKRL__SEMAPHORE_HPP__ - -#include -#include - -class Semaphore -{ -public: - Semaphore( int count ) : m_count( count ) {} - - void lock() - { - std::unique_lock lock( m_mutex ); - m_cv.wait( lock, [this](){ return m_count != 0; } ); - m_count--; - } - - void unlock() - { - std::lock_guard lock( m_mutex ); - m_count++; - m_cv.notify_one(); - } - - bool try_lock() - { - std::lock_guard lock( m_mutex ); - if( m_count == 0 ) - { - return false; - } - else - { - m_count--; - return true; - } - } - -private: - std::mutex m_mutex; - std::condition_variable m_cv; - unsigned int m_count; -}; - -#endif diff --git a/lib/etcpak/etcpak/System.cpp b/lib/etcpak/etcpak/System.cpp deleted file mode 100644 index 1383d0ecd0e..00000000000 --- a/lib/etcpak/etcpak/System.cpp +++ /dev/null @@ -1,68 +0,0 @@ -#include -#ifdef _WIN32 -# include -#else -# include -# include -#endif - -#include "System.hpp" - -unsigned int System::CPUCores() -{ - static unsigned int cores = 0; - if( cores == 0 ) - { - int tmp; -#ifdef _WIN32 - SYSTEM_INFO info; - GetSystemInfo( &info ); - tmp = (int)info.dwNumberOfProcessors; -#else -# ifndef _SC_NPROCESSORS_ONLN -# ifdef _SC_NPROC_ONLN -# define _SC_NPROCESSORS_ONLN _SC_NPROC_ONLN -# elif defined _SC_CRAY_NCPU -# define _SC_NPROCESSORS_ONLN _SC_CRAY_NCPU -# endif -# endif - tmp = (int)(long)sysconf( _SC_NPROCESSORS_ONLN ); -#endif - cores = (unsigned int)std::max( tmp, 1 ); - } - return cores; -} - -void System::SetThreadName( std::thread& thread, const char* name ) -{ -#ifdef _WIN32 - const DWORD MS_VC_EXCEPTION=0x406D1388; - -# pragma pack( push, 8 ) - struct THREADNAME_INFO - { - DWORD dwType; - LPCSTR szName; - DWORD dwThreadID; - DWORD dwFlags; - }; -# pragma pack(pop) - - DWORD ThreadId = GetThreadId( static_cast( thread.native_handle() ) ); - THREADNAME_INFO info; - info.dwType = 0x1000; - info.szName = name; - info.dwThreadID = ThreadId; - info.dwFlags = 0; - - __try - { - RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info ); - } - __except(EXCEPTION_EXECUTE_HANDLER) - { - } -#elif !defined(__APPLE__) - pthread_setname_np( thread.native_handle(), name ); -#endif -} diff --git a/lib/etcpak/etcpak/System.hpp b/lib/etcpak/etcpak/System.hpp deleted file mode 100644 index 1a09bb15e1c..00000000000 --- a/lib/etcpak/etcpak/System.hpp +++ /dev/null @@ -1,15 +0,0 @@ -#ifndef __DARKRL__SYSTEM_HPP__ -#define __DARKRL__SYSTEM_HPP__ - -#include - -class System -{ -public: - System() = delete; - - static unsigned int CPUCores(); - static void SetThreadName( std::thread& thread, const char* name ); -}; - -#endif diff --git a/lib/etcpak/etcpak/TaskDispatch.cpp b/lib/etcpak/etcpak/TaskDispatch.cpp deleted file mode 100644 index 7287da4de22..00000000000 --- a/lib/etcpak/etcpak/TaskDispatch.cpp +++ /dev/null @@ -1,115 +0,0 @@ -#include -#include - -#include "Debug.hpp" -#include "System.hpp" -#include "TaskDispatch.hpp" - -static TaskDispatch* s_instance = nullptr; - -TaskDispatch::TaskDispatch( size_t workers ) - : m_exit( false ) - , m_jobs( 0 ) -{ - assert( !s_instance ); - s_instance = this; - - assert( workers >= 1 ); - workers--; - - m_workers.reserve( workers ); - for( size_t i=0; i& f ) -{ - std::unique_lock lock( s_instance->m_queueLock ); - s_instance->m_queue.emplace_back( f ); - const auto size = s_instance->m_queue.size(); - lock.unlock(); - if( size > 1 ) - { - s_instance->m_cvWork.notify_one(); - } -} - -void TaskDispatch::Queue( std::function&& f ) -{ - std::unique_lock lock( s_instance->m_queueLock ); - s_instance->m_queue.emplace_back( std::move( f ) ); - const auto size = s_instance->m_queue.size(); - lock.unlock(); - if( size > 1 ) - { - s_instance->m_cvWork.notify_one(); - } -} - -void TaskDispatch::Sync() -{ - std::unique_lock lock( s_instance->m_queueLock ); - while( !s_instance->m_queue.empty() ) - { - auto f = s_instance->m_queue.back(); - s_instance->m_queue.pop_back(); - lock.unlock(); - f(); - lock.lock(); - } - s_instance->m_cvJobs.wait( lock, []{ return s_instance->m_jobs == 0; } ); -} - -void TaskDispatch::Worker() -{ - for(;;) - { - std::unique_lock lock( m_queueLock ); - m_cvWork.wait( lock, [this]{ return !m_queue.empty() || m_exit; } ); - if( m_exit ) return; - auto f = m_queue.back(); - m_queue.pop_back(); - m_jobs++; - lock.unlock(); - f(); - lock.lock(); - m_jobs--; - bool notify = m_jobs == 0 && m_queue.empty(); - lock.unlock(); - if( notify ) - { - m_cvJobs.notify_all(); - } - } -} diff --git a/lib/etcpak/etcpak/TaskDispatch.hpp b/lib/etcpak/etcpak/TaskDispatch.hpp deleted file mode 100644 index b513de4c0c5..00000000000 --- a/lib/etcpak/etcpak/TaskDispatch.hpp +++ /dev/null @@ -1,34 +0,0 @@ -#ifndef __DARKRL__TASKDISPATCH_HPP__ -#define __DARKRL__TASKDISPATCH_HPP__ - -#include -#include -#include -#include -#include -#include - -class TaskDispatch -{ -public: - TaskDispatch( size_t workers ); - ~TaskDispatch(); - - static void Queue( const std::function& f ); - static void Queue( std::function&& f ); - - static void Sync(); - -private: - void Worker(); - - std::vector> m_queue; - std::mutex m_queueLock; - std::condition_variable m_cvWork, m_cvJobs; - std::atomic m_exit; - size_t m_jobs; - - std::vector m_workers; -}; - -#endif diff --git a/lib/etcpak/etcpak/TextureHeader.cpp b/lib/etcpak/etcpak/TextureHeader.cpp deleted file mode 100644 index bee8152192e..00000000000 --- a/lib/etcpak/etcpak/TextureHeader.cpp +++ /dev/null @@ -1,129 +0,0 @@ -#include "TextureHeader.hpp" -#include - -void ProcessHeader(uint8_t* data, CodecType& type, int32_t& width, int32_t& height, size_t& dataOffset){ - auto data32 = (uint32_t*)data; - if( *data32 == 0x03525650 ) - { - // PVR - switch( *(data32+2) ) - { - case 6: - type = Etc1; - break; - case 7: - type = Bc1; - break; - case 11: - type = Bc3; - break; - case 12: - type = Bc4; - break; - case 13: - type = Bc5; - break; - case 15: - type = Bc7; - break; - case 22: - type = Etc2_RGB; - break; - case 23: - type = Etc2_RGBA; - break; - case 25: - type = Etc2_R11; - break; - case 26: - type = Etc2_RG11; - break; - default: - assert( false ); - break; - } - - height = *(data32+6); - width = *(data32+7); - dataOffset = 52 + *(data32+12); - } - else if( *data32 == 0x58544BAB ) - { - // KTX - switch( *(data32+7) ) - { - case 0x9274: - type = Etc2_RGB; - break; - case 0x9278: - type = Etc2_RGBA; - break; - case 0x9270: - type = Etc2_R11; - break; - case 0x9272: - type = Etc2_RG11; - break; - default: - assert( false ); - break; - } - - width = *(data32+9); - height = *(data32+10); - dataOffset = sizeof( uint32_t ) * 17 + *(data32+15); - } - else if( *data32 == 0x20534444 ) - { - // DDS - switch( *(data32+21) ) - { - case 0x31545844: - type = Bc1; - dataOffset = 128; - break; - case 0x35545844: - type = Bc3; - dataOffset = 128; - break; - case 0x30315844: - dataOffset = 148; - // DXGI_FORMAT_BCn - switch( *(data32+32) ) - { - case 71: - case 72: - type = Bc1; - break; - case 77: - case 78: - type = Bc3; - break; - case 80: - type = Bc4; - break; - case 83: - type = Bc5; - break; - case 98: - case 99: - type = Bc7; - break; - default: - assert( false ); - break; - }; - break; - default: - assert( false ); - break; - }; - - width = *(data32+4); - height = *(data32+3); - } - else - { - assert( false ); - } -} diff --git a/lib/etcpak/etcpak/TextureHeader.hpp b/lib/etcpak/etcpak/TextureHeader.hpp deleted file mode 100644 index 0deb7178faa..00000000000 --- a/lib/etcpak/etcpak/TextureHeader.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#ifndef __TEXTUREHEADER_HPP__ -#define __TEXTUREHEADER_HPP__ - -#include "ForceInline.hpp" -#include -#include - -enum CodecType -{ - Etc1, - Etc2_RGB, - Etc2_RGBA, - Etc2_R11, - Etc2_RG11, - Bc1, - Bc3, - Bc4, - Bc5, - Bc7 -}; - -// Public interface for processing header -etcpak_no_inline void ProcessHeader(uint8_t* data, CodecType& type, int32_t& width, int32_t& height, size_t& dataOffset); -#endif \ No newline at end of file diff --git a/lib/etcpak/etcpak/Timing.cpp b/lib/etcpak/etcpak/Timing.cpp deleted file mode 100644 index 2af851f9a91..00000000000 --- a/lib/etcpak/etcpak/Timing.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include - -#include "Timing.hpp" - -uint64_t GetTime() -{ - return std::chrono::time_point_cast( std::chrono::high_resolution_clock::now() ).time_since_epoch().count(); -} diff --git a/lib/etcpak/etcpak/Timing.hpp b/lib/etcpak/etcpak/Timing.hpp deleted file mode 100644 index 3767e20f24a..00000000000 --- a/lib/etcpak/etcpak/Timing.hpp +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef __DARKRL__TIMING_HPP__ -#define __DARKRL__TIMING_HPP__ - -#include - -uint64_t GetTime(); - -#endif diff --git a/lib/etcpak/etcpak/mmap.cpp b/lib/etcpak/etcpak/mmap.cpp deleted file mode 100644 index c2460ee9e4e..00000000000 --- a/lib/etcpak/etcpak/mmap.cpp +++ /dev/null @@ -1,38 +0,0 @@ -#include "mmap.hpp" - -#ifdef _WIN32 -# include -# include - -void* mmap( void* addr, size_t length, int prot, int flags, int fd, off_t offset ) -{ - HANDLE hnd; - void* map = nullptr; - - switch( prot ) - { - case PROT_READ: - if( hnd = CreateFileMapping( HANDLE( _get_osfhandle( fd ) ), nullptr, PAGE_READONLY, 0, DWORD( length ), nullptr ) ) - { - map = MapViewOfFile( hnd, FILE_MAP_READ, 0, 0, length ); - CloseHandle( hnd ); - } - break; - case PROT_WRITE: - if( hnd = CreateFileMapping( HANDLE( _get_osfhandle( fd ) ), nullptr, PAGE_READWRITE, 0, DWORD( length ), nullptr ) ) - { - map = MapViewOfFile( hnd, FILE_MAP_WRITE, 0, 0, length ); - CloseHandle( hnd ); - } - break; - } - - return map ? (char*)map + offset : (void*)-1; -} - -int munmap( void* addr, size_t length ) -{ - return UnmapViewOfFile( addr ) != 0 ? 0 : -1; -} - -#endif diff --git a/lib/etcpak/etcpak/mmap.hpp b/lib/etcpak/etcpak/mmap.hpp deleted file mode 100644 index e4cfe7759ca..00000000000 --- a/lib/etcpak/etcpak/mmap.hpp +++ /dev/null @@ -1,19 +0,0 @@ -#ifndef __MMAP_HPP__ -#define __MMAP_HPP__ - -#ifndef _WIN32 -# include -#else -# include -# include - -# define PROT_READ 1 -# define PROT_WRITE 2 -# define MAP_SHARED 0 - -void* mmap( void* addr, size_t length, int prot, int flags, int fd, off_t offset ); -int munmap( void* addr, size_t length ); - -#endif - -#endif diff --git a/lib/etcpak/etcpak/simd.py b/lib/etcpak/etcpak/simd.py deleted file mode 100644 index e87d0dfcd3d..00000000000 --- a/lib/etcpak/etcpak/simd.py +++ /dev/null @@ -1,118 +0,0 @@ -import lldb - -class Simd128Printer: - def __init__(self, valobj, internal_dict): - self.valobj = valobj - - def update(self): - self.v0 = self.valobj.GetChildAtIndex(0).GetValueAsUnsigned() - self.v1 = self.valobj.GetChildAtIndex(1).GetValueAsUnsigned() - - def num_children(self): - return 8 - - def get_child_index(self, name): - return int(name.lstrip('[').rstrip(']')) - - def get_child_at_index(self, index): - if index == 0: - return self.valobj.CreateValueFromExpression('u8x16', 'uint16_t x[16] = {' + str(self.v0 & 0xFF) + ',' + str((self.v0 >> 8) & 0xFF) + ',' + str((self.v0 >> 16) & 0xFF) + ',' + str((self.v0 >> 24) & 0xFF) + ',' + str((self.v0 >> 32) & 0xFF) + ',' + str((self.v0 >> 40) & 0xFF) + ',' + str((self.v0 >> 48) & 0xFF) + ',' + str(self.v0 >> 56) + ',' + str(self.v1 & 0xFF) + ',' + str((self.v1 >> 8) & 0xFF) + ',' + str((self.v1 >> 16) & 0xFF) + ',' + str((self.v1 >> 24) & 0xFF) + ',' + str((self.v1 >> 32) & 0xFF) + ',' + str((self.v1 >> 40) & 0xFF) + ',' + str((self.v1 >> 48) & 0xFF) + ',' + str(self.v1 >> 56) + '}; x') - elif index == 1: - return self.valobj.CreateValueFromExpression('i8x16', 'int16_t x[16] = {(int8_t)' + str(self.v0 & 0xFF) + ',(int8_t)' + str((self.v0 >> 8) & 0xFF) + ',(int8_t)' + str((self.v0 >> 16) & 0xFF) + ',(int8_t)' + str((self.v0 >> 24) & 0xFF) + ',(int8_t)' + str((self.v0 >> 32) & 0xFF) + ',(int8_t)' + str((self.v0 >> 40) & 0xFF) + ',(int8_t)' + str((self.v0 >> 48) & 0xFF) + ',(int8_t)' + str(self.v0 >> 56) + ',(int8_t)' + str(self.v1 & 0xFF) + ',(int8_t)' + str((self.v1 >> 8) & 0xFF) + ',(int8_t)' + str((self.v1 >> 16) & 0xFF) + ',(int8_t)' + str((self.v1 >> 24) & 0xFF) + ',(int8_t)' + str((self.v1 >> 32) & 0xFF) + ',(int8_t)' + str((self.v1 >> 40) & 0xFF) + ',(int8_t)' + str((self.v1 >> 48) & 0xFF) + ',(int8_t)' + str(self.v1 >> 56) + '}; x') - elif index == 2: - return self.valobj.CreateValueFromExpression('u16x8', 'uint16_t x[8] = {' + str(self.v0 & 0xFFFF) + ',' + str((self.v0 >> 16) & 0xFFFF) + ',' + str((self.v0 >> 32) & 0xFFFF) + ',' + str(self.v0 >> 48) + ',' + str(self.v1 & 0xFFFF) + ',' + str((self.v1 >> 16) & 0xFFFF) + ',' + str((self.v1 >> 32) & 0xFFFF) + ',' + str(self.v1 >> 48) + '}; x') - elif index == 3: - return self.valobj.CreateValueFromExpression('i16x8', 'int16_t x[8] = {(int16_t)' + str(self.v0 & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v0 >> 48) + ',(int16_t)' + str(self.v1 & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v1 >> 48) + '}; x') - elif index == 4: - return self.valobj.CreateValueFromExpression('u32x4', 'uint32_t x[4] = {' + str(self.v0 & 0xFFFFFFFF) + ',' + str(self.v0 >> 32) + ',' + str(self.v1 & 0xFFFFFFFF) + ',' + str(self.v1 >> 32) + '}; x') - elif index == 5: - return self.valobj.CreateValueFromExpression('i32x4', 'int32_t x[4] = {(int32_t)' + str(self.v0 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v0 >> 32) + ',(int32_t)' + str(self.v1 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v1 >> 32) + '}; x') - elif index == 6: - return self.valobj.CreateValueFromExpression('u64x2', 'uint64_t x[2] = {' + str(self.v0) + ',' + str(self.v1) + '}; x') - elif index == 7: - return self.valobj.CreateValueFromExpression('i64x2', 'int64_t x[2] = {(int64_t)' + str(self.v0) + ',(int64_t)' + str(self.v1) + '}; x') - else: - return None - -class Simd256Printer: - def __init__(self, valobj, internal_dict): - self.valobj = valobj - - def update(self): - self.v0 = self.valobj.GetChildAtIndex(0).GetValueAsUnsigned() - self.v1 = self.valobj.GetChildAtIndex(1).GetValueAsUnsigned() - self.v2 = self.valobj.GetChildAtIndex(2).GetValueAsUnsigned() - self.v3 = self.valobj.GetChildAtIndex(3).GetValueAsUnsigned() - - def num_children(self): - return 8 - - def get_child_index(self, name): - return int(name.lstrip('[').rstrip(']')) - - def get_child_at_index(self, index): - if index == 0: - return self.valobj.CreateValueFromExpression('u8x32', 'uint16_t x[32] = {' + str(self.v0 & 0xFF) + ',' + str((self.v0 >> 8) & 0xFF) + ',' + str((self.v0 >> 16) & 0xFF) + ',' + str((self.v0 >> 24) & 0xFF) + ',' + str((self.v0 >> 32) & 0xFF) + ',' + str((self.v0 >> 40) & 0xFF) + ',' + str((self.v0 >> 48) & 0xFF) + ',' + str(self.v0 >> 56) + ',' + str(self.v1 & 0xFF) + ',' + str((self.v1 >> 8) & 0xFF) + ',' + str((self.v1 >> 16) & 0xFF) + ',' + str((self.v1 >> 24) & 0xFF) + ',' + str((self.v1 >> 32) & 0xFF) + ',' + str((self.v1 >> 40) & 0xFF) + ',' + str((self.v1 >> 48) & 0xFF) + ',' + str(self.v1 >> 56) + ',' + str(self.v2 & 0xFF) + ',' + str((self.v2 >> 8) & 0xFF) + ',' + str((self.v2 >> 16) & 0xFF) + ',' + str((self.v2 >> 24) & 0xFF) + ',' + str((self.v2 >> 32) & 0xFF) + ',' + str((self.v2 >> 40) & 0xFF) + ',' + str((self.v2 >> 48) & 0xFF) + ',' + str(self.v2 >> 56) + ',' + str(self.v3 & 0xFF) + ',' + str((self.v3 >> 8) & 0xFF) + ',' + str((self.v3 >> 16) & 0xFF) + ',' + str((self.v3 >> 24) & 0xFF) + ',' + str((self.v3 >> 32) & 0xFF) + ',' + str((self.v3 >> 40) & 0xFF) + ',' + str((self.v3 >> 48) & 0xFF) + ',' + str(self.v3 >> 56) + '}; x') - elif index == 1: - return self.valobj.CreateValueFromExpression('i8x32', 'int16_t x[32] = {(int8_t)' + str(self.v0 & 0xFF) + ',(int8_t)' + str((self.v0 >> 8) & 0xFF) + ',(int8_t)' + str((self.v0 >> 16) & 0xFF) + ',(int8_t)' + str((self.v0 >> 24) & 0xFF) + ',(int8_t)' + str((self.v0 >> 32) & 0xFF) + ',(int8_t)' + str((self.v0 >> 40) & 0xFF) + ',(int8_t)' + str((self.v0 >> 48) & 0xFF) + ',(int8_t)' + str(self.v0 >> 56) + ',(int8_t)' + str(self.v1 & 0xFF) + ',(int8_t)' + str((self.v1 >> 8) & 0xFF) + ',(int8_t)' + str((self.v1 >> 16) & 0xFF) + ',(int8_t)' + str((self.v1 >> 24) & 0xFF) + ',(int8_t)' + str((self.v1 >> 32) & 0xFF) + ',(int8_t)' + str((self.v1 >> 40) & 0xFF) + ',(int8_t)' + str((self.v1 >> 48) & 0xFF) + ',(int8_t)' + str(self.v1 >> 56) + ',(int8_t)' + str(self.v2 & 0xFF) + ',(int8_t)' + str((self.v2 >> 8) & 0xFF) + ',(int8_t)' + str((self.v2 >> 16) & 0xFF) + ',(int8_t)' + str((self.v2 >> 24) & 0xFF) + ',(int8_t)' + str((self.v2 >> 32) & 0xFF) + ',(int8_t)' + str((self.v2 >> 40) & 0xFF) + ',(int8_t)' + str((self.v2 >> 48) & 0xFF) + ',(int8_t)' + str(self.v2 >> 56) + ',(int8_t)' + str(self.v3 & 0xFF) + ',(int8_t)' + str((self.v3 >> 8) & 0xFF) + ',(int8_t)' + str((self.v3 >> 16) & 0xFF) + ',(int8_t)' + str((self.v3 >> 24) & 0xFF) + ',(int8_t)' + str((self.v3 >> 32) & 0xFF) + ',(int8_t)' + str((self.v3 >> 40) & 0xFF) + ',(int8_t)' + str((self.v3 >> 48) & 0xFF) + ',(int8_t)' + str(self.v3 >> 56) + '}; x') - elif index == 2: - return self.valobj.CreateValueFromExpression('u16x16', 'uint16_t x[16] = {' + str(self.v0 & 0xFFFF) + ',' + str((self.v0 >> 16) & 0xFFFF) + ',' + str((self.v0 >> 32) & 0xFFFF) + ',' + str(self.v0 >> 48) + ',' + str(self.v1 & 0xFFFF) + ',' + str((self.v1 >> 16) & 0xFFFF) + ',' + str((self.v1 >> 32) & 0xFFFF) + ',' + str(self.v1 >> 48) + ',' + str(self.v2 & 0xFFFF) + ',' + str((self.v2 >> 16) & 0xFFFF) + ',' + str((self.v2 >> 32) & 0xFFFF) + ',' + str(self.v2 >> 48) + ',' + str(self.v3 & 0xFFFF) + ',' + str((self.v3 >> 16) & 0xFFFF) + ',' + str((self.v3 >> 32) & 0xFFFF) + ',' + str(self.v3 >> 48) + '}; x') - elif index == 3: - return self.valobj.CreateValueFromExpression('i16x16', 'int16_t x[16] = {(int16_t)' + str(self.v0 & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v0 >> 48) + ',(int16_t)' + str(self.v1 & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v1 >> 48) + ',(int16_t)' + str(self.v2 & 0xFFFF) + ',(int16_t)' + str((self.v2 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v2 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v2 >> 48) + ',(int16_t)' + str(self.v3 & 0xFFFF) + ',(int16_t)' + str((self.v3 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v3 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v3 >> 48) + '}; x') - elif index == 4: - return self.valobj.CreateValueFromExpression('u32x8', 'uint32_t x[8] = {' + str(self.v0 & 0xFFFFFFFF) + ',' + str(self.v0 >> 32) + ',' + str(self.v1 & 0xFFFFFFFF) + ',' + str(self.v1 >> 32) + ',' + str(self.v2 & 0xFFFFFFFF) + ',' + str(self.v2 >> 32) + ',' + str(self.v3 & 0xFFFFFFFF) + ',' + str(self.v3 >> 32) + '}; x') - elif index == 5: - return self.valobj.CreateValueFromExpression('i32x8', 'int32_t x[8] = {(int32_t)' + str(self.v0 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v0 >> 32) + ',(int32_t)' + str(self.v1 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v1 >> 32) + ',(int32_t)' + str(self.v2 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v2 >> 32) + ',(int32_t)' + str(self.v3 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v3 >> 32) + '}; x') - elif index == 6: - return self.valobj.CreateValueFromExpression('u64x4', 'uint64_t x[4] = {' + str(self.v0) + ',' + str(self.v1) + ',' + str(self.v2) + ',' + str(self.v3) + '}; x') - elif index == 7: - return self.valobj.CreateValueFromExpression('i64x4', 'int64_t x[4] = {(int64_t)' + str(self.v0) + ',(int64_t)' + str(self.v1) + ',(int64_t)' + str(self.v2) + ',(int64_t)' + str(self.v3) + '}; x') - else: - return None - -class Simd512Printer: - def __init__(self, valobj, internal_dict): - self.valobj = valobj - - def update(self): - self.v0 = self.valobj.GetChildAtIndex(0).GetValueAsUnsigned() - self.v1 = self.valobj.GetChildAtIndex(1).GetValueAsUnsigned() - self.v2 = self.valobj.GetChildAtIndex(2).GetValueAsUnsigned() - self.v3 = self.valobj.GetChildAtIndex(3).GetValueAsUnsigned() - self.v4 = self.valobj.GetChildAtIndex(4).GetValueAsUnsigned() - self.v5 = self.valobj.GetChildAtIndex(5).GetValueAsUnsigned() - self.v6 = self.valobj.GetChildAtIndex(6).GetValueAsUnsigned() - self.v7 = self.valobj.GetChildAtIndex(7).GetValueAsUnsigned() - - def num_children(self): - return 8 - - def get_child_index(self, name): - return int(name.lstrip('[').rstrip(']')) - - def get_child_at_index(self, index): - if index == 0: - return self.valobj.CreateValueFromExpression('u8x64', 'uint16_t x[64] = {' + str(self.v0 & 0xFF) + ',' + str((self.v0 >> 8) & 0xFF) + ',' + str((self.v0 >> 16) & 0xFF) + ',' + str((self.v0 >> 24) & 0xFF) + ',' + str((self.v0 >> 32) & 0xFF) + ',' + str((self.v0 >> 40) & 0xFF) + ',' + str((self.v0 >> 48) & 0xFF) + ',' + str(self.v0 >> 56) + ',' + str(self.v1 & 0xFF) + ',' + str((self.v1 >> 8) & 0xFF) + ',' + str((self.v1 >> 16) & 0xFF) + ',' + str((self.v1 >> 24) & 0xFF) + ',' + str((self.v1 >> 32) & 0xFF) + ',' + str((self.v1 >> 40) & 0xFF) + ',' + str((self.v1 >> 48) & 0xFF) + ',' + str(self.v1 >> 56) + ',' + str(self.v2 & 0xFF) + ',' + str((self.v2 >> 8) & 0xFF) + ',' + str((self.v2 >> 16) & 0xFF) + ',' + str((self.v2 >> 24) & 0xFF) + ',' + str((self.v2 >> 32) & 0xFF) + ',' + str((self.v2 >> 40) & 0xFF) + ',' + str((self.v2 >> 48) & 0xFF) + ',' + str(self.v2 >> 56) + ',' + str(self.v3 & 0xFF) + ',' + str((self.v3 >> 8) & 0xFF) + ',' + str((self.v3 >> 16) & 0xFF) + ',' + str((self.v3 >> 24) & 0xFF) + ',' + str((self.v3 >> 32) & 0xFF) + ',' + str((self.v3 >> 40) & 0xFF) + ',' + str((self.v3 >> 48) & 0xFF) + ',' + str(self.v3 >> 56) + ',' + str(self.v4 & 0xFF) + ',' + str((self.v4 >> 8) & 0xFF) + ',' + str((self.v4 >> 16) & 0xFF) + ',' + str((self.v4 >> 24) & 0xFF) + ',' + str((self.v4 >> 32) & 0xFF) + ',' + str((self.v4 >> 40) & 0xFF) + ',' + str((self.v4 >> 48) & 0xFF) + ',' + str(self.v4 >> 56) + ',' + str(self.v5 & 0xFF) + ',' + str((self.v5 >> 8) & 0xFF) + ',' + str((self.v5 >> 16) & 0xFF) + ',' + str((self.v5 >> 24) & 0xFF) + ',' + str((self.v5 >> 32) & 0xFF) + ',' + str((self.v5 >> 40) & 0xFF) + ',' + str((self.v5 >> 48) & 0xFF) + ',' + str(self.v5 >> 56) + ',' + str(self.v6 & 0xFF) + ',' + str((self.v6 >> 8) & 0xFF) + ',' + str((self.v6 >> 16) & 0xFF) + ',' + str((self.v6 >> 24) & 0xFF) + ',' + str((self.v6 >> 32) & 0xFF) + ',' + str((self.v6 >> 40) & 0xFF) + ',' + str((self.v6 >> 48) & 0xFF) + ',' + str(self.v6 >> 56) + ',' + str(self.v7 & 0xFF) + ',' + str((self.v7 >> 8) & 0xFF) + ',' + str((self.v7 >> 16) & 0xFF) + ',' + str((self.v7 >> 24) & 0xFF) + ',' + str((self.v7 >> 32) & 0xFF) + ',' + str((self.v7 >> 40) & 0xFF) + ',' + str((self.v7 >> 48) & 0xFF) + ',' + str(self.v7 >> 56) + '}; x') - elif index == 1: - return self.valobj.CreateValueFromExpression('i8x64', 'int16_t x[64] = {(int8_t)' + str(self.v0 & 0xFF) + ',(int8_t)' + str((self.v0 >> 8) & 0xFF) + ',(int8_t)' + str((self.v0 >> 16) & 0xFF) + ',(int8_t)' + str((self.v0 >> 24) & 0xFF) + ',(int8_t)' + str((self.v0 >> 32) & 0xFF) + ',(int8_t)' + str((self.v0 >> 40) & 0xFF) + ',(int8_t)' + str((self.v0 >> 48) & 0xFF) + ',(int8_t)' + str(self.v0 >> 56) + ',(int8_t)' + str(self.v1 & 0xFF) + ',(int8_t)' + str((self.v1 >> 8) & 0xFF) + ',(int8_t)' + str((self.v1 >> 16) & 0xFF) + ',(int8_t)' + str((self.v1 >> 24) & 0xFF) + ',(int8_t)' + str((self.v1 >> 32) & 0xFF) + ',(int8_t)' + str((self.v1 >> 40) & 0xFF) + ',(int8_t)' + str((self.v1 >> 48) & 0xFF) + ',(int8_t)' + str(self.v1 >> 56) + ',(int8_t)' + str(self.v2 & 0xFF) + ',(int8_t)' + str((self.v2 >> 8) & 0xFF) + ',(int8_t)' + str((self.v2 >> 16) & 0xFF) + ',(int8_t)' + str((self.v2 >> 24) & 0xFF) + ',(int8_t)' + str((self.v2 >> 32) & 0xFF) + ',(int8_t)' + str((self.v2 >> 40) & 0xFF) + ',(int8_t)' + str((self.v2 >> 48) & 0xFF) + ',(int8_t)' + str(self.v2 >> 56) + ',(int8_t)' + str(self.v3 & 0xFF) + ',(int8_t)' + str((self.v3 >> 8) & 0xFF) + ',(int8_t)' + str((self.v3 >> 16) & 0xFF) + ',(int8_t)' + str((self.v3 >> 24) & 0xFF) + ',(int8_t)' + str((self.v3 >> 32) & 0xFF) + ',(int8_t)' + str((self.v3 >> 40) & 0xFF) + ',(int8_t)' + str((self.v3 >> 48) & 0xFF) + ',(int8_t)' + str(self.v3 >> 56) + ',(int8_t)' + str(self.v4 & 0xFF) + ',(int8_t)' + str((self.v4 >> 8) & 0xFF) + ',(int8_t)' + str((self.v4 >> 16) & 0xFF) + ',(int8_t)' + str((self.v4 >> 24) & 0xFF) + ',(int8_t)' + str((self.v4 >> 32) & 0xFF) + ',(int8_t)' + str((self.v4 >> 40) & 0xFF) + ',(int8_t)' + str((self.v4 >> 48) & 0xFF) + ',(int8_t)' + str(self.v4 >> 56) + ',(int8_t)' + str(self.v5 & 0xFF) + ',(int8_t)' + str((self.v5 >> 8) & 0xFF) + ',(int8_t)' + str((self.v5 >> 16) & 0xFF) + ',(int8_t)' + str((self.v5 >> 24) & 0xFF) + ',(int8_t)' + str((self.v5 >> 32) & 0xFF) + ',(int8_t)' + str((self.v5 >> 40) & 0xFF) + ',(int8_t)' + str((self.v5 >> 48) & 0xFF) + ',(int8_t)' + str(self.v5 >> 56) + ',(int8_t)' + str(self.v6 & 0xFF) + ',(int8_t)' + str((self.v6 >> 8) & 0xFF) + ',(int8_t)' + str((self.v6 >> 16) & 0xFF) + ',(int8_t)' + str((self.v6 >> 24) & 0xFF) + ',(int8_t)' + str((self.v6 >> 32) & 0xFF) + ',(int8_t)' + str((self.v6 >> 40) & 0xFF) + ',(int8_t)' + str((self.v6 >> 48) & 0xFF) + ',(int8_t)' + str(self.v6 >> 56) + ',(int8_t)' + str(self.v7 & 0xFF) + ',(int8_t)' + str((self.v7 >> 8) & 0xFF) + ',(int8_t)' + str((self.v7 >> 16) & 0xFF) + ',(int8_t)' + str((self.v7 >> 24) & 0xFF) + ',(int8_t)' + str((self.v7 >> 32) & 0xFF) + ',(int8_t)' + str((self.v7 >> 40) & 0xFF) + ',(int8_t)' + str((self.v7 >> 48) & 0xFF) + ',(int8_t)' + str(self.v7 >> 56) + '}; x') - elif index == 2: - return self.valobj.CreateValueFromExpression('u16x32', 'uint16_t x[32] = {' + str(self.v0 & 0xFFFF) + ',' + str((self.v0 >> 16) & 0xFFFF) + ',' + str((self.v0 >> 32) & 0xFFFF) + ',' + str(self.v0 >> 48) + ',' + str(self.v1 & 0xFFFF) + ',' + str((self.v1 >> 16) & 0xFFFF) + ',' + str((self.v1 >> 32) & 0xFFFF) + ',' + str(self.v1 >> 48) + ',' + str(self.v2 & 0xFFFF) + ',' + str((self.v2 >> 16) & 0xFFFF) + ',' + str((self.v2 >> 32) & 0xFFFF) + ',' + str(self.v2 >> 48) + ',' + str(self.v3 & 0xFFFF) + ',' + str((self.v3 >> 16) & 0xFFFF) + ',' + str((self.v3 >> 32) & 0xFFFF) + ',' + str(self.v3 >> 48) + ',' + str(self.v4 & 0xFFFF) + ',' + str((self.v4 >> 16) & 0xFFFF) + ',' + str((self.v4 >> 32) & 0xFFFF) + ',' + str(self.v4 >> 48) + ',' + str(self.v5 & 0xFFFF) + ',' + str((self.v5 >> 16) & 0xFFFF) + ',' + str((self.v5 >> 32) & 0xFFFF) + ',' + str(self.v5 >> 48) + ',' + str(self.v6 & 0xFFFF) + ',' + str((self.v6 >> 16) & 0xFFFF) + ',' + str((self.v6 >> 32) & 0xFFFF) + ',' + str(self.v6 >> 48) + ',' + str(self.v7 & 0xFFFF) + ',' + str((self.v7 >> 16) & 0xFFFF) + ',' + str((self.v7 >> 32) & 0xFFFF) + ',' + str(self.v7 >> 48) + '}; x') - elif index == 3: - return self.valobj.CreateValueFromExpression('i16x32', 'int16_t x[32] = {(int16_t)' + str(self.v0 & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v0 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v0 >> 48) + ',(int16_t)' + str(self.v1 & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v1 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v1 >> 48) + ',(int16_t)' + str(self.v2 & 0xFFFF) + ',(int16_t)' + str((self.v2 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v2 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v2 >> 48) + ',(int16_t)' + str(self.v3 & 0xFFFF) + ',(int16_t)' + str((self.v3 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v3 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v3 >> 48) + ',(int16_t)' + str(self.v4 & 0xFFFF) + ',(int16_t)' + str((self.v4 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v4 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v4 >> 48) + ',(int16_t)' + str(self.v5 & 0xFFFF) + ',(int16_t)' + str((self.v5 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v5 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v5 >> 48) + ',(int16_t)' + str(self.v6 & 0xFFFF) + ',(int16_t)' + str((self.v6 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v6 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v6 >> 48) + ',(int16_t)' + str(self.v7 & 0xFFFF) + ',(int16_t)' + str((self.v7 >> 16) & 0xFFFF) + ',(int16_t)' + str((self.v7 >> 32) & 0xFFFF) + ',(int16_t)' + str(self.v7 >> 48) + '}; x') - elif index == 4: - return self.valobj.CreateValueFromExpression('u32x16', 'uint32_t x[16] = {' + str(self.v0 & 0xFFFFFFFF) + ',' + str(self.v0 >> 32) + ',' + str(self.v1 & 0xFFFFFFFF) + ',' + str(self.v1 >> 32) + ',' + str(self.v2 & 0xFFFFFFFF) + ',' + str(self.v2 >> 32) + ',' + str(self.v3 & 0xFFFFFFFF) + ',' + str(self.v3 >> 32) + ',' + str(self.v4 & 0xFFFFFFFF) + ',' + str(self.v4 >> 32) + ',' + str(self.v5 & 0xFFFFFFFF) + ',' + str(self.v5 >> 32) + ',' + str(self.v6 & 0xFFFFFFFF) + ',' + str(self.v6 >> 32) + ',' + str(self.v7 & 0xFFFFFFFF) + ',' + str(self.v7 >> 32) + '}; x') - elif index == 5: - return self.valobj.CreateValueFromExpression('i32x16', 'int32_t x[16] = {(int32_t)' + str(self.v0 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v0 >> 32) + ',(int32_t)' + str(self.v1 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v1 >> 32) + ',(int32_t)' + str(self.v2 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v2 >> 32) + ',(int32_t)' + str(self.v3 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v3 >> 32) + ',(int32_t)' + str(self.v4 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v4 >> 32) + ',(int32_t)' + str(self.v5 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v5 >> 32) + ',(int32_t)' + str(self.v6 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v6 >> 32) + ',(int32_t)' + str(self.v7 & 0xFFFFFFFF) + ',(int32_t)' + str(self.v7 >> 32) + '}; x') - elif index == 6: - return self.valobj.CreateValueFromExpression('u64x8', 'uint64_t x[8] = {' + str(self.v0) + ',' + str(self.v1) + ',' + str(self.v2) + ',' + str(self.v3) + ',' + str(self.v4) + ',' + str(self.v5) + ',' + str(self.v6) + ',' + str(self.v7) + '}; x') - elif index == 7: - return self.valobj.CreateValueFromExpression('i64x8', 'int64_t x[8] = {(int64_t)' + str(self.v0) + ',(int64_t)' + str(self.v1) + ',(int64_t)' + str(self.v2) + ',(int64_t)' + str(self.v3) + ',(int64_t)' + str(self.v4) + ',(int64_t)' + str(self.v5) + ',(int64_t)' + str(self.v6) + ',(int64_t)' + str(self.v7) + '}; x') - else: - return None - -def __lldb_init_module(debugger, dict): - debugger.HandleCommand('type synthetic add -w simd -l simd.Simd128Printer __m128i') - debugger.HandleCommand('type synthetic add -w simd -l simd.Simd256Printer __m256i') - debugger.HandleCommand('type synthetic add -w simd -l simd.Simd512Printer __m512i') - debugger.HandleCommand('type category enable simd') - debugger.HandleCommand('type category disable VectorTypes') From 410fac6a25898981dd5dbe8632b728f04de9473f Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Wed, 19 Aug 2026 21:29:38 -0300 Subject: [PATCH 12/14] Transcode DXT1 to ETC2_RGB --- code/bmpman/bmpman.cpp | 4 ++++ code/ddsutils/ddsutils.cpp | 40 +++++++++++++++++++++++--------------- code/ddsutils/ddsutils.h | 1 + 3 files changed, 29 insertions(+), 16 deletions(-) diff --git a/code/bmpman/bmpman.cpp b/code/bmpman/bmpman.cpp index 77f8b0be69e..376c23fb952 100644 --- a/code/bmpman/bmpman.cpp +++ b/code/bmpman/bmpman.cpp @@ -1158,6 +1158,10 @@ static int bm_load_info(BM_TYPE type, const char *filename, CFILE *img_cfp, int *c_type = BM_TYPE_ETC2_RGBA_EAC; break; + case DDS_ETC2_RGB: + *c_type = BM_TYPE_ETC2_RGB; + break; + case DDS_UNCOMPRESSED: *c_type = BM_TYPE_DDS; break; diff --git a/code/ddsutils/ddsutils.cpp b/code/ddsutils/ddsutils.cpp index c4dd8eb0782..2c1b6bce288 100644 --- a/code/ddsutils/ddsutils.cpp +++ b/code/ddsutils/ddsutils.cpp @@ -91,16 +91,14 @@ static dds_conv_target dds_get_conversion_target(const DDS_HEADER &dds_header) return dds_conv_target::bgra; } -static size_t compute_etc2_rgba_size(const DDS_HEADER &dds_header) +static size_t compute_etc2_size(const DDS_HEADER& dds_header, uint block_bytes) { size_t total = 0; - for (uint i = 0; i < dds_header.dwMipMapCount; i++) { const uint w = std::max(1U, dds_header.dwWidth >> i); const uint h = std::max(1U, dds_header.dwHeight >> i); - total += static_cast((w + 3) / 4) * ((h + 3) / 4) * 16; + total += (size_t)((w + 3) / 4) * ((h + 3) / 4) * block_bytes; } - return total; } @@ -406,7 +404,7 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh dds_header.dwMipMapCount -= conversion_resize(dds_header, dds_conv_target::etc2); dds_header.dwMipMapCount = std::max(1U, dds_header.dwMipMapCount); - ct = DDS_ETC2_RGBA8; + ct = (ct == DDS_DXT1) ? DDS_ETC2_RGB : DDS_ETC2_RGBA8; } else if (convert) { // switch to uncompressed format and reset vars dds_header.ddspf.dwFlags &= ~DDPF_FOURCC; @@ -430,7 +428,7 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh // stuff important info if (size) { if (conv_target == dds_conv_target::etc2) - *size = compute_etc2_rgba_size(dds_header); + *size = compute_etc2_size(dds_header, (ct == DDS_ETC2_RGB) ? 8u : 16u); else *size = compute_dds_size(dds_header, convert); } @@ -518,11 +516,15 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) const uint mipmap_offset = conversion_resize(dds_header, dds_conv_target::etc2); const uint out_mips = orig_mips - mipmap_offset; + const bool is_dxt1 = (dds_header.ddspf.dwFourCC == FOURCC_DXT1); + const uint out_block_bytes = is_dxt1 ? 8u : 16u; + const int cache_fmt = is_dxt1 ? DDS_ETC2_RGB : DDS_ETC2_RGBA8; + size_t etc2_size = 0; for (uint m = 0; m < out_mips; ++m) { const uint w = std::max(1U, dds_header.dwWidth >> m); const uint h = std::max(1U, dds_header.dwHeight >> m); - etc2_size += (size_t)((w + 3) / 4) * ((h + 3) / 4) * 16; + etc2_size += (size_t)((w + 3) / 4) * ((h + 3) / 4) * out_block_bytes; } extern bool Cmdline_no_transcode_cache; @@ -530,12 +532,12 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) if (!Cmdline_no_transcode_cache) { //Build the cache MD5 hash - key = etc2_cache_make_key(cfp, dds_header.ddspf.dwFourCC, DDS_ETC2_RGBA8, static_cast(etc2_size)); + key = etc2_cache_make_key(cfp, dds_header.ddspf.dwFourCC, cache_fmt, static_cast(etc2_size)); //Try to load from a cache file - if (etc2_cache_try_load(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, DDS_ETC2_RGBA8, etc2_size, data)) { + if (etc2_cache_try_load(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, cache_fmt, etc2_size, data)) { if (bpp) - *bpp = (ubyte)32; + *bpp = is_dxt1 ? (ubyte)24 : (ubyte)32; cfclose(cfp); return DDS_ERROR_NONE; } @@ -597,7 +599,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) } } - // R<->B + // etcpak wants BGRA -> swap R<->B const size_t px_count = (size_t)pw * ph; for (size_t p = 0; p < px_count; ++p) { ubyte* px = rgba + p * 4; @@ -607,14 +609,20 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) } const uint32_t blocks = (pw / 4) * (ph / 4); - CompressEtc2Rgba(reinterpret_cast(rgba), reinterpret_cast(data + out_offset), blocks, pw, true); - // bump data offset to next layer - out_offset += (size_t)blocks * 16; + + if (is_dxt1) { + CompressEtc2Rgb(reinterpret_cast(rgba), reinterpret_cast(data + out_offset), blocks, pw, true); + } + else { + CompressEtc2Rgba(reinterpret_cast(rgba), reinterpret_cast(data + out_offset), blocks, pw, true); + } + + out_offset += (size_t)blocks * out_block_bytes; } if (!Cmdline_no_transcode_cache) { //Save to cache - etc2_cache_store(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, DDS_ETC2_RGBA8, data, etc2_size); + etc2_cache_store(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, cache_fmt, data, etc2_size); } vm_free(rgba); vm_free(comp_data); @@ -709,7 +717,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) } if (bpp) - *bpp = (tgt == dds_conv_target::etc2) ? (ubyte)32 : (ubyte)get_bit_count(dds_header); + *bpp = (ubyte)get_bit_count(dds_header); // we look done here cfclose(cfp); diff --git a/code/ddsutils/ddsutils.h b/code/ddsutils/ddsutils.h index c15a436fe01..9d858feb2f3 100644 --- a/code/ddsutils/ddsutils.h +++ b/code/ddsutils/ddsutils.h @@ -29,6 +29,7 @@ #define DDS_CUBEMAP_DXT3 13 #define DDS_CUBEMAP_DXT5 15 #define DDS_ETC2_RGBA8 20 +#define DDS_ETC2_RGB 21 #ifndef MAKEFOURCC #define MAKEFOURCC(ch0, ch1, ch2, ch3) \ From eae044a379bdb6bac2011ae0b5f434a9d3c826d1 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 22 Aug 2026 15:07:21 -0300 Subject: [PATCH 13/14] refactor cache system --- code/ddsutils/ddsutils.cpp | 8 +- code/ddsutils/ddsutils_etc_cache.h | 19 - code/graphics/opengl/es_compatibility.h | 1 + code/graphics/opengl/gropengl.cpp | 8 +- code/source_groups.cmake | 8 +- .../tex_cache.cpp} | 77 +- code/texcache/tex_cache.h | 24 + freespace2/freespace.cpp | 4 +- lib/etcpak/CMakeLists.txt | 4 +- lib/etcpak/etcpak/ProcessDxtc.cpp | 1122 +++++++++++++++++ lib/etcpak/etcpak/ProcessDxtc.hpp | 18 + lib/etcpak/etcpak/README.md | 85 -- 12 files changed, 1221 insertions(+), 157 deletions(-) delete mode 100644 code/ddsutils/ddsutils_etc_cache.h rename code/{ddsutils/ddsutils_etc_cache.cpp => texcache/tex_cache.cpp} (70%) create mode 100644 code/texcache/tex_cache.h create mode 100644 lib/etcpak/etcpak/ProcessDxtc.cpp create mode 100644 lib/etcpak/etcpak/ProcessDxtc.hpp delete mode 100644 lib/etcpak/etcpak/README.md diff --git a/code/ddsutils/ddsutils.cpp b/code/ddsutils/ddsutils.cpp index 2c1b6bce288..23d641b66be 100644 --- a/code/ddsutils/ddsutils.cpp +++ b/code/ddsutils/ddsutils.cpp @@ -1,6 +1,6 @@ #include "ddsutils/ddsutils.h" -#include "ddsutils/ddsutils_etc_cache.h" +#include "texcache/tex_cache.h" #include "cfile/cfile.h" #include "graphics/2d.h" #include "osapi/osregistry.h" @@ -532,10 +532,10 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) if (!Cmdline_no_transcode_cache) { //Build the cache MD5 hash - key = etc2_cache_make_key(cfp, dds_header.ddspf.dwFourCC, cache_fmt, static_cast(etc2_size)); + key = tex_cache_make_key(cfp, TEX_CACHE_TYPE_ETC2, dds_header.ddspf.dwFourCC, cache_fmt, static_cast(etc2_size)); //Try to load from a cache file - if (etc2_cache_try_load(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, cache_fmt, etc2_size, data)) { + if (tex_cache_try_load(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, cache_fmt, etc2_size, data)) { if (bpp) *bpp = is_dxt1 ? (ubyte)24 : (ubyte)32; cfclose(cfp); @@ -622,7 +622,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type) if (!Cmdline_no_transcode_cache) { //Save to cache - etc2_cache_store(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, cache_fmt, data, etc2_size); + tex_cache_store(key, dds_header.dwWidth, dds_header.dwHeight, out_mips, cache_fmt, data, etc2_size); } vm_free(rgba); vm_free(comp_data); diff --git a/code/ddsutils/ddsutils_etc_cache.h b/code/ddsutils/ddsutils_etc_cache.h deleted file mode 100644 index f632a3a3ae2..00000000000 --- a/code/ddsutils/ddsutils_etc_cache.h +++ /dev/null @@ -1,19 +0,0 @@ -#ifndef _DDSUTILS_ETC_CACHE_H -#define _DDSUTILS_ETC_CACHE_H - -#include "globalincs/pstypes.h" -#include "cfile/cfile.h" - -// Clear the transcode cache if the total file size is over the limit -void etc2_cache_prune(); - -// Get the MD5 file hash for the dds texture -SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint etc2_size); - -// Load a transcoded texture from cache if present -bool etc2_cache_try_load(const SCP_string &key, uint expected_width, uint expected_height, uint expected_mips, int expected_format, size_t expected_size, ubyte *out_data); - -// Save a texture to cache for later use -void etc2_cache_store(const SCP_string &key, uint width, uint height, uint mips, int format, const ubyte *payload, size_t payload_size); - -#endif diff --git a/code/graphics/opengl/es_compatibility.h b/code/graphics/opengl/es_compatibility.h index a864be1545e..072a3b6169b 100644 --- a/code/graphics/opengl/es_compatibility.h +++ b/code/graphics/opengl/es_compatibility.h @@ -48,6 +48,7 @@ #define GLAD_GL_ARB_texture_storage GL_TRUE // ES 3.2 #define GLAD_GL_ARB_draw_buffers_blend GL_TRUE // ES 3.2 (glBlendFunci and glBlendEquationi) #define GLAD_GL_ARB_vertex_attrib_binding GL_TRUE // ES 3.1 +#define GLAD_GL_ARB_ES3_compatibility GL_TRUE //Functions Redefinitions #define glBlendFunciARB glBlendFunci // ES 3.2 diff --git a/code/graphics/opengl/gropengl.cpp b/code/graphics/opengl/gropengl.cpp index 01cfdede56e..454fafa4db0 100644 --- a/code/graphics/opengl/gropengl.cpp +++ b/code/graphics/opengl/gropengl.cpp @@ -1614,15 +1614,11 @@ bool gr_opengl_is_capable(gr_capability capability) case gr_capability::CAPABILITY_PERSISTENT_BUFFER_MAPPING: return GLAD_GL_ARB_buffer_storage != 0; case gr_capability::CAPABILITY_BPTC: - return GLAD_GL_ARB_texture_compression_bptc != 0; + return false;// GLAD_GL_ARB_texture_compression_bptc != 0; case gr_capability::CAPABILITY_S3TC: - return GLAD_GL_EXT_texture_compression_s3tc != 0; + return false;// GLAD_GL_EXT_texture_compression_s3tc != 0; case gr_capability::CAPABILITY_ETC2: -#ifdef USE_OPENGL_ES - return true; -#else return GLAD_GL_ARB_ES3_compatibility != 0; -#endif case gr_capability::CAPABILITY_LARGE_SHADER: return !Cmdline_no_large_shaders; case gr_capability::CAPABILITY_INSTANCED_RENDERING: diff --git a/code/source_groups.cmake b/code/source_groups.cmake index 09046652e56..9c142a04eb2 100644 --- a/code/source_groups.cmake +++ b/code/source_groups.cmake @@ -192,8 +192,12 @@ endif() add_file_folder("ddsutils" ddsutils/ddsutils.cpp ddsutils/ddsutils.h - ddsutils/ddsutils_etc_cache.cpp - ddsutils/ddsutils_etc_cache.h +) + +# texture transcode cache files +add_file_folder("texcache" + texcache/tex_cache.cpp + texcache/tex_cache.h ) # Debris files diff --git a/code/ddsutils/ddsutils_etc_cache.cpp b/code/texcache/tex_cache.cpp similarity index 70% rename from code/ddsutils/ddsutils_etc_cache.cpp rename to code/texcache/tex_cache.cpp index e8cb5be1006..583e5b844c1 100644 --- a/code/ddsutils/ddsutils_etc_cache.cpp +++ b/code/texcache/tex_cache.cpp @@ -1,4 +1,4 @@ -#include "ddsutils/ddsutils_etc_cache.h" +#include "texcache/tex_cache.h" #include "cfile/cfile.h" #include "options/Option.h" @@ -8,32 +8,32 @@ #include #include -#define ETC2_CACHE_VERSION_TAG "etc2-v1" -static constexpr uint ETC2_CACHE_MAGIC = 0x32435445u; -static constexpr uint ETC2_CACHE_VERSION = 1u; -static constexpr uint ETC2_CACHE_FLAG_LZ4 = 0x1u; -static constexpr int ETC2_CACHE_CHKSUM_WINDOW = 65536; +#define TEX_CACHE_VERSION_TAG "tex-v1" +static constexpr uint TEX_CACHE_MAGIC = 0x32435445u; +static constexpr uint TEX_CACHE_VERSION = 1u; +static constexpr uint TEX_CACHE_FLAG_LZ4 = 0x1u; +static constexpr int TEX_CACHE_CHKSUM_WINDOW = 65536; static const uint32_t CACHE_LOCATION_FLAGS = CF_LOCATION_ROOT_USER | CF_LOCATION_TYPE_ROOT; -static SCP_string etc2_cache_filename(const SCP_string &key) +static SCP_string tex_cache_filename(const SCP_string &key) { - return SCP_string("etc2-") + key + ".cache"; + return SCP_string("tex-") + key + ".cache"; } -static SCP_string etc2_cache_temp_filename(const SCP_string &key) +static SCP_string tex_cache_temp_filename(const SCP_string &key) { - return SCP_string("etc2-") + key + ".cache.tmp"; + return SCP_string("tex-") + key + ".cache.tmp"; } -SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint etc2_size) +SCP_string tex_cache_make_key(CFILE *dds, tex_cache_type cache_type, uint src_fourcc, int dst_format, uint tex_size) { const int saved_pos = cftell(dds); cfseek(dds, 0, CF_SEEK_SET); uint src_crc = 0; - cf_chksum_long(dds, &src_crc, ETC2_CACHE_CHKSUM_WINDOW); + cf_chksum_long(dds, &src_crc, TEX_CACHE_CHKSUM_WINDOW); const uint src_len = (uint)cfilelength(dds); @@ -45,21 +45,22 @@ SCP_string etc2_cache_make_key(CFILE *dds, uint src_fourcc, int dst_format, uint } MD5 md5; - md5.update(ETC2_CACHE_VERSION_TAG, (MD5::size_type)strlen(ETC2_CACHE_VERSION_TAG)); + md5.update(TEX_CACHE_VERSION_TAG, (MD5::size_type)strlen(TEX_CACHE_VERSION_TAG)); + md5.update(reinterpret_cast(&cache_type), sizeof(cache_type)); md5.update(name, (MD5::size_type)strlen(name)); md5.update(reinterpret_cast(&src_crc), sizeof(src_crc)); md5.update(reinterpret_cast(&src_len), sizeof(src_len)); md5.update(reinterpret_cast(&src_fourcc), sizeof(src_fourcc)); md5.update(reinterpret_cast(&dst_format), sizeof(dst_format)); - md5.update(reinterpret_cast(&etc2_size), sizeof(etc2_size)); + md5.update(reinterpret_cast(&tex_size), sizeof(tex_size)); md5.finalize(); return md5.hexdigest(); } -bool etc2_cache_try_load(const SCP_string &key, uint expected_width, uint expected_height, uint expected_mips, int expected_format, size_t expected_size, ubyte *out_data) +bool tex_cache_try_load(const SCP_string &key, uint expected_width, uint expected_height, uint expected_mips, int expected_format, size_t expected_size, ubyte *out_data) { - const SCP_string name = etc2_cache_filename(key); + const SCP_string name = tex_cache_filename(key); CFILE *fp = cfopen(name.c_str(), "rb", CF_TYPE_CACHE, false, CACHE_LOCATION_FLAGS); @@ -78,9 +79,9 @@ bool etc2_cache_try_load(const SCP_string &key, uint expected_width, uint expect const uint stored_size = cfread_uint(fp); const uint payload_crc = cfread_uint(fp); - const bool header_ok = (magic == ETC2_CACHE_MAGIC) && - (version == ETC2_CACHE_VERSION) && - ((flags & ~ETC2_CACHE_FLAG_LZ4) == 0) && + const bool header_ok = (magic == TEX_CACHE_MAGIC) && + (version == TEX_CACHE_VERSION) && + ((flags & ~TEX_CACHE_FLAG_LZ4) == 0) && (format == (uint)expected_format) && (width == expected_width) && (height == expected_height) && @@ -104,7 +105,7 @@ bool etc2_cache_try_load(const SCP_string &key, uint expected_width, uint expect bool ok = false; - if (flags & ETC2_CACHE_FLAG_LZ4) { + if (flags & TEX_CACHE_FLAG_LZ4) { const int dec = LZ4_decompress_safe(reinterpret_cast(stored.data()), reinterpret_cast(out_data), (int)stored_size, (int)payload_size); @@ -129,7 +130,7 @@ bool etc2_cache_try_load(const SCP_string &key, uint expected_width, uint expect return true; } -void etc2_cache_store(const SCP_string &key, uint width, uint height, uint mips, int format, const ubyte *payload, size_t payload_size) +void tex_cache_store(const SCP_string &key, uint width, uint height, uint mips, int format, const ubyte *payload, size_t payload_size) { if (payload == nullptr || payload_size == 0) { return; @@ -150,13 +151,13 @@ void etc2_cache_store(const SCP_string &key, uint width, uint height, uint mips, size_t out_size = payload_size; if ((csize > 0) && ((size_t)csize < payload_size)) { - flags = ETC2_CACHE_FLAG_LZ4; + flags = TEX_CACHE_FLAG_LZ4; out_buf = compressed.data(); out_size = (size_t)csize; } - const SCP_string temp_name = etc2_cache_temp_filename(key); - const SCP_string final_name = etc2_cache_filename(key); + const SCP_string temp_name = tex_cache_temp_filename(key); + const SCP_string final_name = tex_cache_filename(key); CFILE *fp = cfopen(temp_name.c_str(), "wb", CF_TYPE_CACHE, false, CACHE_LOCATION_FLAGS); @@ -164,8 +165,8 @@ void etc2_cache_store(const SCP_string &key, uint width, uint height, uint mips, return; } - cfwrite_uint(ETC2_CACHE_MAGIC, fp); - cfwrite_uint(ETC2_CACHE_VERSION, fp); + cfwrite_uint(TEX_CACHE_MAGIC, fp); + cfwrite_uint(TEX_CACHE_VERSION, fp); cfwrite_uint(flags, fp); cfwrite_uint((uint)format, fp); cfwrite_uint(width, fp); @@ -187,9 +188,9 @@ void etc2_cache_store(const SCP_string &key, uint width, uint height, uint mips, cf_rename(temp_name.c_str(), final_name.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); } -auto CacheSizeLimit = options::OptionBuilder("Graphics.EtcCacheSize", - std::pair{"ETC Transcode Cache", 1933}, - std::pair{"ETC2 transcode cache size in GBs. 0 for unlimited. Relevant for mobile GPUs lacking S3TC/BC7 support.", 1934}) +auto CacheSizeLimit = options::OptionBuilder("Graphics.TexCacheSize", + std::pair{"Texture Transcode Cache", 1933}, + std::pair{"Texture transcode cache size in GBs. 0 for unlimited. Mostly relevant for mobile GPUs lacking S3TC / BC7 support.", 1934}) .category(std::make_pair("Graphics", 1825)) .level(options::ExpertLevel::Advanced) .range(0.0f, 20.0f) @@ -197,29 +198,29 @@ auto CacheSizeLimit = options::OptionBuilder("Graphics.EtcCacheSize", .importance(0) .finish(); -void etc2_cache_prune() +void tex_cache_prune() { - auto max_bytes = (size_t)(CacheSizeLimit->getValue() * 1000000000); - - // unlimited cache - if (max_bytes <= 0) - return; - // Clear any incomplete .tmp file SCP_vector temps; - cf_get_file_list(temps, CF_TYPE_CACHE, "etc2-*.cache.tmp", CF_SORT_NONE, nullptr, CACHE_LOCATION_FLAGS); + cf_get_file_list(temps, CF_TYPE_CACHE, "tex-*.cache.tmp", CF_SORT_NONE, nullptr, CACHE_LOCATION_FLAGS); for (const auto& temp : temps) { const SCP_string tname = temp + ".tmp"; cf_delete(tname.c_str(), CF_TYPE_CACHE, CACHE_LOCATION_FLAGS); } + auto max_bytes = (size_t)(CacheSizeLimit->getValue() * 1000000000); + + // unlimited cache + if (max_bytes <= 0) + return; + // Check and clear cache SCP_vector names; SCP_vector info; - cf_get_file_list(names, CF_TYPE_CACHE, "etc2-*.cache", CF_SORT_NONE, &info, CACHE_LOCATION_FLAGS); + cf_get_file_list(names, CF_TYPE_CACHE, "tex-*.cache", CF_SORT_NONE, &info, CACHE_LOCATION_FLAGS); const size_t count = names.size(); diff --git a/code/texcache/tex_cache.h b/code/texcache/tex_cache.h new file mode 100644 index 00000000000..a0b50786855 --- /dev/null +++ b/code/texcache/tex_cache.h @@ -0,0 +1,24 @@ +#ifndef _TEX_CACHE_H +#define _TEX_CACHE_H + +#include "globalincs/pstypes.h" +#include "cfile/cfile.h" + +enum tex_cache_type { + TEX_CACHE_TYPE_ETC2 = 1000, + TEX_CACHE_TYPE_BC +}; + +// Clear the transcode cache if the total file size is over the limit +void tex_cache_prune(); + +// Get the MD5 key hash for the dds texture +SCP_string tex_cache_make_key(CFILE *dds, tex_cache_type cache_type, uint src_fourcc, int dst_format, uint tex_size); + +// Load a transcoded texture from cache if present +bool tex_cache_try_load(const SCP_string &key, uint expected_width, uint expected_height, uint expected_mips, int expected_format, size_t expected_size, ubyte *out_data); + +// Save a texture to cache for later use +void tex_cache_store(const SCP_string &key, uint width, uint height, uint mips, int format, const ubyte *payload, size_t payload_size); + +#endif diff --git a/freespace2/freespace.cpp b/freespace2/freespace.cpp index 9a0588987e6..3a8d9a44812 100644 --- a/freespace2/freespace.cpp +++ b/freespace2/freespace.cpp @@ -204,7 +204,7 @@ #include "weapon/muzzleflash.h" #include "weapon/shockwave.h" #include "weapon/weapon.h" -#include "ddsutils/ddsutils_etc_cache.h" +#include "texcache/tex_cache.h" #include @@ -1924,7 +1924,7 @@ void game_init() lcl_init( detect_lang() ); lcl_xstr_init(); - etc2_cache_prune(); // Clear ETC transcode cache + tex_cache_prune(); // Clear texture transcode cache if (Is_standalone) { // force off some cmdlines if they are on diff --git a/lib/etcpak/CMakeLists.txt b/lib/etcpak/CMakeLists.txt index ef3eac13c67..63793686b05 100644 --- a/lib/etcpak/CMakeLists.txt +++ b/lib/etcpak/CMakeLists.txt @@ -1,9 +1,11 @@ set(ETCPAK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/etcpak") +# Note: BC7 encoder was commented out in ProcessDxtc as it needs C++20 and not included set(ETCPAK_SOURCES "${ETCPAK_DIR}/ProcessRGB.cpp" "${ETCPAK_DIR}/Tables.cpp" - "${ETCPAK_DIR}/Dither.cpp") + "${ETCPAK_DIR}/Dither.cpp" + "${ETCPAK_DIR}/ProcessDxtc.cpp") add_library(etcpak STATIC ${ETCPAK_SOURCES}) diff --git a/lib/etcpak/etcpak/ProcessDxtc.cpp b/lib/etcpak/etcpak/ProcessDxtc.cpp new file mode 100644 index 00000000000..5a782496404 --- /dev/null +++ b/lib/etcpak/etcpak/ProcessDxtc.cpp @@ -0,0 +1,1122 @@ +//#include "bc7enc.h" +#include "Dither.hpp" +#include "ForceInline.hpp" +#include "ProcessDxtc.hpp" + +#include +#include +#include + +#ifdef __ARM_NEON +# include +#endif + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#if defined __SSE4_1__ || defined __AVX2__ +# ifdef _MSC_VER +# include +# else +# include +# ifndef _mm256_cvtsi256_si32 +# define _mm256_cvtsi256_si32( v ) ( _mm_cvtsi128_si32( _mm256_castsi256_si128( v ) ) ) +# endif +# endif +#endif + + +static etcpak_force_inline uint16_t to565( uint8_t r, uint8_t g, uint8_t b ) +{ + return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( b >> 3 ); +} + +static etcpak_force_inline uint16_t to565( uint32_t c ) +{ + return + ( ( c & 0xF80000 ) >> 19 ) | + ( ( c & 0x00FC00 ) >> 5 ) | + ( ( c & 0x0000F8 ) << 8 ); +} + +static const uint8_t DxtcIndexTable[256] = { + 85, 87, 86, 84, 93, 95, 94, 92, 89, 91, 90, 88, 81, 83, 82, 80, + 117, 119, 118, 116, 125, 127, 126, 124, 121, 123, 122, 120, 113, 115, 114, 112, + 101, 103, 102, 100, 109, 111, 110, 108, 105, 107, 106, 104, 97, 99, 98, 96, + 69, 71, 70, 68, 77, 79, 78, 76, 73, 75, 74, 72, 65, 67, 66, 64, + 213, 215, 214, 212, 221, 223, 222, 220, 217, 219, 218, 216, 209, 211, 210, 208, + 245, 247, 246, 244, 253, 255, 254, 252, 249, 251, 250, 248, 241, 243, 242, 240, + 229, 231, 230, 228, 237, 239, 238, 236, 233, 235, 234, 232, 225, 227, 226, 224, + 197, 199, 198, 196, 205, 207, 206, 204, 201, 203, 202, 200, 193, 195, 194, 192, + 149, 151, 150, 148, 157, 159, 158, 156, 153, 155, 154, 152, 145, 147, 146, 144, + 181, 183, 182, 180, 189, 191, 190, 188, 185, 187, 186, 184, 177, 179, 178, 176, + 165, 167, 166, 164, 173, 175, 174, 172, 169, 171, 170, 168, 161, 163, 162, 160, + 133, 135, 134, 132, 141, 143, 142, 140, 137, 139, 138, 136, 129, 131, 130, 128, + 21, 23, 22, 20, 29, 31, 30, 28, 25, 27, 26, 24, 17, 19, 18, 16, + 53, 55, 54, 52, 61, 63, 62, 60, 57, 59, 58, 56, 49, 51, 50, 48, + 37, 39, 38, 36, 45, 47, 46, 44, 41, 43, 42, 40, 33, 35, 34, 32, + 5, 7, 6, 4, 13, 15, 14, 12, 9, 11, 10, 8, 1, 3, 2, 0 +}; + +static const uint8_t AlphaIndexTable_SSE[64] = { + 9, 15, 14, 13, 12, 11, 10, 8, 57, 63, 62, 61, 60, 59, 58, 56, + 49, 55, 54, 53, 52, 51, 50, 48, 41, 47, 46, 45, 44, 43, 42, 40, + 33, 39, 38, 37, 36, 35, 34, 32, 25, 31, 30, 29, 28, 27, 26, 24, + 17, 23, 22, 21, 20, 19, 18, 16, 1, 7, 6, 5, 4, 3, 2, 0, +}; + +static const uint16_t DivTable[255*3+1] = { + 0xffff, 0xffff, 0xffff, 0xffff, 0xcccc, 0xaaaa, 0x9249, 0x8000, 0x71c7, 0x6666, 0x5d17, 0x5555, 0x4ec4, 0x4924, 0x4444, 0x4000, + 0x3c3c, 0x38e3, 0x35e5, 0x3333, 0x30c3, 0x2e8b, 0x2c85, 0x2aaa, 0x28f5, 0x2762, 0x25ed, 0x2492, 0x234f, 0x2222, 0x2108, 0x2000, + 0x1f07, 0x1e1e, 0x1d41, 0x1c71, 0x1bac, 0x1af2, 0x1a41, 0x1999, 0x18f9, 0x1861, 0x17d0, 0x1745, 0x16c1, 0x1642, 0x15c9, 0x1555, + 0x14e5, 0x147a, 0x1414, 0x13b1, 0x1352, 0x12f6, 0x129e, 0x1249, 0x11f7, 0x11a7, 0x115b, 0x1111, 0x10c9, 0x1084, 0x1041, 0x1000, + 0x0fc0, 0x0f83, 0x0f48, 0x0f0f, 0x0ed7, 0x0ea0, 0x0e6c, 0x0e38, 0x0e07, 0x0dd6, 0x0da7, 0x0d79, 0x0d4c, 0x0d20, 0x0cf6, 0x0ccc, + 0x0ca4, 0x0c7c, 0x0c56, 0x0c30, 0x0c0c, 0x0be8, 0x0bc5, 0x0ba2, 0x0b81, 0x0b60, 0x0b40, 0x0b21, 0x0b02, 0x0ae4, 0x0ac7, 0x0aaa, + 0x0a8e, 0x0a72, 0x0a57, 0x0a3d, 0x0a23, 0x0a0a, 0x09f1, 0x09d8, 0x09c0, 0x09a9, 0x0991, 0x097b, 0x0964, 0x094f, 0x0939, 0x0924, + 0x090f, 0x08fb, 0x08e7, 0x08d3, 0x08c0, 0x08ad, 0x089a, 0x0888, 0x0876, 0x0864, 0x0853, 0x0842, 0x0831, 0x0820, 0x0810, 0x0800, + 0x07f0, 0x07e0, 0x07d1, 0x07c1, 0x07b3, 0x07a4, 0x0795, 0x0787, 0x0779, 0x076b, 0x075d, 0x0750, 0x0743, 0x0736, 0x0729, 0x071c, + 0x070f, 0x0703, 0x06f7, 0x06eb, 0x06df, 0x06d3, 0x06c8, 0x06bc, 0x06b1, 0x06a6, 0x069b, 0x0690, 0x0685, 0x067b, 0x0670, 0x0666, + 0x065c, 0x0652, 0x0648, 0x063e, 0x0634, 0x062b, 0x0621, 0x0618, 0x060f, 0x0606, 0x05fd, 0x05f4, 0x05eb, 0x05e2, 0x05d9, 0x05d1, + 0x05c9, 0x05c0, 0x05b8, 0x05b0, 0x05a8, 0x05a0, 0x0598, 0x0590, 0x0588, 0x0581, 0x0579, 0x0572, 0x056b, 0x0563, 0x055c, 0x0555, + 0x054e, 0x0547, 0x0540, 0x0539, 0x0532, 0x052b, 0x0525, 0x051e, 0x0518, 0x0511, 0x050b, 0x0505, 0x04fe, 0x04f8, 0x04f2, 0x04ec, + 0x04e6, 0x04e0, 0x04da, 0x04d4, 0x04ce, 0x04c8, 0x04c3, 0x04bd, 0x04b8, 0x04b2, 0x04ad, 0x04a7, 0x04a2, 0x049c, 0x0497, 0x0492, + 0x048d, 0x0487, 0x0482, 0x047d, 0x0478, 0x0473, 0x046e, 0x0469, 0x0465, 0x0460, 0x045b, 0x0456, 0x0452, 0x044d, 0x0448, 0x0444, + 0x043f, 0x043b, 0x0436, 0x0432, 0x042d, 0x0429, 0x0425, 0x0421, 0x041c, 0x0418, 0x0414, 0x0410, 0x040c, 0x0408, 0x0404, 0x0400, + 0x03fc, 0x03f8, 0x03f4, 0x03f0, 0x03ec, 0x03e8, 0x03e4, 0x03e0, 0x03dd, 0x03d9, 0x03d5, 0x03d2, 0x03ce, 0x03ca, 0x03c7, 0x03c3, + 0x03c0, 0x03bc, 0x03b9, 0x03b5, 0x03b2, 0x03ae, 0x03ab, 0x03a8, 0x03a4, 0x03a1, 0x039e, 0x039b, 0x0397, 0x0394, 0x0391, 0x038e, + 0x038b, 0x0387, 0x0384, 0x0381, 0x037e, 0x037b, 0x0378, 0x0375, 0x0372, 0x036f, 0x036c, 0x0369, 0x0366, 0x0364, 0x0361, 0x035e, + 0x035b, 0x0358, 0x0355, 0x0353, 0x0350, 0x034d, 0x034a, 0x0348, 0x0345, 0x0342, 0x0340, 0x033d, 0x033a, 0x0338, 0x0335, 0x0333, + 0x0330, 0x032e, 0x032b, 0x0329, 0x0326, 0x0324, 0x0321, 0x031f, 0x031c, 0x031a, 0x0317, 0x0315, 0x0313, 0x0310, 0x030e, 0x030c, + 0x0309, 0x0307, 0x0305, 0x0303, 0x0300, 0x02fe, 0x02fc, 0x02fa, 0x02f7, 0x02f5, 0x02f3, 0x02f1, 0x02ef, 0x02ec, 0x02ea, 0x02e8, + 0x02e6, 0x02e4, 0x02e2, 0x02e0, 0x02de, 0x02dc, 0x02da, 0x02d8, 0x02d6, 0x02d4, 0x02d2, 0x02d0, 0x02ce, 0x02cc, 0x02ca, 0x02c8, + 0x02c6, 0x02c4, 0x02c2, 0x02c0, 0x02be, 0x02bc, 0x02bb, 0x02b9, 0x02b7, 0x02b5, 0x02b3, 0x02b1, 0x02b0, 0x02ae, 0x02ac, 0x02aa, + 0x02a8, 0x02a7, 0x02a5, 0x02a3, 0x02a1, 0x02a0, 0x029e, 0x029c, 0x029b, 0x0299, 0x0297, 0x0295, 0x0294, 0x0292, 0x0291, 0x028f, + 0x028d, 0x028c, 0x028a, 0x0288, 0x0287, 0x0285, 0x0284, 0x0282, 0x0280, 0x027f, 0x027d, 0x027c, 0x027a, 0x0279, 0x0277, 0x0276, + 0x0274, 0x0273, 0x0271, 0x0270, 0x026e, 0x026d, 0x026b, 0x026a, 0x0268, 0x0267, 0x0265, 0x0264, 0x0263, 0x0261, 0x0260, 0x025e, + 0x025d, 0x025c, 0x025a, 0x0259, 0x0257, 0x0256, 0x0255, 0x0253, 0x0252, 0x0251, 0x024f, 0x024e, 0x024d, 0x024b, 0x024a, 0x0249, + 0x0247, 0x0246, 0x0245, 0x0243, 0x0242, 0x0241, 0x0240, 0x023e, 0x023d, 0x023c, 0x023b, 0x0239, 0x0238, 0x0237, 0x0236, 0x0234, + 0x0233, 0x0232, 0x0231, 0x0230, 0x022e, 0x022d, 0x022c, 0x022b, 0x022a, 0x0229, 0x0227, 0x0226, 0x0225, 0x0224, 0x0223, 0x0222, + 0x0220, 0x021f, 0x021e, 0x021d, 0x021c, 0x021b, 0x021a, 0x0219, 0x0218, 0x0216, 0x0215, 0x0214, 0x0213, 0x0212, 0x0211, 0x0210, + 0x020f, 0x020e, 0x020d, 0x020c, 0x020b, 0x020a, 0x0209, 0x0208, 0x0207, 0x0206, 0x0205, 0x0204, 0x0203, 0x0202, 0x0201, 0x0200, + 0x01ff, 0x01fe, 0x01fd, 0x01fc, 0x01fb, 0x01fa, 0x01f9, 0x01f8, 0x01f7, 0x01f6, 0x01f5, 0x01f4, 0x01f3, 0x01f2, 0x01f1, 0x01f0, + 0x01ef, 0x01ee, 0x01ed, 0x01ec, 0x01eb, 0x01ea, 0x01e9, 0x01e9, 0x01e8, 0x01e7, 0x01e6, 0x01e5, 0x01e4, 0x01e3, 0x01e2, 0x01e1, + 0x01e0, 0x01e0, 0x01df, 0x01de, 0x01dd, 0x01dc, 0x01db, 0x01da, 0x01da, 0x01d9, 0x01d8, 0x01d7, 0x01d6, 0x01d5, 0x01d4, 0x01d4, + 0x01d3, 0x01d2, 0x01d1, 0x01d0, 0x01cf, 0x01cf, 0x01ce, 0x01cd, 0x01cc, 0x01cb, 0x01cb, 0x01ca, 0x01c9, 0x01c8, 0x01c7, 0x01c7, + 0x01c6, 0x01c5, 0x01c4, 0x01c3, 0x01c3, 0x01c2, 0x01c1, 0x01c0, 0x01c0, 0x01bf, 0x01be, 0x01bd, 0x01bd, 0x01bc, 0x01bb, 0x01ba, + 0x01ba, 0x01b9, 0x01b8, 0x01b7, 0x01b7, 0x01b6, 0x01b5, 0x01b4, 0x01b4, 0x01b3, 0x01b2, 0x01b2, 0x01b1, 0x01b0, 0x01af, 0x01af, + 0x01ae, 0x01ad, 0x01ad, 0x01ac, 0x01ab, 0x01aa, 0x01aa, 0x01a9, 0x01a8, 0x01a8, 0x01a7, 0x01a6, 0x01a6, 0x01a5, 0x01a4, 0x01a4, + 0x01a3, 0x01a2, 0x01a2, 0x01a1, 0x01a0, 0x01a0, 0x019f, 0x019e, 0x019e, 0x019d, 0x019c, 0x019c, 0x019b, 0x019a, 0x019a, 0x0199, + 0x0198, 0x0198, 0x0197, 0x0197, 0x0196, 0x0195, 0x0195, 0x0194, 0x0193, 0x0193, 0x0192, 0x0192, 0x0191, 0x0190, 0x0190, 0x018f, + 0x018f, 0x018e, 0x018d, 0x018d, 0x018c, 0x018b, 0x018b, 0x018a, 0x018a, 0x0189, 0x0189, 0x0188, 0x0187, 0x0187, 0x0186, 0x0186, + 0x0185, 0x0184, 0x0184, 0x0183, 0x0183, 0x0182, 0x0182, 0x0181, 0x0180, 0x0180, 0x017f, 0x017f, 0x017e, 0x017e, 0x017d, 0x017d, + 0x017c, 0x017b, 0x017b, 0x017a, 0x017a, 0x0179, 0x0179, 0x0178, 0x0178, 0x0177, 0x0177, 0x0176, 0x0175, 0x0175, 0x0174, 0x0174, + 0x0173, 0x0173, 0x0172, 0x0172, 0x0171, 0x0171, 0x0170, 0x0170, 0x016f, 0x016f, 0x016e, 0x016e, 0x016d, 0x016d, 0x016c, 0x016c, + 0x016b, 0x016b, 0x016a, 0x016a, 0x0169, 0x0169, 0x0168, 0x0168, 0x0167, 0x0167, 0x0166, 0x0166, 0x0165, 0x0165, 0x0164, 0x0164, + 0x0163, 0x0163, 0x0162, 0x0162, 0x0161, 0x0161, 0x0160, 0x0160, 0x015f, 0x015f, 0x015e, 0x015e, 0x015d, 0x015d, 0x015d, 0x015c, + 0x015c, 0x015b, 0x015b, 0x015a, 0x015a, 0x0159, 0x0159, 0x0158, 0x0158, 0x0158, 0x0157, 0x0157, 0x0156, 0x0156 +}; +static const uint16_t DivTableNEON[255*3+1] = { + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x1c71, 0x1af2, 0x1999, 0x1861, 0x1745, 0x1642, 0x1555, 0x147a, 0x13b1, 0x12f6, 0x1249, 0x11a7, 0x1111, 0x1084, 0x1000, + 0x0f83, 0x0f0f, 0x0ea0, 0x0e38, 0x0dd6, 0x0d79, 0x0d20, 0x0ccc, 0x0c7c, 0x0c30, 0x0be8, 0x0ba2, 0x0b60, 0x0b21, 0x0ae4, 0x0aaa, + 0x0a72, 0x0a3d, 0x0a0a, 0x09d8, 0x09a9, 0x097b, 0x094f, 0x0924, 0x08fb, 0x08d3, 0x08ad, 0x0888, 0x0864, 0x0842, 0x0820, 0x0800, + 0x07e0, 0x07c1, 0x07a4, 0x0787, 0x076b, 0x0750, 0x0736, 0x071c, 0x0703, 0x06eb, 0x06d3, 0x06bc, 0x06a6, 0x0690, 0x067b, 0x0666, + 0x0652, 0x063e, 0x062b, 0x0618, 0x0606, 0x05f4, 0x05e2, 0x05d1, 0x05c0, 0x05b0, 0x05a0, 0x0590, 0x0581, 0x0572, 0x0563, 0x0555, + 0x0547, 0x0539, 0x052b, 0x051e, 0x0511, 0x0505, 0x04f8, 0x04ec, 0x04e0, 0x04d4, 0x04c8, 0x04bd, 0x04b2, 0x04a7, 0x049c, 0x0492, + 0x0487, 0x047d, 0x0473, 0x0469, 0x0460, 0x0456, 0x044d, 0x0444, 0x043b, 0x0432, 0x0429, 0x0421, 0x0418, 0x0410, 0x0408, 0x0400, + 0x03f8, 0x03f0, 0x03e8, 0x03e0, 0x03d9, 0x03d2, 0x03ca, 0x03c3, 0x03bc, 0x03b5, 0x03ae, 0x03a8, 0x03a1, 0x039b, 0x0394, 0x038e, + 0x0387, 0x0381, 0x037b, 0x0375, 0x036f, 0x0369, 0x0364, 0x035e, 0x0358, 0x0353, 0x034d, 0x0348, 0x0342, 0x033d, 0x0338, 0x0333, + 0x032e, 0x0329, 0x0324, 0x031f, 0x031a, 0x0315, 0x0310, 0x030c, 0x0307, 0x0303, 0x02fe, 0x02fa, 0x02f5, 0x02f1, 0x02ec, 0x02e8, + 0x02e4, 0x02e0, 0x02dc, 0x02d8, 0x02d4, 0x02d0, 0x02cc, 0x02c8, 0x02c4, 0x02c0, 0x02bc, 0x02b9, 0x02b5, 0x02b1, 0x02ae, 0x02aa, + 0x02a7, 0x02a3, 0x02a0, 0x029c, 0x0299, 0x0295, 0x0292, 0x028f, 0x028c, 0x0288, 0x0285, 0x0282, 0x027f, 0x027c, 0x0279, 0x0276, + 0x0273, 0x0270, 0x026d, 0x026a, 0x0267, 0x0264, 0x0261, 0x025e, 0x025c, 0x0259, 0x0256, 0x0253, 0x0251, 0x024e, 0x024b, 0x0249, + 0x0246, 0x0243, 0x0241, 0x023e, 0x023c, 0x0239, 0x0237, 0x0234, 0x0232, 0x0230, 0x022d, 0x022b, 0x0229, 0x0226, 0x0224, 0x0222, + 0x021f, 0x021d, 0x021b, 0x0219, 0x0216, 0x0214, 0x0212, 0x0210, 0x020e, 0x020c, 0x020a, 0x0208, 0x0206, 0x0204, 0x0202, 0x0200, + 0x01fe, 0x01fc, 0x01fa, 0x01f8, 0x01f6, 0x01f4, 0x01f2, 0x01f0, 0x01ee, 0x01ec, 0x01ea, 0x01e9, 0x01e7, 0x01e5, 0x01e3, 0x01e1, + 0x01e0, 0x01de, 0x01dc, 0x01da, 0x01d9, 0x01d7, 0x01d5, 0x01d4, 0x01d2, 0x01d0, 0x01cf, 0x01cd, 0x01cb, 0x01ca, 0x01c8, 0x01c7, + 0x01c5, 0x01c3, 0x01c2, 0x01c0, 0x01bf, 0x01bd, 0x01bc, 0x01ba, 0x01b9, 0x01b7, 0x01b6, 0x01b4, 0x01b3, 0x01b2, 0x01b0, 0x01af, + 0x01ad, 0x01ac, 0x01aa, 0x01a9, 0x01a8, 0x01a6, 0x01a5, 0x01a4, 0x01a2, 0x01a1, 0x01a0, 0x019e, 0x019d, 0x019c, 0x019a, 0x0199, + 0x0198, 0x0197, 0x0195, 0x0194, 0x0193, 0x0192, 0x0190, 0x018f, 0x018e, 0x018d, 0x018b, 0x018a, 0x0189, 0x0188, 0x0187, 0x0186, + 0x0184, 0x0183, 0x0182, 0x0181, 0x0180, 0x017f, 0x017e, 0x017d, 0x017b, 0x017a, 0x0179, 0x0178, 0x0177, 0x0176, 0x0175, 0x0174, + 0x0173, 0x0172, 0x0171, 0x0170, 0x016f, 0x016e, 0x016d, 0x016c, 0x016b, 0x016a, 0x0169, 0x0168, 0x0167, 0x0166, 0x0165, 0x0164, + 0x0163, 0x0162, 0x0161, 0x0160, 0x015f, 0x015e, 0x015d, 0x015c, 0x015b, 0x015a, 0x0159, 0x0158, 0x0158, 0x0157, 0x0156, 0x0155, + 0x0154, 0x0153, 0x0152, 0x0151, 0x0150, 0x0150, 0x014f, 0x014e, 0x014d, 0x014c, 0x014b, 0x014a, 0x014a, 0x0149, 0x0148, 0x0147, + 0x0146, 0x0146, 0x0145, 0x0144, 0x0143, 0x0142, 0x0142, 0x0141, 0x0140, 0x013f, 0x013e, 0x013e, 0x013d, 0x013c, 0x013b, 0x013b, + 0x013a, 0x0139, 0x0138, 0x0138, 0x0137, 0x0136, 0x0135, 0x0135, 0x0134, 0x0133, 0x0132, 0x0132, 0x0131, 0x0130, 0x0130, 0x012f, + 0x012e, 0x012e, 0x012d, 0x012c, 0x012b, 0x012b, 0x012a, 0x0129, 0x0129, 0x0128, 0x0127, 0x0127, 0x0126, 0x0125, 0x0125, 0x0124, + 0x0123, 0x0123, 0x0122, 0x0121, 0x0121, 0x0120, 0x0120, 0x011f, 0x011e, 0x011e, 0x011d, 0x011c, 0x011c, 0x011b, 0x011b, 0x011a, + 0x0119, 0x0119, 0x0118, 0x0118, 0x0117, 0x0116, 0x0116, 0x0115, 0x0115, 0x0114, 0x0113, 0x0113, 0x0112, 0x0112, 0x0111, 0x0111, + 0x0110, 0x010f, 0x010f, 0x010e, 0x010e, 0x010d, 0x010d, 0x010c, 0x010c, 0x010b, 0x010a, 0x010a, 0x0109, 0x0109, 0x0108, 0x0108, + 0x0107, 0x0107, 0x0106, 0x0106, 0x0105, 0x0105, 0x0104, 0x0104, 0x0103, 0x0103, 0x0102, 0x0102, 0x0101, 0x0101, 0x0100, 0x0100, + 0x00ff, 0x00ff, 0x00fe, 0x00fe, 0x00fd, 0x00fd, 0x00fc, 0x00fc, 0x00fb, 0x00fb, 0x00fa, 0x00fa, 0x00f9, 0x00f9, 0x00f8, 0x00f8, + 0x00f7, 0x00f7, 0x00f6, 0x00f6, 0x00f5, 0x00f5, 0x00f4, 0x00f4, 0x00f4, 0x00f3, 0x00f3, 0x00f2, 0x00f2, 0x00f1, 0x00f1, 0x00f0, + 0x00f0, 0x00f0, 0x00ef, 0x00ef, 0x00ee, 0x00ee, 0x00ed, 0x00ed, 0x00ed, 0x00ec, 0x00ec, 0x00eb, 0x00eb, 0x00ea, 0x00ea, 0x00ea, + 0x00e9, 0x00e9, 0x00e8, 0x00e8, 0x00e7, 0x00e7, 0x00e7, 0x00e6, 0x00e6, 0x00e5, 0x00e5, 0x00e5, 0x00e4, 0x00e4, 0x00e3, 0x00e3, + 0x00e3, 0x00e2, 0x00e2, 0x00e1, 0x00e1, 0x00e1, 0x00e0, 0x00e0, 0x00e0, 0x00df, 0x00df, 0x00de, 0x00de, 0x00de, 0x00dd, 0x00dd, + 0x00dd, 0x00dc, 0x00dc, 0x00db, 0x00db, 0x00db, 0x00da, 0x00da, 0x00da, 0x00d9, 0x00d9, 0x00d9, 0x00d8, 0x00d8, 0x00d7, 0x00d7, + 0x00d7, 0x00d6, 0x00d6, 0x00d6, 0x00d5, 0x00d5, 0x00d5, 0x00d4, 0x00d4, 0x00d4, 0x00d3, 0x00d3, 0x00d3, 0x00d2, 0x00d2, 0x00d2, + 0x00d1, 0x00d1, 0x00d1, 0x00d0, 0x00d0, 0x00d0, 0x00cf, 0x00cf, 0x00cf, 0x00ce, 0x00ce, 0x00ce, 0x00cd, 0x00cd, 0x00cd, 0x00cc, + 0x00cc, 0x00cc, 0x00cb, 0x00cb, 0x00cb, 0x00ca, 0x00ca, 0x00ca, 0x00c9, 0x00c9, 0x00c9, 0x00c9, 0x00c8, 0x00c8, 0x00c8, 0x00c7, + 0x00c7, 0x00c7, 0x00c6, 0x00c6, 0x00c6, 0x00c5, 0x00c5, 0x00c5, 0x00c5, 0x00c4, 0x00c4, 0x00c4, 0x00c3, 0x00c3, 0x00c3, 0x00c3, + 0x00c2, 0x00c2, 0x00c2, 0x00c1, 0x00c1, 0x00c1, 0x00c1, 0x00c0, 0x00c0, 0x00c0, 0x00bf, 0x00bf, 0x00bf, 0x00bf, 0x00be, 0x00be, + 0x00be, 0x00bd, 0x00bd, 0x00bd, 0x00bd, 0x00bc, 0x00bc, 0x00bc, 0x00bc, 0x00bb, 0x00bb, 0x00bb, 0x00ba, 0x00ba, 0x00ba, 0x00ba, + 0x00b9, 0x00b9, 0x00b9, 0x00b9, 0x00b8, 0x00b8, 0x00b8, 0x00b8, 0x00b7, 0x00b7, 0x00b7, 0x00b7, 0x00b6, 0x00b6, 0x00b6, 0x00b6, + 0x00b5, 0x00b5, 0x00b5, 0x00b5, 0x00b4, 0x00b4, 0x00b4, 0x00b4, 0x00b3, 0x00b3, 0x00b3, 0x00b3, 0x00b2, 0x00b2, 0x00b2, 0x00b2, + 0x00b1, 0x00b1, 0x00b1, 0x00b1, 0x00b0, 0x00b0, 0x00b0, 0x00b0, 0x00af, 0x00af, 0x00af, 0x00af, 0x00ae, 0x00ae, 0x00ae, 0x00ae, + 0x00ae, 0x00ad, 0x00ad, 0x00ad, 0x00ad, 0x00ac, 0x00ac, 0x00ac, 0x00ac, 0x00ac, 0x00ab, 0x00ab, 0x00ab, 0x00ab, +}; + +static const uint16_t DivTableAlpha[256] = { + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xe38e, 0xcccc, 0xba2e, 0xaaaa, 0x9d89, 0x9249, 0x8888, 0x8000, + 0x7878, 0x71c7, 0x6bca, 0x6666, 0x6186, 0x5d17, 0x590b, 0x5555, 0x51eb, 0x4ec4, 0x4bda, 0x4924, 0x469e, 0x4444, 0x4210, 0x4000, + 0x3e0f, 0x3c3c, 0x3a83, 0x38e3, 0x3759, 0x35e5, 0x3483, 0x3333, 0x31f3, 0x30c3, 0x2fa0, 0x2e8b, 0x2d82, 0x2c85, 0x2b93, 0x2aaa, + 0x29cb, 0x28f5, 0x2828, 0x2762, 0x26a4, 0x25ed, 0x253c, 0x2492, 0x23ee, 0x234f, 0x22b6, 0x2222, 0x2192, 0x2108, 0x2082, 0x2000, + 0x1f81, 0x1f07, 0x1e91, 0x1e1e, 0x1dae, 0x1d41, 0x1cd8, 0x1c71, 0x1c0e, 0x1bac, 0x1b4e, 0x1af2, 0x1a98, 0x1a41, 0x19ec, 0x1999, + 0x1948, 0x18f9, 0x18ac, 0x1861, 0x1818, 0x17d0, 0x178a, 0x1745, 0x1702, 0x16c1, 0x1681, 0x1642, 0x1605, 0x15c9, 0x158e, 0x1555, + 0x151d, 0x14e5, 0x14af, 0x147a, 0x1446, 0x1414, 0x13e2, 0x13b1, 0x1381, 0x1352, 0x1323, 0x12f6, 0x12c9, 0x129e, 0x1273, 0x1249, + 0x121f, 0x11f7, 0x11cf, 0x11a7, 0x1181, 0x115b, 0x1135, 0x1111, 0x10ec, 0x10c9, 0x10a6, 0x1084, 0x1062, 0x1041, 0x1020, 0x1000, + 0x0fe0, 0x0fc0, 0x0fa2, 0x0f83, 0x0f66, 0x0f48, 0x0f2b, 0x0f0f, 0x0ef2, 0x0ed7, 0x0ebb, 0x0ea0, 0x0e86, 0x0e6c, 0x0e52, 0x0e38, + 0x0e1f, 0x0e07, 0x0dee, 0x0dd6, 0x0dbe, 0x0da7, 0x0d90, 0x0d79, 0x0d62, 0x0d4c, 0x0d36, 0x0d20, 0x0d0b, 0x0cf6, 0x0ce1, 0x0ccc, + 0x0cb8, 0x0ca4, 0x0c90, 0x0c7c, 0x0c69, 0x0c56, 0x0c43, 0x0c30, 0x0c1e, 0x0c0c, 0x0bfa, 0x0be8, 0x0bd6, 0x0bc5, 0x0bb3, 0x0ba2, + 0x0b92, 0x0b81, 0x0b70, 0x0b60, 0x0b50, 0x0b40, 0x0b30, 0x0b21, 0x0b11, 0x0b02, 0x0af3, 0x0ae4, 0x0ad6, 0x0ac7, 0x0ab8, 0x0aaa, + 0x0a9c, 0x0a8e, 0x0a80, 0x0a72, 0x0a65, 0x0a57, 0x0a4a, 0x0a3d, 0x0a30, 0x0a23, 0x0a16, 0x0a0a, 0x09fd, 0x09f1, 0x09e4, 0x09d8, + 0x09cc, 0x09c0, 0x09b4, 0x09a9, 0x099d, 0x0991, 0x0986, 0x097b, 0x0970, 0x0964, 0x095a, 0x094f, 0x0944, 0x0939, 0x092f, 0x0924, + 0x091a, 0x090f, 0x0905, 0x08fb, 0x08f1, 0x08e7, 0x08dd, 0x08d3, 0x08ca, 0x08c0, 0x08b7, 0x08ad, 0x08a4, 0x089a, 0x0891, 0x0888, + 0x087f, 0x0876, 0x086d, 0x0864, 0x085b, 0x0853, 0x084a, 0x0842, 0x0839, 0x0831, 0x0828, 0x0820, 0x0818, 0x0810, 0x0808, 0x0800, +}; + +static etcpak_force_inline uint64_t ProcessRGB( const uint8_t* src ) +{ +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128(((__m128i*)src) + 0); + __m128i px1 = _mm_loadu_si128(((__m128i*)src) + 1); + __m128i px2 = _mm_loadu_si128(((__m128i*)src) + 2); + __m128i px3 = _mm_loadu_si128(((__m128i*)src) + 3); + + __m128i smask = _mm_set1_epi32( 0xF8FCF8 ); + __m128i sd0 = _mm_and_si128( px0, smask ); + __m128i sd1 = _mm_and_si128( px1, smask ); + __m128i sd2 = _mm_and_si128( px2, smask ); + __m128i sd3 = _mm_and_si128( px3, smask ); + + __m128i sc = _mm_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m128i sc0 = _mm_cmpeq_epi8(sd0, sc); + __m128i sc1 = _mm_cmpeq_epi8(sd1, sc); + __m128i sc2 = _mm_cmpeq_epi8(sd2, sc); + __m128i sc3 = _mm_cmpeq_epi8(sd3, sc); + + __m128i sm0 = _mm_and_si128(sc0, sc1); + __m128i sm1 = _mm_and_si128(sc2, sc3); + __m128i sm = _mm_and_si128(sm0, sm1); + + if( _mm_testc_si128(sm, _mm_set1_epi32(-1)) ) + { + uint32_t c; + memcpy( &c, src, 4 ); + return uint64_t( to565( c ) ) << 16; + } + + __m128i min0 = _mm_min_epu8( px0, px1 ); + __m128i min1 = _mm_min_epu8( px2, px3 ); + __m128i min2 = _mm_min_epu8( min0, min1 ); + + __m128i max0 = _mm_max_epu8( px0, px1 ); + __m128i max1 = _mm_max_epu8( px2, px3 ); + __m128i max2 = _mm_max_epu8( max0, max1 ); + + __m128i min3 = _mm_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i max3 = _mm_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i min4 = _mm_min_epu8( min2, min3 ); + __m128i max4 = _mm_max_epu8( max2, max3 ); + + __m128i min5 = _mm_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i max5 = _mm_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i rmin = _mm_min_epu8( min4, min5 ); + __m128i rmax = _mm_max_epu8( max4, max5 ); + + __m128i range1 = _mm_subs_epu8( rmax, rmin ); + __m128i range2 = _mm_sad_epu8( rmax, rmin ); + + uint32_t vrange = _mm_cvtsi128_si32( range2 ) >> 1; + __m128i range = _mm_set1_epi16( DivTable[vrange] ); + + __m128i inset1 = _mm_srli_epi16( range1, 4 ); + __m128i inset = _mm_and_si128( inset1, _mm_set1_epi8( 0xF ) ); + __m128i min = _mm_adds_epu8( rmin, inset ); + __m128i max = _mm_subs_epu8( rmax, inset ); + + __m128i c0 = _mm_subs_epu8( px0, rmin ); + __m128i c1 = _mm_subs_epu8( px1, rmin ); + __m128i c2 = _mm_subs_epu8( px2, rmin ); + __m128i c3 = _mm_subs_epu8( px3, rmin ); + + __m128i is0 = _mm_maddubs_epi16( c0, _mm_set1_epi8( 1 ) ); + __m128i is1 = _mm_maddubs_epi16( c1, _mm_set1_epi8( 1 ) ); + __m128i is2 = _mm_maddubs_epi16( c2, _mm_set1_epi8( 1 ) ); + __m128i is3 = _mm_maddubs_epi16( c3, _mm_set1_epi8( 1 ) ); + + __m128i s0 = _mm_hadd_epi16( is0, is1 ); + __m128i s1 = _mm_hadd_epi16( is2, is3 ); + + __m128i m0 = _mm_mulhi_epu16( s0, range ); + __m128i m1 = _mm_mulhi_epu16( s1, range ); + + __m128i p0 = _mm_packus_epi16( m0, m1 ); + + __m128i p1 = _mm_or_si128( _mm_srai_epi32( p0, 6 ), _mm_srai_epi32( p0, 12 ) ); + __m128i p2 = _mm_or_si128( _mm_srai_epi32( p0, 18 ), p0 ); + __m128i p3 = _mm_or_si128( p1, p2 ); + __m128i p =_mm_shuffle_epi8( p3, _mm_set1_epi32( 0x0C080400 ) ); + + uint32_t vmin = _mm_cvtsi128_si32( min ); + uint32_t vmax = _mm_cvtsi128_si32( max ); + uint32_t vp = _mm_cvtsi128_si32( p ); + + return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); +#elif defined __ARM_NEON +# ifdef __aarch64__ + uint8x16x4_t px = vld4q_u8( src ); + + uint8x16_t lr = px.val[0]; + uint8x16_t lg = px.val[1]; + uint8x16_t lb = px.val[2]; + + uint8_t rmaxr = vmaxvq_u8( lr ); + uint8_t rmaxg = vmaxvq_u8( lg ); + uint8_t rmaxb = vmaxvq_u8( lb ); + + uint8_t rminr = vminvq_u8( lr ); + uint8_t rming = vminvq_u8( lg ); + uint8_t rminb = vminvq_u8( lb ); + + int rr = rmaxr - rminr; + int rg = rmaxg - rming; + int rb = rmaxb - rminb; + + int vrange1 = rr + rg + rb; + uint16_t vrange2 = DivTableNEON[vrange1]; + + uint8_t insetr = rr >> 4; + uint8_t insetg = rg >> 4; + uint8_t insetb = rb >> 4; + + uint8_t minr = rminr + insetr; + uint8_t ming = rming + insetg; + uint8_t minb = rminb + insetb; + + uint8_t maxr = rmaxr - insetr; + uint8_t maxg = rmaxg - insetg; + uint8_t maxb = rmaxb - insetb; + + uint8x16_t cr = vsubq_u8( lr, vdupq_n_u8( rminr ) ); + uint8x16_t cg = vsubq_u8( lg, vdupq_n_u8( rming ) ); + uint8x16_t cb = vsubq_u8( lb, vdupq_n_u8( rminb ) ); + + uint16x8_t is0l = vaddl_u8( vget_low_u8( cr ), vget_low_u8( cg ) ); + uint16x8_t is0h = vaddl_u8( vget_high_u8( cr ), vget_high_u8( cg ) ); + uint16x8_t is1l = vaddw_u8( is0l, vget_low_u8( cb ) ); + uint16x8_t is1h = vaddw_u8( is0h, vget_high_u8( cb ) ); + + int16x8_t range = vdupq_n_s16( vrange2 ); + uint16x8_t m0 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( is1l ), range ) ); + uint16x8_t m1 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( is1h ), range ) ); + + uint8x8_t p00 = vmovn_u16( m0 ); + uint8x8_t p01 = vmovn_u16( m1 ); + uint8x16_t p0 = vcombine_u8( p00, p01 ); + + uint32x4_t p1 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 6 ), vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 12 ) ); + uint32x4_t p2 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 18 ), vreinterpretq_u32_u8( p0 ) ); + uint32x4_t p3 = vaddq_u32( p1, p2 ); + + uint16x4x2_t p4 = vuzp_u16( vget_low_u16( vreinterpretq_u16_u32( p3 ) ), vget_high_u16( vreinterpretq_u16_u32( p3 ) ) ); + uint8x8x2_t p = vuzp_u8( vreinterpret_u8_u16( p4.val[0] ), vreinterpret_u8_u16( p4.val[0] ) ); + + uint32_t vp; + vst1_lane_u32( &vp, vreinterpret_u32_u8( p.val[0] ), 0 ); + + return uint64_t( ( uint64_t( to565( minr, ming, minb ) ) << 16 ) | to565( maxr, maxg, maxb ) | ( uint64_t( vp ) << 32 ) ); +# else + uint32x4_t px0 = vld1q_u32( (uint32_t*)src ); + uint32x4_t px1 = vld1q_u32( (uint32_t*)src + 4 ); + uint32x4_t px2 = vld1q_u32( (uint32_t*)src + 8 ); + uint32x4_t px3 = vld1q_u32( (uint32_t*)src + 12 ); + + uint32x4_t smask = vdupq_n_u32( 0xF8FCF8 ); + uint32x4_t sd0 = vandq_u32( smask, px0 ); + uint32x4_t sd1 = vandq_u32( smask, px1 ); + uint32x4_t sd2 = vandq_u32( smask, px2 ); + uint32x4_t sd3 = vandq_u32( smask, px3 ); + + uint32x4_t sc = vdupq_n_u32( sd0[0] ); + + uint32x4_t sc0 = vceqq_u32( sd0, sc ); + uint32x4_t sc1 = vceqq_u32( sd1, sc ); + uint32x4_t sc2 = vceqq_u32( sd2, sc ); + uint32x4_t sc3 = vceqq_u32( sd3, sc ); + + uint32x4_t sm0 = vandq_u32( sc0, sc1 ); + uint32x4_t sm1 = vandq_u32( sc2, sc3 ); + int64x2_t sm = vreinterpretq_s64_u32( vandq_u32( sm0, sm1 ) ); + + if( sm[0] == -1 && sm[1] == -1 ) + { + return uint64_t( to565( src[0], src[1], src[2] ) ) << 16; + } + + uint32x4_t mask = vdupq_n_u32( 0xFFFFFF ); + uint8x16_t l0 = vreinterpretq_u8_u32( vandq_u32( mask, px0 ) ); + uint8x16_t l1 = vreinterpretq_u8_u32( vandq_u32( mask, px1 ) ); + uint8x16_t l2 = vreinterpretq_u8_u32( vandq_u32( mask, px2 ) ); + uint8x16_t l3 = vreinterpretq_u8_u32( vandq_u32( mask, px3 ) ); + + uint8x16_t min0 = vminq_u8( l0, l1 ); + uint8x16_t min1 = vminq_u8( l2, l3 ); + uint8x16_t min2 = vminq_u8( min0, min1 ); + + uint8x16_t max0 = vmaxq_u8( l0, l1 ); + uint8x16_t max1 = vmaxq_u8( l2, l3 ); + uint8x16_t max2 = vmaxq_u8( max0, max1 ); + + uint8x16_t min3 = vreinterpretq_u8_u32( vrev64q_u32( vreinterpretq_u32_u8( min2 ) ) ); + uint8x16_t max3 = vreinterpretq_u8_u32( vrev64q_u32( vreinterpretq_u32_u8( max2 ) ) ); + + uint8x16_t min4 = vminq_u8( min2, min3 ); + uint8x16_t max4 = vmaxq_u8( max2, max3 ); + + uint8x16_t min5 = vcombine_u8( vget_high_u8( min4 ), vget_low_u8( min4 ) ); + uint8x16_t max5 = vcombine_u8( vget_high_u8( max4 ), vget_low_u8( max4 ) ); + + uint8x16_t rmin = vminq_u8( min4, min5 ); + uint8x16_t rmax = vmaxq_u8( max4, max5 ); + + uint8x16_t range1 = vsubq_u8( rmax, rmin ); + uint8x8_t range2 = vget_low_u8( range1 ); + uint8x8x2_t range3 = vzip_u8( range2, vdup_n_u8( 0 ) ); + uint16x4_t range4 = vreinterpret_u16_u8( range3.val[0] ); + + uint16_t vrange1; + uint16x4_t range5 = vpadd_u16( range4, range4 ); + uint16x4_t range6 = vpadd_u16( range5, range5 ); + vst1_lane_u16( &vrange1, range6, 0 ); + + uint32_t vrange2 = ( 2 << 16 ) / uint32_t( vrange1 + 1 ); + uint16x8_t range = vdupq_n_u16( vrange2 ); + + uint8x16_t inset = vshrq_n_u8( range1, 4 ); + uint8x16_t min = vaddq_u8( rmin, inset ); + uint8x16_t max = vsubq_u8( rmax, inset ); + + uint8x16_t c0 = vsubq_u8( l0, rmin ); + uint8x16_t c1 = vsubq_u8( l1, rmin ); + uint8x16_t c2 = vsubq_u8( l2, rmin ); + uint8x16_t c3 = vsubq_u8( l3, rmin ); + + uint16x8_t is0 = vpaddlq_u8( c0 ); + uint16x8_t is1 = vpaddlq_u8( c1 ); + uint16x8_t is2 = vpaddlq_u8( c2 ); + uint16x8_t is3 = vpaddlq_u8( c3 ); + + uint16x4_t is4 = vpadd_u16( vget_low_u16( is0 ), vget_high_u16( is0 ) ); + uint16x4_t is5 = vpadd_u16( vget_low_u16( is1 ), vget_high_u16( is1 ) ); + uint16x4_t is6 = vpadd_u16( vget_low_u16( is2 ), vget_high_u16( is2 ) ); + uint16x4_t is7 = vpadd_u16( vget_low_u16( is3 ), vget_high_u16( is3 ) ); + + uint16x8_t s0 = vcombine_u16( is4, is5 ); + uint16x8_t s1 = vcombine_u16( is6, is7 ); + + uint16x8_t m0 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( s0 ), vreinterpretq_s16_u16( range ) ) ); + uint16x8_t m1 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( s1 ), vreinterpretq_s16_u16( range ) ) ); + + uint8x8_t p00 = vmovn_u16( m0 ); + uint8x8_t p01 = vmovn_u16( m1 ); + uint8x16_t p0 = vcombine_u8( p00, p01 ); + + uint32x4_t p1 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 6 ), vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 12 ) ); + uint32x4_t p2 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 18 ), vreinterpretq_u32_u8( p0 ) ); + uint32x4_t p3 = vaddq_u32( p1, p2 ); + + uint16x4x2_t p4 = vuzp_u16( vget_low_u16( vreinterpretq_u16_u32( p3 ) ), vget_high_u16( vreinterpretq_u16_u32( p3 ) ) ); + uint8x8x2_t p = vuzp_u8( vreinterpret_u8_u16( p4.val[0] ), vreinterpret_u8_u16( p4.val[0] ) ); + + uint32_t vmin, vmax, vp; + vst1q_lane_u32( &vmin, vreinterpretq_u32_u8( min ), 0 ); + vst1q_lane_u32( &vmax, vreinterpretq_u32_u8( max ), 0 ); + vst1_lane_u32( &vp, vreinterpret_u32_u8( p.val[0] ), 0 ); + + return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); +# endif +#else + uint32_t ref; + memcpy( &ref, src, 4 ); + uint32_t refMask = ref & 0xF8FCF8; + auto stmp = src + 4; + for( int i=1; i<16; i++ ) + { + uint32_t px; + memcpy( &px, stmp, 4 ); + if( ( px & 0xF8FCF8 ) != refMask ) break; + stmp += 4; + } + if( stmp == src + 64 ) + { + return uint64_t( to565( ref ) ) << 16; + } + + uint8_t min[3] = { src[0], src[1], src[2] }; + uint8_t max[3] = { src[0], src[1], src[2] }; + auto tmp = src + 4; + for( int i=1; i<16; i++ ) + { + for( int j=0; j<3; j++ ) + { + if( tmp[j] < min[j] ) min[j] = tmp[j]; + else if( tmp[j] > max[j] ) max[j] = tmp[j]; + } + tmp += 4; + } + + const uint32_t range = DivTable[max[0] - min[0] + max[1] - min[1] + max[2] - min[2]]; + const uint32_t rmin = min[0] + min[1] + min[2]; + for( int i=0; i<3; i++ ) + { + const uint8_t inset = ( max[i] - min[i] ) >> 4; + min[i] += inset; + max[i] -= inset; + } + + uint32_t data = 0; + for( int i=0; i<16; i++ ) + { + const uint32_t c = src[0] + src[1] + src[2] - rmin; + const uint8_t idx = ( c * range ) >> 16; + data |= idx << (i*2); + src += 4; + } + + return uint64_t( ( uint64_t( to565( min[0], min[1], min[2] ) ) << 16 ) | to565( max[0], max[1], max[2] ) | ( uint64_t( data ) << 32 ) ); +#endif +} + +#ifdef __AVX2__ +static etcpak_force_inline void ProcessRGB_AVX( const uint8_t* src, char*& dst ) +{ + __m256i px0 = _mm256_loadu_si256(((__m256i*)src) + 0); + __m256i px1 = _mm256_loadu_si256(((__m256i*)src) + 1); + __m256i px2 = _mm256_loadu_si256(((__m256i*)src) + 2); + __m256i px3 = _mm256_loadu_si256(((__m256i*)src) + 3); + + __m256i smask = _mm256_set1_epi32( 0xF8FCF8 ); + __m256i sd0 = _mm256_and_si256( px0, smask ); + __m256i sd1 = _mm256_and_si256( px1, smask ); + __m256i sd2 = _mm256_and_si256( px2, smask ); + __m256i sd3 = _mm256_and_si256( px3, smask ); + + __m256i sc = _mm256_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m256i sc0 = _mm256_cmpeq_epi8(sd0, sc); + __m256i sc1 = _mm256_cmpeq_epi8(sd1, sc); + __m256i sc2 = _mm256_cmpeq_epi8(sd2, sc); + __m256i sc3 = _mm256_cmpeq_epi8(sd3, sc); + + __m256i sm0 = _mm256_and_si256(sc0, sc1); + __m256i sm1 = _mm256_and_si256(sc2, sc3); + __m256i sm = _mm256_and_si256(sm0, sm1); + + const int64_t solid0 = 1 - _mm_testc_si128( _mm256_castsi256_si128( sm ), _mm_set1_epi32( -1 ) ); + const int64_t solid1 = 1 - _mm_testc_si128( _mm256_extracti128_si256( sm, 1 ), _mm_set1_epi32( -1 ) ); + + if( solid0 + solid1 == 0 ) + { + const auto c0 = uint64_t( to565( src[0], src[1], src[2] ) ); + const auto c1 = uint64_t( to565( src[16], src[17], src[18] ) ); + memcpy( dst, &c0, 8 ); + memcpy( dst+8, &c1, 8 ); + dst += 16; + return; + } + + __m256i min0 = _mm256_min_epu8( px0, px1 ); + __m256i min1 = _mm256_min_epu8( px2, px3 ); + __m256i min2 = _mm256_min_epu8( min0, min1 ); + + __m256i max0 = _mm256_max_epu8( px0, px1 ); + __m256i max1 = _mm256_max_epu8( px2, px3 ); + __m256i max2 = _mm256_max_epu8( max0, max1 ); + + __m256i min3 = _mm256_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m256i max3 = _mm256_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m256i min4 = _mm256_min_epu8( min2, min3 ); + __m256i max4 = _mm256_max_epu8( max2, max3 ); + + __m256i min5 = _mm256_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m256i max5 = _mm256_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m256i rmin = _mm256_min_epu8( min4, min5 ); + __m256i rmax = _mm256_max_epu8( max4, max5 ); + + __m256i range1 = _mm256_subs_epu8( rmax, rmin ); + __m256i range2 = _mm256_sad_epu8( rmax, rmin ); + + uint16_t vrange0 = DivTable[_mm256_cvtsi256_si32( range2 ) >> 1]; + uint16_t vrange1 = DivTable[_mm256_extract_epi16( range2, 8 ) >> 1]; + __m256i range00 = _mm256_set1_epi16( vrange0 ); + __m256i range = _mm256_inserti128_si256( range00, _mm_set1_epi16( vrange1 ), 1 ); + + __m256i inset1 = _mm256_srli_epi16( range1, 4 ); + __m256i inset = _mm256_and_si256( inset1, _mm256_set1_epi8( 0xF ) ); + __m256i min = _mm256_adds_epu8( rmin, inset ); + __m256i max = _mm256_subs_epu8( rmax, inset ); + + __m256i c0 = _mm256_subs_epu8( px0, rmin ); + __m256i c1 = _mm256_subs_epu8( px1, rmin ); + __m256i c2 = _mm256_subs_epu8( px2, rmin ); + __m256i c3 = _mm256_subs_epu8( px3, rmin ); + + __m256i is0 = _mm256_maddubs_epi16( c0, _mm256_set1_epi8( 1 ) ); + __m256i is1 = _mm256_maddubs_epi16( c1, _mm256_set1_epi8( 1 ) ); + __m256i is2 = _mm256_maddubs_epi16( c2, _mm256_set1_epi8( 1 ) ); + __m256i is3 = _mm256_maddubs_epi16( c3, _mm256_set1_epi8( 1 ) ); + + __m256i s0 = _mm256_hadd_epi16( is0, is1 ); + __m256i s1 = _mm256_hadd_epi16( is2, is3 ); + + __m256i m0 = _mm256_mulhi_epu16( s0, range ); + __m256i m1 = _mm256_mulhi_epu16( s1, range ); + + __m256i p0 = _mm256_packus_epi16( m0, m1 ); + + __m256i p1 = _mm256_or_si256( _mm256_srai_epi32( p0, 6 ), _mm256_srai_epi32( p0, 12 ) ); + __m256i p2 = _mm256_or_si256( _mm256_srai_epi32( p0, 18 ), p0 ); + __m256i p3 = _mm256_or_si256( p1, p2 ); + __m256i p =_mm256_shuffle_epi8( p3, _mm256_set1_epi32( 0x0C080400 ) ); + + __m256i mm0 = _mm256_unpacklo_epi8( _mm256_setzero_si256(), min ); + __m256i mm1 = _mm256_unpacklo_epi8( _mm256_setzero_si256(), max ); + __m256i mm2 = _mm256_unpacklo_epi64( mm1, mm0 ); + __m256i mmr = _mm256_slli_epi64( _mm256_srli_epi64( mm2, 11 ), 11 ); + __m256i mmg = _mm256_slli_epi64( _mm256_srli_epi64( mm2, 26 ), 5 ); + __m256i mmb = _mm256_srli_epi64( _mm256_slli_epi64( mm2, 16 ), 59 ); + __m256i mm3 = _mm256_or_si256( mmr, mmg ); + __m256i mm4 = _mm256_or_si256( mm3, mmb ); + __m256i mm5 = _mm256_shuffle_epi8( mm4, _mm256_set1_epi32( 0x09080100 ) ); + + __m256i d0 = _mm256_unpacklo_epi32( mm5, p ); + __m256i d1 = _mm256_permute4x64_epi64( d0, _MM_SHUFFLE( 3, 2, 2, 0 ) ); + __m128i d2 = _mm256_castsi256_si128( d1 ); + + __m128i mask = _mm_set_epi64x( 0xFFFF0000 | -solid1, 0xFFFF0000 | -solid0 ); + __m128i d3 = _mm_and_si128( d2, mask ); + + __m128i x0 = _mm_andnot_si128( d3, _mm_set1_epi32( 0x55555555 ) ); + __m128i x1 = _mm_andnot_si128( d3, _mm_set1_epi32( 0xAAAAAAAA ) ); + __m128i x2 = _mm_slli_epi32( x0, 1 ); + __m128i x3 = _mm_srli_epi32( x1, 1 ); + __m128i x4 = _mm_xor_si128( x1, x2 ); + __m128i x5 = _mm_or_si128( x3, x4 ); + __m128i x6 = _mm_and_si128( d3, _mm_set1_epi64x( 0xFFFFFFFF ) ); + __m128i x7 = _mm_and_si128( x5, _mm_set1_epi64x( 0xFFFFFFFF00000000 ) ); + __m128i x8 = _mm_or_si128( x6, x7 ); + + _mm_storeu_si128( (__m128i*)dst, x8 ); + dst += 16; +} +#endif + +static const uint8_t AlphaIndexTable[8] = { 1, 7, 6, 5, 4, 3, 2, 0 }; + +static etcpak_force_inline uint64_t ProcessAlpha( const uint8_t* src ) +{ + uint8_t solid8 = *src; + uint16_t solid16 = uint16_t( solid8 ) | ( uint16_t( solid8 ) << 8 ); + uint32_t solid32 = uint32_t( solid16 ) | ( uint32_t( solid16 ) << 16 ); + uint64_t solid64 = uint64_t( solid32 ) | ( uint64_t( solid32 ) << 32 ); + if( memcmp( src, &solid64, 8 ) == 0 && memcmp( src+8, &solid64, 8 ) == 0 ) + { + return solid8; + } + + uint8_t min = src[0]; + uint8_t max = min; + for( int i=1; i<16; i++ ) + { + const auto v = src[i]; + if( v > max ) max = v; + else if( v < min ) min = v; + } + + uint32_t range = ( 8 << 13 ) / ( 1 + max - min ); + uint64_t data = 0; + for( int i=0; i<16; i++ ) + { + uint8_t a = src[i] - min; + uint64_t idx = AlphaIndexTable[( a * range ) >> 13]; + data |= idx << (i*3); + } + + return max | ( min << 8 ) | ( data << 16 ); +} + +#ifdef __SSE4_1__ +static etcpak_force_inline uint64_t ProcessRGB_SSE( __m128i px0, __m128i px1, __m128i px2, __m128i px3 ) +{ + __m128i smask = _mm_set1_epi32( 0xF8FCF8 ); + __m128i sd0 = _mm_and_si128( px0, smask ); + __m128i sd1 = _mm_and_si128( px1, smask ); + __m128i sd2 = _mm_and_si128( px2, smask ); + __m128i sd3 = _mm_and_si128( px3, smask ); + + __m128i sc = _mm_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m128i sc0 = _mm_cmpeq_epi8(sd0, sc); + __m128i sc1 = _mm_cmpeq_epi8(sd1, sc); + __m128i sc2 = _mm_cmpeq_epi8(sd2, sc); + __m128i sc3 = _mm_cmpeq_epi8(sd3, sc); + + __m128i sm0 = _mm_and_si128(sc0, sc1); + __m128i sm1 = _mm_and_si128(sc2, sc3); + __m128i sm = _mm_and_si128(sm0, sm1); + + if( _mm_testc_si128(sm, _mm_set1_epi32(-1)) ) + { + return uint64_t( to565( _mm_cvtsi128_si32( px0 ) ) ) << 16; + } + + px0 = _mm_and_si128( px0, _mm_set1_epi32( 0xFFFFFF ) ); + px1 = _mm_and_si128( px1, _mm_set1_epi32( 0xFFFFFF ) ); + px2 = _mm_and_si128( px2, _mm_set1_epi32( 0xFFFFFF ) ); + px3 = _mm_and_si128( px3, _mm_set1_epi32( 0xFFFFFF ) ); + + __m128i min0 = _mm_min_epu8( px0, px1 ); + __m128i min1 = _mm_min_epu8( px2, px3 ); + __m128i min2 = _mm_min_epu8( min0, min1 ); + + __m128i max0 = _mm_max_epu8( px0, px1 ); + __m128i max1 = _mm_max_epu8( px2, px3 ); + __m128i max2 = _mm_max_epu8( max0, max1 ); + + __m128i min3 = _mm_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i max3 = _mm_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i min4 = _mm_min_epu8( min2, min3 ); + __m128i max4 = _mm_max_epu8( max2, max3 ); + + __m128i min5 = _mm_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i max5 = _mm_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i rmin = _mm_min_epu8( min4, min5 ); + __m128i rmax = _mm_max_epu8( max4, max5 ); + + __m128i range1 = _mm_subs_epu8( rmax, rmin ); + __m128i range2 = _mm_sad_epu8( rmax, rmin ); + + uint32_t vrange = _mm_cvtsi128_si32( range2 ) >> 1; + __m128i range = _mm_set1_epi16( DivTable[vrange] ); + + __m128i inset1 = _mm_srli_epi16( range1, 4 ); + __m128i inset = _mm_and_si128( inset1, _mm_set1_epi8( 0xF ) ); + __m128i min = _mm_adds_epu8( rmin, inset ); + __m128i max = _mm_subs_epu8( rmax, inset ); + + __m128i c0 = _mm_subs_epu8( px0, rmin ); + __m128i c1 = _mm_subs_epu8( px1, rmin ); + __m128i c2 = _mm_subs_epu8( px2, rmin ); + __m128i c3 = _mm_subs_epu8( px3, rmin ); + + __m128i is0 = _mm_maddubs_epi16( c0, _mm_set1_epi8( 1 ) ); + __m128i is1 = _mm_maddubs_epi16( c1, _mm_set1_epi8( 1 ) ); + __m128i is2 = _mm_maddubs_epi16( c2, _mm_set1_epi8( 1 ) ); + __m128i is3 = _mm_maddubs_epi16( c3, _mm_set1_epi8( 1 ) ); + + __m128i s0 = _mm_hadd_epi16( is0, is1 ); + __m128i s1 = _mm_hadd_epi16( is2, is3 ); + + __m128i m0 = _mm_mulhi_epu16( s0, range ); + __m128i m1 = _mm_mulhi_epu16( s1, range ); + + __m128i p0 = _mm_packus_epi16( m0, m1 ); + + __m128i p1 = _mm_or_si128( _mm_srai_epi32( p0, 6 ), _mm_srai_epi32( p0, 12 ) ); + __m128i p2 = _mm_or_si128( _mm_srai_epi32( p0, 18 ), p0 ); + __m128i p3 = _mm_or_si128( p1, p2 ); + __m128i p =_mm_shuffle_epi8( p3, _mm_set1_epi32( 0x0C080400 ) ); + + uint32_t vmin = _mm_cvtsi128_si32( min ); + uint32_t vmax = _mm_cvtsi128_si32( max ); + uint32_t vp = _mm_cvtsi128_si32( p ); + + return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); +} + +static etcpak_force_inline uint64_t ProcessOneChannel_SSE( __m128i a ) +{ + __m128i solidCmp = _mm_shuffle_epi8( a, _mm_setzero_si128() ); + __m128i cmpRes = _mm_cmpeq_epi8( a, solidCmp ); + if( _mm_testc_si128( cmpRes, _mm_set1_epi32( -1 ) ) ) + { + return _mm_cvtsi128_si32( a ) & 0xFF; + } + + __m128i a1 = _mm_shuffle_epi32( a, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i max1 = _mm_max_epu8( a, a1 ); + __m128i min1 = _mm_min_epu8( a, a1 ); + __m128i amax2 = _mm_shuffle_epi32( max1, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i amin2 = _mm_shuffle_epi32( min1, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i max2 = _mm_max_epu8( max1, amax2 ); + __m128i min2 = _mm_min_epu8( min1, amin2 ); + __m128i amax3 = _mm_alignr_epi8( max2, max2, 2 ); + __m128i amin3 = _mm_alignr_epi8( min2, min2, 2 ); + __m128i max3 = _mm_max_epu8( max2, amax3 ); + __m128i min3 = _mm_min_epu8( min2, amin3 ); + __m128i amax4 = _mm_alignr_epi8( max3, max3, 1 ); + __m128i amin4 = _mm_alignr_epi8( min3, min3, 1 ); + __m128i max = _mm_max_epu8( max3, amax4 ); + __m128i min = _mm_min_epu8( min3, amin4 ); + __m128i minmax = _mm_unpacklo_epi8( max, min ); + + __m128i r = _mm_sub_epi8( max, min ); + int range = _mm_cvtsi128_si32( r ) & 0xFF; + __m128i rv = _mm_set1_epi16( DivTableAlpha[range] ); + + __m128i v = _mm_sub_epi8( a, min ); + + __m128i lo16 = _mm_unpacklo_epi8( v, _mm_setzero_si128() ); + __m128i hi16 = _mm_unpackhi_epi8( v, _mm_setzero_si128() ); + + __m128i lomul = _mm_mulhi_epu16( lo16, rv ); + __m128i himul = _mm_mulhi_epu16( hi16, rv ); + + __m128i p0 = _mm_packus_epi16( lomul, himul ); + __m128i p1 = _mm_or_si128( _mm_and_si128( p0, _mm_set1_epi16( 0x3F ) ), _mm_srai_epi16( _mm_and_si128( p0, _mm_set1_epi16( 0x3F00 ) ), 5 ) ); + __m128i p2 = _mm_packus_epi16( p1, p1 ); + + uint64_t pi = _mm_cvtsi128_si64( p2 ); + uint64_t data = 0; + for( int i=0; i<8; i++ ) + { + uint64_t idx = AlphaIndexTable_SSE[(pi>>(i*8)) & 0x3F]; + data |= idx << (i*6); + } + return (uint64_t)(uint16_t)_mm_cvtsi128_si32( minmax ) | ( data << 16 ); +} + +static etcpak_force_inline uint64_t ProcessAlpha_SSE( __m128i px0, __m128i px1, __m128i px2, __m128i px3 ) +{ + __m128i mask = _mm_setr_epi32( 0x0f0b0703, -1, -1, -1 ); + + __m128i m0 = _mm_shuffle_epi8( px0, mask ); + __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + __m128i m4 = _mm_or_si128( m0, m1 ); + __m128i m5 = _mm_or_si128( m2, m3 ); + __m128i a = _mm_or_si128( m4, m5 ); + + return ProcessOneChannel_SSE( a ); +} +#endif + +void CompressBc1( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ +#ifdef __AVX2__ + if( width%8 == 0 ) + { + blocks /= 2; + uint32_t buf[8*4]; + int i = 0; + char* dst8 = (char*)dst; + + do + { + auto tmp = (char*)buf; + memcpy( tmp, src + width * 0, 8*4 ); + memcpy( tmp + 8*4, src + width * 1, 8*4 ); + memcpy( tmp + 16*4, src + width * 2, 8*4 ); + memcpy( tmp + 24*4, src + width * 3, 8*4 ); + src += 8; + if( ++i == width/8 ) + { + src += width * 3; + i = 0; + } + + ProcessRGB_AVX( (uint8_t*)buf, dst8 ); + } + while( --blocks ); + } + else +#endif + { + uint32_t buf[4*4]; + int i = 0; + + auto ptr = dst; + do + { + auto tmp = (char*)buf; + memcpy( tmp, src + width * 0, 4*4 ); + memcpy( tmp + 4*4, src + width * 1, 4*4 ); + memcpy( tmp + 8*4, src + width * 2, 4*4 ); + memcpy( tmp + 12*4, src + width * 3, 4*4 ); + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + const auto c = ProcessRGB( (uint8_t*)buf ); + uint8_t fix[8]; + memcpy( fix, &c, 8 ); + for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; + memcpy( ptr, fix, sizeof( uint64_t ) ); + ptr++; + } + while( --blocks ); + } +} + +void CompressBc1Dither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + uint32_t buf[4*4]; + int i = 0; + + auto ptr = dst; + do + { + auto tmp = (char*)buf; + memcpy( tmp, src + width * 0, 4*4 ); + memcpy( tmp + 4*4, src + width * 1, 4*4 ); + memcpy( tmp + 8*4, src + width * 2, 4*4 ); + memcpy( tmp + 12*4, src + width * 3, 4*4 ); + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + Dither( (uint8_t*)buf ); + + const auto c = ProcessRGB( (uint8_t*)buf ); + uint8_t fix[8]; + memcpy( fix, &c, 8 ); + for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; + memcpy( ptr, fix, sizeof( uint64_t ) ); + ptr++; + } + while( --blocks ); +} + +void CompressBc3( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int i = 0; + auto ptr = dst; + do + { +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); + __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); + __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); + __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); + + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + *ptr++ = ProcessAlpha_SSE( px0, px1, px2, px3 ); + + const auto c = ProcessRGB_SSE( px0, px1, px2, px3 ); + uint8_t fix[8]; + memcpy( fix, &c, 8 ); + for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; + memcpy( ptr, fix, sizeof( uint64_t ) ); + ptr++; +#else + uint32_t rgba[4*4]; + uint8_t alpha[4*4]; + + auto tmp = (char*)rgba; + memcpy( tmp, src + width * 0, 4*4 ); + memcpy( tmp + 4*4, src + width * 1, 4*4 ); + memcpy( tmp + 8*4, src + width * 2, 4*4 ); + memcpy( tmp + 12*4, src + width * 3, 4*4 ); + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + for( int i=0; i<16; i++ ) + { + alpha[i] = rgba[i] >> 24; + rgba[i] &= 0xFFFFFF; + } + *ptr++ = ProcessAlpha( alpha ); + + const auto c = ProcessRGB( (uint8_t*)rgba ); + uint8_t fix[8]; + memcpy( fix, &c, 8 ); + for( int j=4; j<8; j++ ) fix[j] = DxtcIndexTable[fix[j]]; + memcpy( ptr, fix, sizeof( uint64_t ) ); + ptr++; +#endif + } + while( --blocks ); +} + +void CompressBc4( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int i = 0; + auto ptr = dst; + do + { +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); + __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); + __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); + __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); + + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + __m128i mask = _mm_setr_epi32( 0x0c080400, -1, -1, -1 ); + + __m128i m0 = _mm_shuffle_epi8( px0, mask ); + __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + __m128i m4 = _mm_or_si128( m0, m1 ); + __m128i m5 = _mm_or_si128( m2, m3 ); + + *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); +#else + uint8_t r[4*4]; + auto rgba = src; + for( int i=0; i<4; i++ ) + { + r[i*4] = rgba[0] & 0xff; + r[i*4+1] = rgba[1] & 0xff; + r[i*4+2] = rgba[2] & 0xff; + r[i*4+3] = rgba[3] & 0xff; + + rgba += width; + } + + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + *ptr++ = ProcessAlpha( r ); +#endif + } while( --blocks ); +} + +void CompressBc5( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ) +{ + int i = 0; + auto ptr = dst; + do + { +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128( (__m128i*)( src + width * 0 ) ); + __m128i px1 = _mm_loadu_si128( (__m128i*)( src + width * 1 ) ); + __m128i px2 = _mm_loadu_si128( (__m128i*)( src + width * 2 ) ); + __m128i px3 = _mm_loadu_si128( (__m128i*)( src + width * 3 ) ); + + src += 4; + if( ++i == width/4 ) + { + src += width*3; + i = 0; + } + + __m128i mask = _mm_setr_epi32( 0x0c080400, -1, -1, -1 ); + + __m128i m0 = _mm_shuffle_epi8( px0, mask ); + __m128i m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + __m128i m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + __m128i m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + __m128i m4 = _mm_or_si128( m0, m1 ); + __m128i m5 = _mm_or_si128( m2, m3 ); + + *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); + + mask = _mm_setr_epi32( 0x0d090501, -1, -1, -1 ); + + m0 = _mm_shuffle_epi8( px0, mask ); + m1 = _mm_shuffle_epi8( px1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) ); + m2 = _mm_shuffle_epi8( px2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) ); + m3 = _mm_shuffle_epi8( px3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) ); + m4 = _mm_or_si128( m0, m1 ); + m5 = _mm_or_si128( m2, m3 ); + + *ptr++ = ProcessOneChannel_SSE( _mm_or_si128( m4, m5 ) ); +#else + uint8_t rg[4*4*2]; + auto rgba = src; + for( int i=0; i<4; i++ ) + { + rg[i*4] = rgba[0] & 0xff; + rg[i*4+1] = rgba[1] & 0xff; + rg[i*4+2] = rgba[2] & 0xff; + rg[i*4+3] = rgba[3] & 0xff; + + rg[16+i*4] = (rgba[0] & 0xff00) >> 8; + rg[16+i*4+1] = (rgba[1] & 0xff00) >> 8; + rg[16+i*4+2] = (rgba[2] & 0xff00) >> 8; + rg[16+i*4+3] = (rgba[3] & 0xff00) >> 8; + + rgba += width; + } + + src += 4; + if( ++i == width/4 ) + { + src += width*3; + i = 0; + } + + *ptr++ = ProcessAlpha( rg ); + *ptr++ = ProcessAlpha( &rg[16] ); +#endif + } while( --blocks ); +} + +/* +void CompressBc7( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, const bc7enc_compress_block_params* params ) +{ + int i = 0; + auto ptr = dst; + do + { + uint32_t rgba[4*4]; + + auto tmp = (char*)rgba; + memcpy( tmp, src + width * 0, 4*4 ); + memcpy( tmp + 4*4, src + width * 1, 4*4 ); + memcpy( tmp + 8*4, src + width * 2, 4*4 ); + memcpy( tmp + 12*4, src + width * 3, 4*4 ); + src += 4; + if( ++i == width/4 ) + { + src += width * 3; + i = 0; + } + + bc7enc_compress_block( ptr, rgba, params ); + ptr += 2; + } + while( --blocks ); +} +*/ \ No newline at end of file diff --git a/lib/etcpak/etcpak/ProcessDxtc.hpp b/lib/etcpak/etcpak/ProcessDxtc.hpp new file mode 100644 index 00000000000..25122fb9d03 --- /dev/null +++ b/lib/etcpak/etcpak/ProcessDxtc.hpp @@ -0,0 +1,18 @@ +#ifndef __PROCESSDXT1_HPP__ +#define __PROCESSDXT1_HPP__ + +#include +#include + +void CompressBc1( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressBc1Dither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressBc3( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); + +void CompressBc4( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); +void CompressBc5( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width ); + +//struct bc7enc_compress_block_params; + +//void CompressBc7( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, const bc7enc_compress_block_params* params ); + +#endif diff --git a/lib/etcpak/etcpak/README.md b/lib/etcpak/etcpak/README.md deleted file mode 100644 index 7166f98a935..00000000000 --- a/lib/etcpak/etcpak/README.md +++ /dev/null @@ -1,85 +0,0 @@ -# etcpak 2.1 # - -## The fastest ETC compressor on the planet ## - -etcpak is an extremely fast [Ericsson Texture Compression](http://en.wikipedia.org/wiki/Ericsson_Texture_Compression) and [Block Compression](https://en.wikipedia.org/wiki/S3_Texture_Compression) utility. Currently it's best suited for rapid assets preparation during development, when graphics quality is not a concern, but it's also used in production builds of applications used by millions of people. - -## Compression times ## - -Benchmark performed on an AMD Ryzen 9 7950X, using a real-life RGBA 16K × 16K atlas. - -ETC1: ST: **797 Mpx/s**, MT: **9613 Mpx/s** -ETC2: ST: **356 Mpx/s**, MT: **6378 Mpx/s** -BC1: ST: **5730 Mpx/s**, MT: **10174 Mpx/s** -BC3: ST: **2437 Mpx/s**, MT: **8568 Mpx/s** -BC7: ST: **12.1 Mpx/s**, MT: **225 Mpx/s** - -The same benchmark performed on Intel i7 1185G7: - -ETC1: ST: **516 Mpx/s**, MT: **2223 Mpx/s** -ETC2: ST: **238 Mpx/s**, MT: **984 Mpx/s** -BC1: ST: **2969 Mpx/s**, MT: **9199 Mpx/s** -BC3: ST: **1351 Mpx/s**, MT: **5503 Mpx/s** -BC7: ST: **7.8 Mpx/s**, MT: **21.3 Mpx/s** - -Apple M3 Max benchmark: - -ETC1: ST: **204 Mpx/s**, MT: **2455 Mpx/s** -ETC2: ST: **101 Mpx/s**, MT: **1231 Mpx/s** -BC1: ST: **3255 Mpx/s**, MT: **30366 Mpx/s** -BC3: ST: **1147 Mpx/s**, MT: **13238 Mpx/s** -BC7: ST: **5.47 Mpx/s**, MT: **65.8 Mpx/s** - -[Why there's no image quality metrics? / Quality comparison.](http://i.imgur.com/FxlmUOF.png) - -## Decompression times ## - -etcpak can also decompress textures. Timings on Ryzen 7950X (all single-threaded): - -ETC1: **604 Mpx/s** -ETC2: **599 Mpx/s** -BC1: **1634 Mpx/s** -BC3: **1172 Mpx/s** -BC7: **201 Mpx/s** - -i7 1185G7: - -ETC1: **383 Mpx/s** -ETC2: **378 Mpx/s** -BC1: **1056 Mpx/s** -BC3: **788 Mpx/s** -BC7: **76 Mpx/s** - -M3 Max: - -ETC1: **690 Mpx/s** -ETC2: **786 Mpx/s** -BC1: **2434 Mpx/s** -BC3: **1414 Mpx/s** -BC7: **406 Mpx/s** - -To give some perspective here, Nvidia in-driver ETC2 decoder can do only 42.5 Mpx/s. - -## Quality comparison ## - -Original image: - -![](examples/kodim23.png) - -Compressed image: - -ETC1: - -![](examples/etc1.png "ETC1 mode") - -ETC2: - -![](examples/etc2.png "ETC2 mode") - -BC1: - -![](examples/dxtc.png "BC1 mode") - -BC7: - -![](examples/bc7.png "BC7 mode") From 6ea948c58c519407368c9b3d98d3cc4b4d72e2f8 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 22 Aug 2026 15:13:45 -0300 Subject: [PATCH 14/14] fix accidental test change --- code/graphics/opengl/gropengl.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/code/graphics/opengl/gropengl.cpp b/code/graphics/opengl/gropengl.cpp index 454fafa4db0..034bfdb7194 100644 --- a/code/graphics/opengl/gropengl.cpp +++ b/code/graphics/opengl/gropengl.cpp @@ -1614,9 +1614,9 @@ bool gr_opengl_is_capable(gr_capability capability) case gr_capability::CAPABILITY_PERSISTENT_BUFFER_MAPPING: return GLAD_GL_ARB_buffer_storage != 0; case gr_capability::CAPABILITY_BPTC: - return false;// GLAD_GL_ARB_texture_compression_bptc != 0; + return GLAD_GL_ARB_texture_compression_bptc != 0; case gr_capability::CAPABILITY_S3TC: - return false;// GLAD_GL_EXT_texture_compression_s3tc != 0; + return GLAD_GL_EXT_texture_compression_s3tc != 0; case gr_capability::CAPABILITY_ETC2: return GLAD_GL_ARB_ES3_compatibility != 0; case gr_capability::CAPABILITY_LARGE_SHADER: