yencode 1.1.5 → 1.2.1

package/src/decoder.h

@@ -1,10 +1,9 @@
 #ifndef __YENC_DECODER_H
 #define __YENC_DECODER_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include "hedley.h"
 
+namespace RapidYenc {
 
 
 // the last state that the decoder was in (i.e. last few characters processed)
@@ -27,21 +26,20 @@ typedef enum {
 	YDEC_END_ARTICLE  // \r\n.\r\n sequence found, src points to byte after last '\n'
 } YencDecoderEnd;
 
-#include "hedley.h"
 
 extern YencDecoderEnd (*_do_decode)(const unsigned char**, unsigned char**, size_t, YencDecoderState*);
 extern YencDecoderEnd (*_do_decode_raw)(const unsigned char**, unsigned char**, size_t, YencDecoderState*);
 extern YencDecoderEnd (*_do_decode_end_raw)(const unsigned char**, unsigned char**, size_t, YencDecoderState*);
 extern int _decode_isa;
 
-static inline size_t do_decode(int isRaw, const unsigned char* src, unsigned char* dest, size_t len, YencDecoderState* state) {
-	unsigned char* ds = dest;
-	(*(isRaw ? _do_decode_raw : _do_decode))(&src, &ds, len, state);
-	return ds - dest;
+static inline size_t decode(int isRaw, const void* src, void* dest, size_t len, YencDecoderState* state) {
+	unsigned char* ds = (unsigned char*)dest;
+	(*(isRaw ? _do_decode_raw : _do_decode))((const unsigned char**)&src, &ds, len, state);
+	return ds - (unsigned char*)dest;
 }
 
-static inline YencDecoderEnd do_decode_end(const unsigned char** src, unsigned char** dest, size_t len, YencDecoderState* state) {
-	return _do_decode_end_raw(src, dest, len, state);
+static inline YencDecoderEnd decode_end(const void** src, void** dest, size_t len, YencDecoderState* state) {
+	return _do_decode_end_raw((const unsigned char**)src, (unsigned char**)dest, len, state);
 }
 
 void decoder_init();
@@ -51,7 +49,5 @@ static inline int decode_isa_level() {
 }
 
 
-#ifdef __cplusplus
-}
-#endif
-#endif
+} // namespace
+#endif // defined(__YENC_DECODER_H)

package/src/decoder_avx.cc

@@ -1,19 +1,18 @@
 #include "common.h"
 
-#if defined(__AVX__) && defined(__POPCNT__)
 #include "decoder_common.h"
+#if defined(__AVX__) && defined(__POPCNT__)
 #include "decoder_sse_base.h"
-void decoder_set_avx_funcs() {
-	decoder_sse_init();
-	decoder_init_lut(lookups->eqFix, lookups->compact);
+void RapidYenc::decoder_set_avx_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_SSE4_POPCNT> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_LEVEL_SSE4_POPCNT> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_LEVEL_SSE4_POPCNT> >;
 	_decode_isa = ISA_LEVEL_AVX;
 }
 #else
-void decoder_set_ssse3_funcs();
-void decoder_set_avx_funcs() {
+void RapidYenc::decoder_set_avx_funcs() {
 	decoder_set_ssse3_funcs();
 }
 #endif

package/src/decoder_avx2.cc

@@ -1,19 +1,18 @@
 #include "common.h"
 
-#if defined(__AVX2__) && !defined(YENC_DISABLE_AVX256)
 #include "decoder_common.h"
+#if defined(__AVX2__) && !defined(YENC_DISABLE_AVX256)
 #include "decoder_avx2_base.h"
-void decoder_set_avx2_funcs() {
+void RapidYenc::decoder_set_avx2_funcs() {
 	ALIGN_ALLOC(lookups, sizeof(*lookups), 16);
-	decoder_init_lut(lookups->eqFix, lookups->compact);
-	_do_decode = &do_decode_simd<false, false, sizeof(__m256i)*2, do_decode_avx2<false, false, ISA_LEVEL_AVX2> >;
-	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m256i)*2, do_decode_avx2<true, false, ISA_LEVEL_AVX2> >;
-	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m256i)*2, do_decode_avx2<true, true, ISA_LEVEL_AVX2> >;
-	_decode_isa = ISA_LEVEL_AVX2;
+	decoder_init_lut(lookups->compact);
+	RapidYenc::_do_decode = &do_decode_simd<false, false, sizeof(__m256i)*2, do_decode_avx2<false, false, ISA_LEVEL_AVX2> >;
+	RapidYenc::_do_decode_raw = &do_decode_simd<true, false, sizeof(__m256i)*2, do_decode_avx2<true, false, ISA_LEVEL_AVX2> >;
+	RapidYenc::_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m256i)*2, do_decode_avx2<true, true, ISA_LEVEL_AVX2> >;
+	RapidYenc::_decode_isa = ISA_LEVEL_AVX2;
 }
 #else
-void decoder_set_avx_funcs();
-void decoder_set_avx2_funcs() {
+void RapidYenc::decoder_set_avx2_funcs() {
 	decoder_set_avx_funcs();
 }
 #endif

package/src/decoder_avx2_base.h

@@ -15,7 +15,6 @@
 #pragma pack(16)
 static struct {
 	/*align16*/ struct { char bytes[16]; } compact[32768];
-	uint8_t eqFix[256];
 } * HEDLEY_RESTRICT lookups;
 #pragma pack()
 
@@ -50,6 +49,8 @@ static HEDLEY_ALWAYS_INLINE __m256i force_align_read_256(const void* p) {
 # define COMPRESS_STORE(dst, mask, vec) _mm256_storeu_si256((__m256i*)(dst), _mm256_maskz_compress_epi8(mask, vec))
 #endif
 
+namespace RapidYenc {
+
 template<bool isRaw, bool searchEnd, enum YEncDecIsaLevel use_isa>
 HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* src, long& len, unsigned char*& p, unsigned char& _escFirst, uint16_t& _nextMask) {
 	HEDLEY_ASSUME(_escFirst == 0 || _escFirst == 1);
@@ -430,17 +431,11 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* src, long& len, unsigned
 			if(use_isa >= ISA_LEVEL_AVX3)
 				dataB = _mm256_add_epi8(oDataB, _mm256_set1_epi8(-42));
 			
-			if(LIKELIHOOD(0.0001, (mask & ((maskEq << 1) + escFirst)) != 0)) {
-				unsigned tmp = lookups->eqFix[(maskEq&0xff) & ~(uint64_t)escFirst];
-				uint64_t maskEq2 = tmp;
-				for(int j=8; j<64; j+=8) {
-					tmp = lookups->eqFix[(unsigned)((maskEq>>j)&0xff) & ~(tmp>>7)];
-					maskEq2 |= (uint64_t)tmp<<j;
-				}
-				maskEq = maskEq2;
-				
+			uint64_t maskEqShift1 = (maskEq << 1) + escFirst;
+			if(LIKELIHOOD(0.0001, (mask & maskEqShift1) != 0)) {
+				maskEq = fix_eqMask<uint64_t>(maskEq, maskEqShift1);
 				mask &= ~(uint64_t)escFirst;
-				escFirst = tmp>>7;
+				escFirst = maskEq>>63;
 				// next, eliminate anything following a `=` from the special char mask; this eliminates cases of `=\r` so that they aren't removed
 				maskEq <<= 1;
 				mask &= ~maskEq;
@@ -619,4 +614,5 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* src, long& len, unsigned
 	_escFirst = (unsigned char)escFirst;
 	_mm256_zeroupper();
 }
+} // namespace
 #endif

package/src/decoder_common.h

@@ -1,338 +1,32 @@
 #include "decoder.h"
 
-// TODO: need to support max output length somehow
-// TODO: add branch probabilities
-
-
-// state var: refers to the previous state - only used for incremental processing
-template<bool isRaw>
-size_t do_decode_noend_scalar(const unsigned char* src, unsigned char* dest, size_t len, YencDecoderState* state) {
-	const unsigned char *es = src + len; // end source pointer
-	unsigned char *p = dest; // destination pointer
-	long i = -(long)len; // input position
-	unsigned char c; // input character
-	
-	if(len < 1) return 0;
+namespace RapidYenc {
+	void decoder_set_sse2_funcs();
+	void decoder_set_ssse3_funcs();
+	void decoder_set_avx_funcs();
+	void decoder_set_avx2_funcs();
+	void decoder_set_vbmi2_funcs();
+	extern const bool decoder_has_avx10;
+	void decoder_set_neon_funcs();
+	void decoder_set_rvv_funcs();
 	
-	if(isRaw) {
-		
-		if(state) switch(*state) {
-			case YDEC_STATE_EQ:
-				c = es[i];
-				*p++ = c - 42 - 64;
-				i++;
-				if(c == '\r') {
-					*state = YDEC_STATE_CR;
-					if(i >= 0) return 0;
-				} else {
-					*state = YDEC_STATE_NONE;
-					break;
-				}
-				// fall-thru
-			case YDEC_STATE_CR:
-				if(es[i] != '\n') break;
-				i++;
-				*state = YDEC_STATE_CRLF;
-				if(i >= 0) return 0;
-				// Else fall-thru
-			case YDEC_STATE_CRLF:
-				// skip past first dot
-				if(es[i] == '.') i++;
-				// fall-thru
-			default: break; // silence compiler warnings
-		} else // treat as YDEC_STATE_CRLF
-			if(es[i] == '.') i++;
-		
-		for(; i < -2; i++) {
-			c = es[i];
-			switch(c) {
-				case '\r':
-					// skip past \r\n. sequences
-					//i += (es[i+1] == '\n' && es[i+2] == '.') << 1;
-					if(es[i+1] == '\n' && es[i+2] == '.')
-						i += 2;
-					// fall-thru
-				case '\n':
-					continue;
-				case '=':
-					c = es[i+1];
-					*p++ = c - 42 - 64;
-					i += (c != '\r'); // if we have a \r, reprocess character to deal with \r\n. case
-					continue;
-				default:
-					*p++ = c - 42;
-			}
-		}
-		if(state) *state = YDEC_STATE_NONE;
-		
-		if(i == -2) { // 2nd last char
-			c = es[i];
-			switch(c) {
-				case '\r':
-					if(state && es[i+1] == '\n') {
-						*state = YDEC_STATE_CRLF;
-						return p - dest;
-					}
-					// Else fall-thru
-				case '\n':
-					break;
-				case '=':
-					c = es[i+1];
-					*p++ = c - 42 - 64;
-					i += (c != '\r');
-					break;
-				default:
-					*p++ = c - 42;
-			}
-			i++;
-		}
-		
-		// do final char; we process this separately to prevent an overflow if the final char is '='
-		if(i == -1) {
-			c = es[i];
-			if(c != '\n' && c != '\r' && c != '=') {
-				*p++ = c - 42;
-			} else if(state) {
-				if(c == '=') *state = YDEC_STATE_EQ;
-				else if(c == '\r') *state = YDEC_STATE_CR;
-				else *state = YDEC_STATE_NONE;
-			}
-		}
-		
-	} else {
-		
-		if(state && *state == YDEC_STATE_EQ) {
-			*p++ = es[i] - 42 - 64;
-			i++;
-			*state = YDEC_STATE_NONE;
-		}
-		
-		/*for(i = 0; i < len - 1; i++) {
-			c = src[i];
-			if(c == '\n' || c == '\r') continue;
-			unsigned char isEquals = (c == '=');
-			i += isEquals;
-			*p++ = src[i] - (42 + (isEquals << 6));
-		}*/
-		for(; i < -1; i++) {
-			c = es[i];
-			switch(c) {
-				case '\n': case '\r': continue;
-				case '=':
-					i++;
-					c = es[i] - 64;
-			}
-			*p++ = c - 42;
-		}
-		if(state) *state = YDEC_STATE_NONE;
-		// do final char; we process this separately to prevent an overflow if the final char is '='
-		if(i == -1) {
-			c = es[i];
-			if(c != '\n' && c != '\r' && c != '=') {
-				*p++ = c - 42;
-			} else
-				if(state) *state = (c == '=' ? YDEC_STATE_EQ : YDEC_STATE_NONE);
-		}
-		
-	}
-	
-	return p - dest;
+	template<bool isRaw, bool searchEnd>
+	YencDecoderEnd do_decode_scalar(const unsigned char** src, unsigned char** dest, size_t len, YencDecoderState* state);
 }
 
-template<bool isRaw>
-YencDecoderEnd do_decode_end_scalar(const unsigned char** src, unsigned char** dest, size_t len, YencDecoderState* state) {
-	const unsigned char *es = (*src) + len; // end source pointer
-	unsigned char *p = *dest; // destination pointer
-	long i = -(long)len; // input position
-	unsigned char c; // input character
-	
-	if(len < 1) return YDEC_END_NONE;
-	
-#define YDEC_CHECK_END(s) if(i == 0) { \
-	*state = s; \
-	*src = es; \
-	*dest = p; \
-	return YDEC_END_NONE; \
-}
-	if(state) switch(*state) {
-		case YDEC_STATE_CRLFEQ: do_decode_endable_scalar_ceq:
-			if(es[i] == 'y') {
-				*state = YDEC_STATE_NONE;
-				*src = es+i+1;
-				*dest = p;
-				return YDEC_END_CONTROL;
-			} // Else fall-thru
-		case YDEC_STATE_EQ:
-			c = es[i];
-			*p++ = c - 42 - 64;
-			i++;
-			if(c != '\r') break;
-			YDEC_CHECK_END(YDEC_STATE_CR)
-			// fall-through
-		case YDEC_STATE_CR:
-			if(es[i] != '\n') break;
-			i++;
-			YDEC_CHECK_END(YDEC_STATE_CRLF)
-			// fall-through
-		case YDEC_STATE_CRLF: do_decode_endable_scalar_c0:
-			if(es[i] == '.' && isRaw) {
-				i++;
-				YDEC_CHECK_END(YDEC_STATE_CRLFDT)
-				// fall-through
-			} else if(es[i] == '=') {
-				i++;
-				YDEC_CHECK_END(YDEC_STATE_CRLFEQ)
-				goto do_decode_endable_scalar_ceq;
-			} else
-				break;
-		case YDEC_STATE_CRLFDT:
-			if(isRaw && es[i] == '\r') {
-				i++;
-				YDEC_CHECK_END(YDEC_STATE_CRLFDTCR)
-				// fall-through
-			} else if(isRaw && es[i] == '=') { // check for dot-stuffed ending: \r\n.=y
-				i++;
-				YDEC_CHECK_END(YDEC_STATE_CRLFEQ)
-				goto do_decode_endable_scalar_ceq;
-			} else
-				break;
-		case YDEC_STATE_CRLFDTCR:
-			if(es[i] == '\n') {
-				if(isRaw) {
-					*state = YDEC_STATE_CRLF;
-					*src = es + i + 1;
-					*dest = p;
-					return YDEC_END_ARTICLE;
-				} else {
-					i++;
-					YDEC_CHECK_END(YDEC_STATE_CRLF)
-					goto do_decode_endable_scalar_c0; // handle as CRLF
-				}
-			} else
-				break;
-		case YDEC_STATE_NONE: break; // silence compiler warning
-	} else // treat as YDEC_STATE_CRLF
-		goto do_decode_endable_scalar_c0;
-	
-	for(; i < -2; i++) {
-		c = es[i];
-		switch(c) {
-			case '\r': if(es[i+1] == '\n') {
-				if(isRaw && es[i+2] == '.') {
-					// skip past \r\n. sequences
-					i += 3;
-					YDEC_CHECK_END(YDEC_STATE_CRLFDT)
-					// check for end
-					if(es[i] == '\r') {
-						i++;
-						YDEC_CHECK_END(YDEC_STATE_CRLFDTCR)
-						if(es[i] == '\n') {
-							*src = es + i + 1;
-							*dest = p;
-							*state = YDEC_STATE_CRLF;
-							return YDEC_END_ARTICLE;
-						} else i--;
-					} else if(es[i] == '=') {
-						i++;
-						YDEC_CHECK_END(YDEC_STATE_CRLFEQ)
-						if(es[i] == 'y') {
-							*src = es + i + 1;
-							*dest = p;
-							*state = YDEC_STATE_NONE;
-							return YDEC_END_CONTROL;
-						} else {
-							// escape char & continue
-							c = es[i];
-							*p++ = c - 42 - 64;
-							i -= (c == '\r');
-						}
-					} else i--;
-				}
-				else if(es[i+2] == '=') {
-					i += 3;
-					YDEC_CHECK_END(YDEC_STATE_CRLFEQ)
-					if(es[i] == 'y') {
-						// ended
-						*src = es + i + 1;
-						*dest = p;
-						*state = YDEC_STATE_NONE;
-						return YDEC_END_CONTROL;
-					} else {
-						// escape char & continue
-						c = es[i];
-						*p++ = c - 42 - 64;
-						i -= (c == '\r');
-					}
-				}
-			} // fall-thru
-			case '\n':
-				continue;
-			case '=':
-				c = es[i+1];
-				*p++ = c - 42 - 64;
-				i += (c != '\r'); // if we have a \r, reprocess character to deal with \r\n. case
-				continue;
-			default:
-				*p++ = c - 42;
-		}
-	}
-	if(state) *state = YDEC_STATE_NONE;
-	
-	if(i == -2) { // 2nd last char
-		c = es[i];
-		switch(c) {
-			case '\r':
-				if(state && es[i+1] == '\n') {
-					*state = YDEC_STATE_CRLF;
-					*src = es;
-					*dest = p;
-					return YDEC_END_NONE;
-				}
-				// Else fall-thru
-			case '\n':
-				break;
-			case '=':
-				c = es[i+1];
-				*p++ = c - 42 - 64;
-				i += (c != '\r');
-				break;
-			default:
-				*p++ = c - 42;
-		}
-		i++;
-	}
-	
-	// do final char; we process this separately to prevent an overflow if the final char is '='
-	if(i == -1) {
-		c = es[i];
-		if(c != '\n' && c != '\r' && c != '=') {
-			*p++ = c - 42;
-		} else if(state) {
-			if(c == '=') *state = YDEC_STATE_EQ;
-			else if(c == '\r') *state = YDEC_STATE_CR;
-			else *state = YDEC_STATE_NONE;
-		}
-	}
-#undef YDEC_CHECK_END
-	
-	*src = es;
-	*dest = p;
-	return YDEC_END_NONE;
-}
 
-template<bool isRaw, bool searchEnd>
-YencDecoderEnd do_decode_scalar(const unsigned char** src, unsigned char** dest, size_t len, YencDecoderState* state) {
-	if(searchEnd)
-		return do_decode_end_scalar<isRaw>(src, dest, len, state);
-	*dest += do_decode_noend_scalar<isRaw>(*src, *dest, len, state);
-	*src += len;
-	return YDEC_END_NONE;
-}
+#if defined(PLATFORM_ARM) && !defined(__aarch64__)
+#define YENC_DEC_USE_THINTABLE 1
+#endif
 
+// TODO: need to support max output length somehow
 
 
-template<bool isRaw, bool searchEnd, int width, void(&kernel)(const uint8_t*, long&, unsigned char*&, unsigned char&, uint16_t&)>
-YencDecoderEnd do_decode_simd(const unsigned char** src, unsigned char** dest, size_t len, YencDecoderState* state) {
+
+template<bool isRaw, bool searchEnd, void(&kernel)(const uint8_t*, long&, unsigned char*&, unsigned char&, uint16_t&)>
+static inline RapidYenc::YencDecoderEnd _do_decode_simd(size_t width, const unsigned char** src, unsigned char** dest, size_t len, RapidYenc::YencDecoderState* state) {
+	using namespace RapidYenc;
+	
 	if(len <= width*2) return do_decode_scalar<isRaw, searchEnd>(src, dest, len, state);
 	
 	YencDecoderState tState = YDEC_STATE_CRLF;
@@ -461,54 +155,22 @@ YencDecoderEnd do_decode_simd(const unsigned char** src, unsigned char** dest, s
 	return YDEC_END_NONE;
 }
 
-static inline void decoder_init_lut(uint8_t* eqFixLUT, void* compactLUT) {
-	for(int i=0; i<256; i++) {
-		int k = i;
-		int p = 0;
-		
-		// fix LUT
-		k = i;
-		p = 0;
-		for(int j=0; j<8; j++) {
-			k = i >> j;
-			if(k & 1) {
-				p |= 1 << j;
-				j++;
-			}
-		}
-		eqFixLUT[i] = p;
-		
-		#ifdef YENC_DEC_USE_THINTABLE
-		uint8_t* res = (uint8_t*)compactLUT + i*8;
-		k = i;
-		p = 0;
-		for(int j=0; j<8; j++) {
-			if(!(k & 1)) {
-				res[p++] = j;
-			}
-			k >>= 1;
-		}
-		for(; p<8; p++)
-			res[p] = 0x80;
-		#endif
-	}
-	#ifndef YENC_DEC_USE_THINTABLE
-	for(int i=0; i<32768; i++) {
-		int k = i;
-		uint8_t* res = (uint8_t*)compactLUT + i*16;
-		int p = 0;
-		
-		for(int j=0; j<16; j++) {
-			if(!(k & 1)) {
-				res[p++] = j;
-			}
-			k >>= 1;
-		}
-		for(; p<16; p++)
-			res[p] = 0x80;
-	}
-	#endif
+template<bool isRaw, bool searchEnd, size_t width, void(&kernel)(const uint8_t*, long&, unsigned char*&, unsigned char&, uint16_t&)>
+static RapidYenc::YencDecoderEnd do_decode_simd(const unsigned char** src, unsigned char** dest, size_t len, RapidYenc::YencDecoderState* state) {
+	return _do_decode_simd<isRaw, searchEnd, kernel>(width, src, dest, len, state);
 }
+template<bool isRaw, bool searchEnd, size_t(&getWidth)(), void(&kernel)(const uint8_t*, long&, unsigned char*&, unsigned char&, uint16_t&)>
+static RapidYenc::YencDecoderEnd do_decode_simd(const unsigned char** src, unsigned char** dest, size_t len, RapidYenc::YencDecoderState* state) {
+	return _do_decode_simd<isRaw, searchEnd, kernel>(getWidth(), src, dest, len, state);
+}
+
+
+#if defined(PLATFORM_X86) || defined(PLATFORM_ARM)
+namespace RapidYenc {
+	void decoder_init_lut(void* compactLUT);
+}
+#endif
+
 template<bool isRaw>
 static inline void decoder_set_nextMask(const uint8_t* src, size_t len, uint16_t& nextMask) {
 	if(isRaw) {
@@ -535,3 +197,24 @@ static inline uint16_t decoder_set_nextMask(const uint8_t* src, unsigned mask) {
 	}
 	return 0;
 }
+
+// resolve invalid sequences of = to deal with cases like '===='
+// bit hack inspired from simdjson: https://youtu.be/wlvKAT7SZIQ?t=33m38s
+template<typename T>
+static inline T fix_eqMask(T mask, T maskShift1) {
+	// isolate the start of each consecutive bit group (e.g. 01011101 -> 01000101)
+	T start = mask & ~maskShift1;
+	
+	// this strategy works by firstly separating groups that start on even/odd bits
+	// generally, it doesn't matter which one (even/odd) we pick, but clearing even groups specifically allows the escFirst bit in maskShift1 to work
+	// (this is because the start of the escFirst group is at index -1, an odd bit, but we can't clear it due to being < 0, so we just retain all odd groups instead)
+	
+	const T even = (T)0x5555555555555555; // every even bit (01010101...)
+	
+	// obtain groups which start on an odd bit (clear groups that start on an even bit, but this leaves an unwanted trailing bit)
+	T oddGroups = mask + (start & even);
+	
+	// clear even bits in odd groups, whilst conversely preserving even bits in even groups
+	// the `& mask` also conveniently gets rid of unwanted trailing bits
+	return (oddGroups ^ even) & mask;
+}

package/src/decoder_neon.cc

@@ -1,11 +1,8 @@
 #include "common.h"
-#ifdef __ARM_NEON
-
-#ifndef __aarch64__
-#define YENC_DEC_USE_THINTABLE 1
-#endif
 #include "decoder_common.h"
 
+#ifdef __ARM_NEON
+
 
 #if defined(_MSC_VER) && !defined(__clang__)
 # define vld1_u8_align(p, a) vld1_u8_ex(p, a*8)
@@ -43,8 +40,6 @@ static struct { char bytes[16]; } ALIGN_TO(16, compactLUT[32768]);
 # pragma pack()
 #endif
 
-static uint8_t eqFixLUT[256];
-
 
 
 static bool neon_vect_is_nonzero(uint8x16_t v) {
@@ -58,6 +53,8 @@ static bool neon_vect_is_nonzero(uint8x16_t v) {
 }
 
 
+namespace RapidYenc {
+
 template<bool isRaw, bool searchEnd>
 HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned char*& p, unsigned char& escFirst, uint16_t& nextMask) {
 	HEDLEY_ASSUME(escFirst == 0 || escFirst == 1);
@@ -327,19 +324,15 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 			// a spec compliant encoder should never generate sequences: ==, =\n and =\r, but we'll handle them to be spec compliant
 			// the yEnc specification requires any character following = to be unescaped, not skipped over, so we'll deal with that
 			// firstly, check for invalid sequences of = (we assume that these are rare, as a spec compliant yEnc encoder should not generate these)
-			if(LIKELIHOOD(0.0001, (mask & ((maskEq << 1) | escFirst)) != 0)) {
-				uint8_t tmp = eqFixLUT[(maskEq&0xff) & ~escFirst];
-				uint32_t maskEq2 = tmp;
-				for(int j=8; j<32; j+=8) {
-					tmp = eqFixLUT[((maskEq>>j)&0xff) & ~(tmp>>7)];
-					maskEq2 |= tmp<<j;
-				}
-				maskEq = maskEq2;
+			uint32_t maskEqShift1 = (maskEq << 1) | escFirst;
+			if(LIKELIHOOD(0.0001, (mask & maskEqShift1) != 0)) {
+				maskEq = fix_eqMask<uint32_t>(maskEq, maskEqShift1);
 				
+				unsigned char nextEscFirst = maskEq>>31;
 				// next, eliminate anything following a `=` from the special char mask; this eliminates cases of `=\r` so that they aren't removed
 				maskEq = (maskEq<<1) | escFirst;
 				mask &= ~maskEq;
-				escFirst = tmp>>7;
+				escFirst = nextEscFirst;
 				
 				// unescape chars following `=`
 				uint8x8_t maskEqTemp = vreinterpret_u8_u32(vmov_n_u32(maskEq));
@@ -455,14 +448,15 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 		}
 	}
 }
+} // namespace
 
-void decoder_set_neon_funcs() {
-	decoder_init_lut(eqFixLUT, compactLUT);
+void RapidYenc::decoder_set_neon_funcs() {
+	decoder_init_lut(compactLUT);
 	_do_decode = &do_decode_simd<false, false, sizeof(uint8x16_t)*2, do_decode_neon<false, false> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(uint8x16_t)*2, do_decode_neon<true, false> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(uint8x16_t)*2, do_decode_neon<true, true> >;
 	_decode_isa = ISA_LEVEL_NEON;
 }
 #else
-void decoder_set_neon_funcs() {}
+void RapidYenc::decoder_set_neon_funcs() {}
 #endif