yencode 1.1.5 → 1.2.1

package/src/encoder.cc

@@ -2,7 +2,32 @@
 #include "encoder_common.h"
 #include "encoder.h"
 
-size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HEDLEY_RESTRICT src, unsigned char* HEDLEY_RESTRICT dest, size_t len, int doEnd) {
+
+// lookup tables for scalar processing
+#define _B1(n) _B(n), _B(n+1), _B(n+2), _B(n+3)
+#define _B2(n) _B1(n), _B1(n+4), _B1(n+8), _B1(n+12)
+#define _B3(n) _B2(n), _B2(n+16), _B2(n+32), _B2(n+48)
+#define _BX _B3(0), _B3(64), _B3(128), _B3(192)
+
+const unsigned char RapidYenc::escapeLUT[256] = { // whether or not the character is critical
+#define _B(n) ((n == 214 || n == '\r'+214 || n == '\n'+214 || n == '='-42) ? 0 : (n+42) & 0xff)
+	_BX
+#undef _B
+};
+const uint16_t RapidYenc::escapedLUT[256] = { // escaped sequences for characters that need escaping
+#define _B(n) ((n == 214 || n == 214+'\r' || n == 214+'\n' || n == '='-42 || n == 214+'\t' || n == 214+' ' || n == '.'-42) ? UINT16_PACK('=', ((n+42+64)&0xff)) : 0)
+	_BX
+#undef _B
+};
+
+#undef _B1
+#undef _B2
+#undef _B3
+#undef _BX
+
+
+
+size_t RapidYenc::do_encode_generic(int line_size, int* colOffset, const unsigned char* HEDLEY_RESTRICT src, unsigned char* HEDLEY_RESTRICT dest, size_t len, int doEnd) {
 	unsigned char* es = (unsigned char*)src + len;
 	unsigned char *p = dest; // destination pointer
 	long i = -(long)len; // input position
@@ -11,8 +36,8 @@ size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HED
 	
 	if (col == 0) {
 		c = es[i++];
-		if (escapedLUT[c]) {
-			memcpy(p, &escapedLUT[c], sizeof(uint16_t));
+		if (RapidYenc::escapedLUT[c]) {
+			memcpy(p, &RapidYenc::escapedLUT[c], sizeof(uint16_t));
 			p += 2;
 			col = 2;
 		} else {
@@ -27,11 +52,11 @@ size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HED
 			// 8 cycle unrolled version
 			sp = p;
 			#define DO_THING(n) \
-				c = es[i+n], escaped = escapeLUT[c]; \
+				c = es[i+n], escaped = RapidYenc::escapeLUT[c]; \
 				if (escaped) \
 					*(p++) = escaped; \
 				else { \
-					memcpy(p, &escapedLUT[c], sizeof(uint16_t)); \
+					memcpy(p, &RapidYenc::escapedLUT[c], sizeof(uint16_t)); \
 					p += 2; \
 				}
 			DO_THING(0);
@@ -55,13 +80,13 @@ size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HED
 		}
 		// handle remaining chars
 		while(col < line_size-1) {
-			c = es[i++], escaped = escapeLUT[c];
+			c = es[i++], escaped = RapidYenc::escapeLUT[c];
 			if (escaped) {
 				*(p++) = escaped;
 				col++;
 			}
 			else {
-				memcpy(p, &escapedLUT[c], sizeof(uint16_t));
+				memcpy(p, &RapidYenc::escapedLUT[c], sizeof(uint16_t));
 				p += 2;
 				col += 2;
 			}
@@ -79,8 +104,8 @@ size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HED
 		// last line char
 		if(col < line_size) { // this can only be false if the last character was an escape sequence (or line_size is horribly small), in which case, we don't need to handle space/tab cases
 			c = es[i++];
-			if (escapedLUT[c] && c != '.'-42) {
-				memcpy(p, &escapedLUT[c], sizeof(uint16_t));
+			if (RapidYenc::escapedLUT[c] && c != '.'-42) {
+				memcpy(p, &RapidYenc::escapedLUT[c], sizeof(uint16_t));
 				p += 2;
 			} else {
 				*(p++) = c + 42;
@@ -90,8 +115,8 @@ size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HED
 		if (i >= 0) break;
 		
 		c = es[i++];
-		if (escapedLUT[c]) {
-			uint32_t w = UINT32_16_PACK(UINT16_PACK('\r', '\n'), (uint32_t)escapedLUT[c]);
+		if (RapidYenc::escapedLUT[c]) {
+			uint32_t w = UINT32_16_PACK(UINT16_PACK('\r', '\n'), (uint32_t)RapidYenc::escapedLUT[c]);
 			memcpy(p, &w, sizeof(w));
 			p += 4;
 			col = 2;
@@ -120,40 +145,31 @@ size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HED
 }
 
 
-extern "C" {
+namespace RapidYenc {
 	size_t (*_do_encode)(int, int*, const unsigned char* HEDLEY_RESTRICT, unsigned char* HEDLEY_RESTRICT, size_t, int) = &do_encode_generic;
 	int _encode_isa = ISA_GENERIC;
 }
 
-void encoder_sse2_init();
-void encoder_ssse3_init();
-void encoder_avx_init();
-void encoder_avx2_init();
-void encoder_vbmi2_init();
-extern const bool encoder_has_avx10;
-void encoder_neon_init();
-void encoder_rvv_init();
-
 #if defined(PLATFORM_X86) && defined(YENC_BUILD_NATIVE) && YENC_BUILD_NATIVE!=0
 # if defined(__AVX2__) && !defined(YENC_DISABLE_AVX256)
 #  include "encoder_avx_base.h"
 static inline void encoder_native_init() {
-	_do_encode = &do_encode_simd< do_encode_avx2<ISA_NATIVE> >;
+	RapidYenc::_do_encode = &do_encode_simd< RapidYenc::do_encode_avx2<ISA_NATIVE> >;
 	encoder_avx2_lut<ISA_NATIVE>();
-	_encode_isa = ISA_NATIVE;
+	RapidYenc::_encode_isa = ISA_NATIVE;
 }
 # else
 #  include "encoder_sse_base.h"
 static inline void encoder_native_init() {
-	_do_encode = &do_encode_simd< do_encode_sse<ISA_NATIVE> >;
+	RapidYenc::_do_encode = &do_encode_simd< RapidYenc::do_encode_sse<ISA_NATIVE> >;
 	encoder_sse_lut<ISA_NATIVE>();
-	_encode_isa = ISA_NATIVE;
+	RapidYenc::_encode_isa = ISA_NATIVE;
 }
 # endif
 #endif
 
 
-void encoder_init() {
+void RapidYenc::encoder_init() {
 #ifdef PLATFORM_X86
 # if defined(YENC_BUILD_NATIVE) && YENC_BUILD_NATIVE!=0
 	encoder_native_init();

package/src/encoder.h

@@ -1,17 +1,17 @@
 #ifndef __YENC_ENCODER_H
 #define __YENC_ENCODER_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include "hedley.h"
 
+namespace RapidYenc {
 
 
-#include "hedley.h"
 
 extern size_t (*_do_encode)(int, int*, const unsigned char* HEDLEY_RESTRICT, unsigned char* HEDLEY_RESTRICT, size_t, int);
 extern int _encode_isa;
-#define do_encode (*_do_encode)
+static inline size_t encode(int line_size, int* colOffset, const void* HEDLEY_RESTRICT src, void* HEDLEY_RESTRICT dest, size_t len, int doEnd) {
+	return (*_do_encode)(line_size, colOffset, (const unsigned char* HEDLEY_RESTRICT)src, (unsigned char*)dest, len, doEnd);
+}
 void encoder_init();
 static inline int encode_isa_level() {
 	return _encode_isa;
@@ -19,7 +19,5 @@ static inline int encode_isa_level() {
 
 
 
-#ifdef __cplusplus
 }
 #endif
-#endif

package/src/encoder_avx.cc

@@ -1,16 +1,16 @@
 #include "common.h"
+#include "encoder_common.h"
 
 #if defined(__AVX__) && defined(__POPCNT__)
 #include "encoder_sse_base.h"
 
-void encoder_avx_init() {
+void RapidYenc::encoder_avx_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_LEVEL_SSE4_POPCNT> >;
 	encoder_sse_lut<ISA_LEVEL_SSE4_POPCNT>();
 	_encode_isa = ISA_LEVEL_AVX;
 }
 #else
-void encoder_ssse3_init();
-void encoder_avx_init() {
+void RapidYenc::encoder_avx_init() {
 	encoder_ssse3_init();
 }
 #endif

package/src/encoder_avx2.cc

@@ -1,16 +1,16 @@
 #include "common.h"
+#include "encoder_common.h"
 
 #if defined(__AVX2__) && !defined(YENC_DISABLE_AVX256)
 #include "encoder_avx_base.h"
 
-void encoder_avx2_init() {
+void RapidYenc::encoder_avx2_init() {
 	_do_encode = &do_encode_simd< do_encode_avx2<ISA_LEVEL_AVX2> >;
 	encoder_avx2_lut<ISA_LEVEL_AVX2>();
 	_encode_isa = ISA_LEVEL_AVX2;
 }
 #else
-void encoder_avx_init();
-void encoder_avx2_init() {
+void RapidYenc::encoder_avx2_init() {
 	encoder_avx_init();
 }
 #endif

package/src/encoder_avx_base.h

@@ -76,6 +76,8 @@ static void encoder_avx2_lut() {
 	}
 }
 
+namespace RapidYenc {
+
 template<enum YEncDecIsaLevel use_isa>
 HEDLEY_ALWAYS_INLINE void do_encode_avx2(int line_size, int* colOffset, const uint8_t* HEDLEY_RESTRICT srcEnd, uint8_t* HEDLEY_RESTRICT& dest, size_t& len) {
 	// offset position to enable simpler loop condition checking
@@ -568,5 +570,6 @@ HEDLEY_ALWAYS_INLINE void do_encode_avx2(int line_size, int* colOffset, const ui
 	dest = p;
 	len = -(i - INPUT_OFFSET);
 }
+} // namespace
 
 #endif

package/src/encoder_common.h

@@ -1,37 +1,31 @@
 #ifndef __YENC_ENCODER_COMMON
 #define __YENC_ENCODER_COMMON
 
-// lookup tables for scalar processing
-#define _B1(n) _B(n), _B(n+1), _B(n+2), _B(n+3)
-#define _B2(n) _B1(n), _B1(n+4), _B1(n+8), _B1(n+12)
-#define _B3(n) _B2(n), _B2(n+16), _B2(n+32), _B2(n+48)
-#define _BX _B3(0), _B3(64), _B3(128), _B3(192)
-
-static const unsigned char escapeLUT[256] = { // whether or not the character is critical
-#define _B(n) ((n == 214 || n == '\r'+214 || n == '\n'+214 || n == '='-42) ? 0 : (n+42) & 0xff)
-	_BX
-#undef _B
-};
-static const uint16_t escapedLUT[256] = { // escaped sequences for characters that need escaping
-#define _B(n) ((n == 214 || n == 214+'\r' || n == 214+'\n' || n == '='-42 || n == 214+'\t' || n == 214+' ' || n == '.'-42) ? UINT16_PACK('=', ((n+42+64)&0xff)) : 0)
-	_BX
-#undef _B
-};
-
-#undef _B1
-#undef _B2
-#undef _B3
-#undef _BX
+namespace RapidYenc {
+	void encoder_sse2_init();
+	void encoder_ssse3_init();
+	void encoder_avx_init();
+	void encoder_avx2_init();
+	void encoder_vbmi2_init();
+	extern const bool encoder_has_avx10;
+	void encoder_neon_init();
+	void encoder_rvv_init();
+	
+	// lookup tables for scalar processing
+	extern const unsigned char escapeLUT[256];
+	extern const uint16_t escapedLUT[256];
+	
+	size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HEDLEY_RESTRICT src, unsigned char* HEDLEY_RESTRICT dest, size_t len, int doEnd);
+}
 
 
-size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HEDLEY_RESTRICT src, unsigned char* HEDLEY_RESTRICT dest, size_t len, int doEnd);
 
 template<void(&kernel)(int, int*, const uint8_t* HEDLEY_RESTRICT, uint8_t* HEDLEY_RESTRICT&, size_t&)>
-static size_t do_encode_simd(int line_size, int* colOffset, const uint8_t* HEDLEY_RESTRICT src, uint8_t* HEDLEY_RESTRICT dest, size_t len, int doEnd) {
+static size_t do_encode_simd(int line_size, int* colOffset, const unsigned char* HEDLEY_RESTRICT src, unsigned char* HEDLEY_RESTRICT dest, size_t len, int doEnd) {
 	if(len < 1) return 0;
 	if(line_size < 12) { // short lines probably not worth processing in a SIMD way
 		// we assume at least the first and last char exist in the line, and since the first char could be escaped, and SIMD encoder assumes at least one non-first/last char, assumption means that line size has to be >= 4
-		return do_encode_generic(line_size, colOffset, src, dest, len, doEnd);
+		return RapidYenc::do_encode_generic(line_size, colOffset, src, dest, len, doEnd);
 	}
 	
 	const uint8_t* es = src + len;
@@ -45,8 +39,8 @@ static size_t do_encode_simd(int line_size, int* colOffset, const uint8_t* HEDLE
 	long i = -(long)len;
 	if(*colOffset == 0 && i < 0) {
 		uint8_t c = es[i++];
-		if (LIKELIHOOD(0.0273, escapedLUT[c] != 0)) {
-			memcpy(p, escapedLUT + c, 2);
+		if (LIKELIHOOD(0.0273, RapidYenc::escapedLUT[c] != 0)) {
+			memcpy(p, RapidYenc::escapedLUT + c, 2);
 			p += 2;
 			*colOffset = 2;
 		} else {
@@ -57,19 +51,19 @@ static size_t do_encode_simd(int line_size, int* colOffset, const uint8_t* HEDLE
 	while(i < 0) {
 		uint8_t c = es[i++];
 		if(*colOffset < line_size-1) {
-			if(!escapeLUT[c]) {
+			if(!RapidYenc::escapeLUT[c]) {
 				p[0] = '=';
 				p[1] = c+42+64;
 				p += 2;
 				(*colOffset) += 2;
 			} else {
-				*(p++) = escapeLUT[c];
+				*(p++) = RapidYenc::escapeLUT[c];
 				(*colOffset) += 1;
 			}
 		} else {
 			if(*colOffset < line_size) {
-				if (escapedLUT[c] && c != '.'-42) {
-					memcpy(p, escapedLUT + c, 2);
+				if (RapidYenc::escapedLUT[c] && c != '.'-42) {
+					memcpy(p, RapidYenc::escapedLUT + c, 2);
 					p += 2;
 				} else {
 					*(p++) = c + 42;
@@ -79,8 +73,8 @@ static size_t do_encode_simd(int line_size, int* colOffset, const uint8_t* HEDLE
 			}
 			
 			// handle EOL
-			if (escapedLUT[c]) {
-				uint32_t w = UINT32_16_PACK(UINT16_PACK('\r', '\n'), (uint32_t)escapedLUT[c]);
+			if (RapidYenc::escapedLUT[c]) {
+				uint32_t w = UINT32_16_PACK(UINT16_PACK('\r', '\n'), (uint32_t)RapidYenc::escapedLUT[c]);
 				memcpy(p, &w, sizeof(w));
 				p += 4;
 				*colOffset = 2;

package/src/encoder_neon.cc

@@ -1,8 +1,8 @@
 #include "common.h"
+#include "encoder_common.h"
 
 #ifdef __ARM_NEON
 #include "encoder.h"
-#include "encoder_common.h"
 
 // Clang wrongly assumes alignment on vst1q_u8_x2, and ARMv7 GCC doesn't support the function, so effectively, it can only be used in ARMv8 compilers
 #if defined(__aarch64__) && (defined(__clang__) || HEDLEY_GCC_VERSION_CHECK(8,5,0))
@@ -259,6 +259,8 @@ static HEDLEY_ALWAYS_INLINE void encode_eol_handle_pre(const uint8_t* HEDLEY_RES
 }
 
 
+namespace RapidYenc {
+
 HEDLEY_ALWAYS_INLINE void do_encode_neon(int line_size, int* colOffset, const uint8_t* HEDLEY_RESTRICT srcEnd, uint8_t* HEDLEY_RESTRICT& dest, size_t& len) {
 	// offset position to enable simpler loop condition checking
 	const int INPUT_OFFSET = sizeof(uint8x16_t)*4 -1; // extra chars for EOL handling, -1 to change <= to <
@@ -517,8 +519,9 @@ HEDLEY_ALWAYS_INLINE void do_encode_neon(int line_size, int* colOffset, const ui
 	dest = p;
 	len = -(i - INPUT_OFFSET);
 }
+} // namespace
 
-void encoder_neon_init() {
+void RapidYenc::encoder_neon_init() {
 	_do_encode = &do_encode_simd<do_encode_neon>;
 	_encode_isa = ISA_LEVEL_NEON;
 	// generate shuf LUT
@@ -543,5 +546,5 @@ void encoder_neon_init() {
 	}
 }
 #else
-void encoder_neon_init() {}
+void RapidYenc::encoder_neon_init() {}
 #endif /* defined(__ARM_NEON) */

package/src/encoder_rvv.cc

@@ -1,30 +1,23 @@
 #include "common.h"
+#include "encoder_common.h"
 
 #ifdef __riscv_vector
 #include "encoder.h"
-#include "encoder_common.h"
-
-# include <riscv_vector.h>
-# if defined(__clang__) && __clang_major__ < 16
-#  define RV(f) f
-# else
-#  define RV(f) __riscv_##f
-# endif
 
 
 static HEDLEY_ALWAYS_INLINE void encode_eol_handle_pre(const uint8_t* HEDLEY_RESTRICT _src, long& inpos, uint8_t*& outp, long& col, long lineSizeOffset) {
 	// TODO: vectorize
 	uint8_t c = _src[inpos++];
-	if(HEDLEY_UNLIKELY(escapedLUT[c] && c != '.'-42)) {
-		memcpy(outp, &escapedLUT[c], sizeof(uint16_t));
+	if(HEDLEY_UNLIKELY(RapidYenc::escapedLUT[c] && c != '.'-42)) {
+		memcpy(outp, &RapidYenc::escapedLUT[c], sizeof(uint16_t));
 		outp += 2;
 	} else {
 		*(outp++) = c + 42;
 	}
 	
 	c = _src[inpos++];
-	if(LIKELIHOOD(0.0273, escapedLUT[c]!=0)) {
-		uint32_t w = UINT32_16_PACK(UINT16_PACK('\r', '\n'), (uint32_t)escapedLUT[c]);
+	if(LIKELIHOOD(0.0273, RapidYenc::escapedLUT[c]!=0)) {
+		uint32_t w = UINT32_16_PACK(UINT16_PACK('\r', '\n'), (uint32_t)RapidYenc::escapedLUT[c]);
 		memcpy(outp, &w, sizeof(w));
 		outp += 4;
 		col = lineSizeOffset + 2;
@@ -36,6 +29,7 @@ static HEDLEY_ALWAYS_INLINE void encode_eol_handle_pre(const uint8_t* HEDLEY_RES
 	}
 }
 
+namespace RapidYenc {
 
 HEDLEY_ALWAYS_INLINE void do_encode_rvv(int line_size, int* colOffset, const uint8_t* HEDLEY_RESTRICT srcEnd, uint8_t* HEDLEY_RESTRICT& dest, size_t& len) {
 	size_t vl2 = RV(vsetvlmax_e8m2)(); // TODO: limit to line length
@@ -112,7 +106,7 @@ HEDLEY_ALWAYS_INLINE void do_encode_rvv(int line_size, int* colOffset, const uin
 			vl2
 		);
 		
-#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 13000
+#ifdef __riscv_v_intrinsic
 		data = RV(vor_vx_u8m2_mu)(cmp, tmpData, tmpData, 64, vl2);
 #else
 		data = RV(vor_vx_u8m2_m)(cmp, tmpData, tmpData, 64, vl2);
@@ -122,11 +116,7 @@ HEDLEY_ALWAYS_INLINE void do_encode_rvv(int line_size, int* colOffset, const uin
 		size_t count = RV(vcpop_m_b4)(cmp, vl2);
 		if(count > 1) {
 			// widen mask: 4b->8b
-#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 13000
-			vuint8mf4_t vcmp = RV(vlmul_trunc_v_u8m1_u8mf4)(RV(vreinterpret_v_b4_u8m1)(cmp));
-#else
-			vuint8mf4_t vcmp = *(vuint8mf4_t*)(&cmp);
-#endif
+			vuint8mf4_t vcmp = RV_VEC_U8MF4_CAST(cmp);
 			// TODO: use vwsll instead if available
 			//    -  is clmul useful here?
 			vuint8mf2_t xcmp = RV(vreinterpret_v_u16mf2_u8mf2)(RV(vwmulu_vx_u16mf2)(vcmp, 16, vl2));
@@ -134,11 +124,7 @@ HEDLEY_ALWAYS_INLINE void do_encode_rvv(int line_size, int* colOffset, const uin
 			
 			// expand mask by inserting '1' between each bit (0000abcd -> 1a1b1c1d)
 			vuint8m1_t xcmpTmp = RV(vrgather_vv_u8m1)(MASK_EXPAND, RV(vlmul_ext_v_u8mf2_u8m1)(xcmp), vl2);
-#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 13000
-			vbool2_t cmpmask = RV(vreinterpret_b2)(xcmpTmp);
-#else
-			vbool2_t cmpmask = *(vbool2_t*)(&xcmpTmp);
-#endif
+			vbool2_t cmpmask = RV_MASK_CAST(2, 8, xcmpTmp);
 			
 			// expand data and insert =
 			// TODO: use vwsll instead if available
@@ -149,7 +135,7 @@ HEDLEY_ALWAYS_INLINE void do_encode_rvv(int line_size, int* colOffset, const uin
 			// prune unneeded =
 			vuint8m4_t dataTmp = RV(vreinterpret_v_u16m4_u8m4)(data2);
 			vuint8m4_t final_data = RV(vcompress_vm_u8m4)(
-#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 13000
+#ifdef __riscv_v_intrinsic
 				dataTmp, cmpmask, vl2*2
 #else
 				cmpmask, dataTmp, dataTmp, vl2*2
@@ -210,11 +196,12 @@ HEDLEY_ALWAYS_INLINE void do_encode_rvv(int line_size, int* colOffset, const uin
 	dest = outp;
 	len = -(inpos - INPUT_OFFSET);
 }
+} // namespace
 
-void encoder_rvv_init() {
+void RapidYenc::encoder_rvv_init() {
 	_do_encode = &do_encode_simd<do_encode_rvv>;
 	_encode_isa = ISA_LEVEL_RVV;
 }
 #else
-void encoder_rvv_init() {}
+void RapidYenc::encoder_rvv_init() {}
 #endif /* defined(__riscv_vector) */

package/src/encoder_sse2.cc

@@ -1,14 +1,15 @@
 #include "common.h"
+#include "encoder_common.h"
 
 #ifdef __SSE2__
 #include "encoder_sse_base.h"
 
-void encoder_sse2_init() {
+void RapidYenc::encoder_sse2_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_LEVEL_SSE2> >;
 	encoder_sse_lut<ISA_LEVEL_SSE2>();
 	_encode_isa = ISA_LEVEL_SSE2;
 }
 #else
-void encoder_sse2_init() {}
+void RapidYenc::encoder_sse2_init() {}
 #endif
 

package/src/encoder_sse_base.h

@@ -147,6 +147,7 @@ static HEDLEY_ALWAYS_INLINE uintptr_t sse2_expand_store_vector(__m128i data, uns
 	}
 }
 
+namespace RapidYenc {
 
 template<enum YEncDecIsaLevel use_isa>
 HEDLEY_ALWAYS_INLINE void do_encode_sse(int line_size, int* colOffset, const uint8_t* HEDLEY_RESTRICT srcEnd, uint8_t* HEDLEY_RESTRICT& dest, size_t& len) {
@@ -720,4 +721,5 @@ HEDLEY_ALWAYS_INLINE void do_encode_sse(int line_size, int* colOffset, const uin
 	dest = p;
 	len = -(i - INPUT_OFFSET);
 }
+} // namespace
 

package/src/encoder_ssse3.cc

@@ -1,18 +1,18 @@
 #include "common.h"
+#include "encoder_common.h"
 
 // slightly faster version which improves the worst case scenario significantly; since worst case doesn't happen often, overall speedup is relatively minor
 // requires PSHUFB (SSSE3) instruction, but will use POPCNT (SSE4.2 (or AMD's ABM, but Phenom doesn't support SSSE3 so doesn't matter)) if available (these only seem to give minor speedups, so considered optional)
 #ifdef __SSSE3__
 #include "encoder_sse_base.h"
 
-void encoder_ssse3_init() {
+void RapidYenc::encoder_ssse3_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_LEVEL_SSSE3> >;
 	encoder_sse_lut<ISA_LEVEL_SSSE3>();
 	_encode_isa = ISA_LEVEL_SSSE3;
 }
 #else
-void encoder_sse2_init();
-void encoder_ssse3_init() {
+void RapidYenc::encoder_ssse3_init() {
 	encoder_sse2_init();
 }
 #endif

package/src/encoder_vbmi2.cc

@@ -1,32 +1,31 @@
 #include "common.h"
+#include "encoder_common.h"
 
-extern const bool encoder_has_avx10;
 #if !defined(__EVEX512__) && (defined(__AVX10_1__) || defined(__EVEX256__)) && defined(__AVX512VL__) && defined(__AVX512VBMI2__) && defined(__AVX512BW__)
-const bool encoder_has_avx10 = true;
+const bool RapidYenc::encoder_has_avx10 = true;
 #else
-const bool encoder_has_avx10 = false;
+const bool RapidYenc::encoder_has_avx10 = false;
 #endif
 
 #if defined(__AVX512VL__) && defined(__AVX512VBMI2__) && defined(__AVX512BW__)
 # ifndef YENC_DISABLE_AVX256
 #  include "encoder_avx_base.h"
 
-void encoder_vbmi2_init() {
+void RapidYenc::encoder_vbmi2_init() {
 	_do_encode = &do_encode_simd< do_encode_avx2<ISA_LEVEL_VBMI2> >;
 	encoder_avx2_lut<ISA_LEVEL_VBMI2>();
 	_encode_isa = ISA_LEVEL_VBMI2;
 }
 # else
 #  include "encoder_sse_base.h"
-void encoder_vbmi2_init() {
+void RapidYenc::encoder_vbmi2_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_LEVEL_VBMI2> >;
 	encoder_sse_lut<ISA_LEVEL_VBMI2>();
 	_encode_isa = ISA_LEVEL_VBMI2;
 }
 # endif
 #else
-void encoder_avx2_init();
-void encoder_vbmi2_init() {
+void RapidYenc::encoder_vbmi2_init() {
 	encoder_avx2_init();
 }
 #endif

package/src/platform.cc

@@ -17,7 +17,7 @@
 #   endif
 #  endif
 # endif
-bool cpu_supports_neon() {
+bool RapidYenc::cpu_supports_neon() {
 # if defined(AT_HWCAP)
 #  ifdef __FreeBSD__
 	unsigned long supported;
@@ -95,7 +95,7 @@ static inline int _GET_XCR() {
 // }
 
 
-int cpu_supports_isa() {
+int RapidYenc::cpu_supports_isa() {
 	int flags[4];
 	_cpuid1(flags);
 	int ret = 0;
@@ -132,29 +132,30 @@ int cpu_supports_isa() {
 					int cpuInfo[4];
 					_cpuidX(cpuInfo, 7, 0);
 					if((cpuInfo[1] & 0x128) == 0x128 && (ret & ISA_FEATURE_LZCNT)) { // BMI2 + AVX2 + BMI1
-						
-						// check AVX10
-						int cpuInfo2[4];
-						_cpuidX(cpuInfo2, 7, 1);
-						if(cpuInfo2[3] & 0x80000) {
-							_cpuidX(cpuInfo2, 0x24, 0);
-							if((cpuInfo2[2] & 0xff) >= 1 && ( // minimum AVX10.1
+						if((xcr & 0xE0) == 0xE0) { // AVX512 XSTATE (also applies to AVX10)
+							// check AVX10
+							int cpuInfo2[4];
+							_cpuidX(cpuInfo2, 7, 1);
+							if(cpuInfo2[3] & 0x80000) {
+								_cpuidX(cpuInfo2, 0x24, 0);
+								if((cpuInfo2[1] & 0xff) >= 1 && ( // minimum AVX10.1
 #ifdef YENC_DISABLE_AVX256
-								cpuInfo2[2] & 0x10000 // AVX10/128
+									cpuInfo2[1] & 0x10000 // AVX10/128
 #else
-								cpuInfo2[2] & 0x20000 // AVX10/256
+									cpuInfo2[1] & 0x20000 // AVX10/256
 #endif
-							)) {
-								if(((xcr & 0xE0) == 0xE0) && (cpuInfo2[2] & 0x40000)) ret |= ISA_FEATURE_EVEX512;
-								return ret | ISA_LEVEL_VBMI2;
+								)) {
+									if(cpuInfo2[1] & 0x40000) ret |= ISA_FEATURE_EVEX512;
+									return ret | ISA_LEVEL_VBMI2;
+								}
+							}
+							
+							if((cpuInfo[1] & 0xC0010000) == 0xC0010000) { // AVX512BW + AVX512VL + AVX512F
+								ret |= ISA_FEATURE_EVEX512;
+								if(cpuInfo[2] & 0x40)
+									return ret | ISA_LEVEL_VBMI2;
+								return ret | ISA_LEVEL_AVX3;
 							}
-						}
-						
-						if(((xcr & 0xE0) == 0xE0) && (cpuInfo[1] & 0xC0010000) == 0xC0010000) { // AVX512BW + AVX512VL + AVX512F
-							ret |= ISA_FEATURE_EVEX512;
-							if(cpuInfo[2] & 0x40)
-								return ret | ISA_LEVEL_VBMI2;
-							return ret | ISA_LEVEL_AVX3;
 						}
 						// AVX2 is beneficial even on Zen1
 						return ret | ISA_LEVEL_AVX2;
@@ -169,7 +170,7 @@ int cpu_supports_isa() {
 	return ret | ISA_LEVEL_SSE2;
 }
 
-int cpu_supports_crc_isa() {
+int RapidYenc::cpu_supports_crc_isa() {
 	int flags[4];
 	_cpuid1(flags);
 	
@@ -200,7 +201,7 @@ int cpu_supports_crc_isa() {
 #   endif
 #  endif
 # endif
-bool cpu_supports_rvv() {
+bool RapidYenc::cpu_supports_rvv() {
 # if defined(AT_HWCAP)
 	unsigned long ret;
 #  ifdef __FreeBSD__