yencode 1.2.0 → 1.2.1

package/src/decoder_sse_base.h

@@ -25,15 +25,17 @@
 # define KOR16(a, b) ((a) | (b))
 #endif
 
-#pragma pack(16)
-typedef struct {
-	unsigned char BitsSetTable256inv[256];
-	/*align16*/ struct { char bytes[16]; } compact[32768];
-	/*align8*/ uint64_t eqAdd[256];
-	/*align16*/ int8_t unshufMask[32*16];
-} SSELookups;
-static SSELookups* HEDLEY_RESTRICT lookups;
-#pragma pack()
+namespace RapidYenc {
+	#pragma pack(16)
+	typedef struct {
+		unsigned char BitsSetTable256inv[256];
+		/*align16*/ struct { char bytes[16]; } compact[32768];
+		/*align8*/ uint64_t eqAdd[256];
+		/*align16*/ int8_t unshufMask[32*16];
+	} SSELookups;
+	#pragma pack()
+}
+static RapidYenc::SSELookups* HEDLEY_RESTRICT lookups;
 
 
 static HEDLEY_ALWAYS_INLINE __m128i force_align_read_128(const void* p) {
@@ -45,7 +47,9 @@ static HEDLEY_ALWAYS_INLINE __m128i force_align_read_128(const void* p) {
 #endif
 }
 
-void decoder_sse_init(SSELookups* HEDLEY_RESTRICT& lookups); // defined in decoder_sse2.cc
+namespace RapidYenc {
+	void decoder_sse_init(SSELookups* HEDLEY_RESTRICT& lookups); // defined in decoder_sse2.cc
+}
 
 
 // for LZCNT/BSR
@@ -90,6 +94,8 @@ static HEDLEY_ALWAYS_INLINE __m128i sse2_compact_vect(uint32_t mask, __m128i dat
 	return data;
 }
 
+namespace RapidYenc {
+
 template<bool isRaw, bool searchEnd, enum YEncDecIsaLevel use_isa>
 HEDLEY_ALWAYS_INLINE void do_decode_sse(const uint8_t* src, long& len, unsigned char*& p, unsigned char& _escFirst, uint16_t& _nextMask) {
 	HEDLEY_ASSUME(_escFirst == 0 || _escFirst == 1);
@@ -500,8 +506,9 @@ HEDLEY_ALWAYS_INLINE void do_decode_sse(const uint8_t* src, long& len, unsigned
 			if(!_USING_BLEND_ADD)
 				dataB = _mm_add_epi8(oDataB, _mm_set1_epi8(-42));
 			
-			if(LIKELIHOOD(0.0001, (mask & ((maskEq << 1) + escFirst)) != 0)) {
-				maskEq = fix_eqMask<uint32_t>(maskEq & ~escFirst);
+			uint32_t maskEqShift1 = (maskEq << 1) + escFirst;
+			if(LIKELIHOOD(0.0001, (mask & maskEqShift1) != 0)) {
+				maskEq = fix_eqMask<uint32_t>(maskEq, maskEqShift1);
 				mask &= ~escFirst;
 				escFirst = maskEq >> 31;
 				// next, eliminate anything following a `=` from the special char mask; this eliminates cases of `=\r` so that they aren't removed
@@ -688,4 +695,5 @@ HEDLEY_ALWAYS_INLINE void do_decode_sse(const uint8_t* src, long& len, unsigned
 	}
 	_escFirst = (unsigned char)escFirst;
 }
+} // namespace
 #endif

package/src/decoder_ssse3.cc

@@ -1,9 +1,9 @@
 #include "common.h"
 
-#ifdef __SSSE3__
 #include "decoder_common.h"
+#ifdef __SSSE3__
 #include "decoder_sse_base.h"
-void decoder_set_ssse3_funcs() {
+void RapidYenc::decoder_set_ssse3_funcs() {
 	decoder_sse_init(lookups);
 	decoder_init_lut(lookups->compact);
 	_do_decode = &do_decode_simd<false, false, sizeof(__m128i)*2, do_decode_sse<false, false, ISA_LEVEL_SSSE3> >;
@@ -12,8 +12,7 @@ void decoder_set_ssse3_funcs() {
 	_decode_isa = ISA_LEVEL_SSSE3;
 }
 #else
-void decoder_set_sse2_funcs();
-void decoder_set_ssse3_funcs() {
+void RapidYenc::decoder_set_ssse3_funcs() {
 	decoder_set_sse2_funcs();
 }
 #endif

package/src/decoder_vbmi2.cc

@@ -1,17 +1,16 @@
 #include "common.h"
+# include "decoder_common.h"
 
-extern const bool decoder_has_avx10;
 #if !defined(__EVEX512__) && (defined(__AVX10_1__) || defined(__EVEX256__)) && defined(__AVX512VL__) && defined(__AVX512VBMI2__) && defined(__AVX512BW__)
-const bool decoder_has_avx10 = true;
+const bool RapidYenc::decoder_has_avx10 = true;
 #else
-const bool decoder_has_avx10 = false;
+const bool RapidYenc::decoder_has_avx10 = false;
 #endif
 
 #if defined(__AVX512VL__) && defined(__AVX512VBMI2__) && defined(__AVX512BW__)
-# include "decoder_common.h"
 # ifndef YENC_DISABLE_AVX256
 #  include "decoder_avx2_base.h"
-void decoder_set_vbmi2_funcs() {
+void RapidYenc::decoder_set_vbmi2_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m256i)*2, do_decode_avx2<false, false, ISA_LEVEL_VBMI2> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m256i)*2, do_decode_avx2<true, false, ISA_LEVEL_VBMI2> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m256i)*2, do_decode_avx2<true, true, ISA_LEVEL_VBMI2> >;
@@ -19,7 +18,7 @@ void decoder_set_vbmi2_funcs() {
 }
 # else
 #  include "decoder_sse_base.h"
-void decoder_set_vbmi2_funcs() {
+void RapidYenc::decoder_set_vbmi2_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m128i)*2, do_decode_sse<false, false, ISA_LEVEL_VBMI2> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_LEVEL_VBMI2> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_LEVEL_VBMI2> >;
@@ -27,8 +26,7 @@ void decoder_set_vbmi2_funcs() {
 }
 # endif
 #else
-void decoder_set_avx2_funcs();
-void decoder_set_vbmi2_funcs() {
+void RapidYenc::decoder_set_vbmi2_funcs() {
 	decoder_set_avx2_funcs();
 }
 #endif

package/src/encoder.cc

@@ -9,12 +9,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 escapeLUT[256] = { // whether or not the character is critical
+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 escapedLUT[256] = { // escaped sequences for characters that need escaping
+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
@@ -27,7 +27,7 @@ const uint16_t escapedLUT[256] = { // escaped sequences for characters that need
 
 
 
-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 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
@@ -36,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 {
@@ -52,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);
@@ -80,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;
 			}
@@ -104,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;
@@ -115,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;
@@ -145,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,19 +1,31 @@
 #ifndef __YENC_ENCODER_COMMON
 #define __YENC_ENCODER_COMMON
 
-// lookup tables for scalar processing
-extern const unsigned char escapeLUT[256];
-extern const uint16_t escapedLUT[256];
+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;
@@ -27,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 {
@@ -39,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;
@@ -61,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,23 +1,23 @@
 #include "common.h"
+#include "encoder_common.h"
 
 #ifdef __riscv_vector
 #include "encoder.h"
-#include "encoder_common.h"
 
 
 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;
@@ -29,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
@@ -195,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