yencode 1.2.0 → 1.2.1

package/src/crc_riscv.cc

@@ -189,7 +189,7 @@ static uint32_t crc32_reduce_rv_zbc(uint64_t prod) {
 	return t;
 }
 #endif
-uint32_t crc32_multiply_rv_zbc(uint32_t a, uint32_t b) {
+static uint32_t crc32_multiply_rv_zbc(uint32_t a, uint32_t b) {
 #if __riscv_xlen == 64
 	uint64_t t = crc32_reduce_rv_zbc(rv_clmul(a, b));
 #else
@@ -209,7 +209,7 @@ uint32_t crc32_multiply_rv_zbc(uint32_t a, uint32_t b) {
 }
 
 #if defined(__GNUC__) || defined(_MSC_VER)
-uint32_t crc32_shift_rv_zbc(uint32_t crc1, uint32_t n) {
+static uint32_t crc32_shift_rv_zbc(uint32_t crc1, uint32_t n) {
 	// TODO: require Zbb for ctz
 	uint32_t result = crc1;
 #if __riscv_xlen == 64
@@ -221,15 +221,15 @@ uint32_t crc32_shift_rv_zbc(uint32_t crc1, uint32_t n) {
 #endif
 	if(!n) return result;
 	
-	uint32_t result2 = crc_power[ctz32(n)];
+	uint32_t result2 = RapidYenc::crc_power[ctz32(n)];
 	n &= n-1;
 	
 	while(n) {
-		result = crc32_multiply_rv_zbc(result, crc_power[ctz32(n)]);
+		result = crc32_multiply_rv_zbc(result, RapidYenc::crc_power[ctz32(n)]);
 		n &= n-1;
 		
 		if(n) {
-			result2 = crc32_multiply_rv_zbc(result2, crc_power[ctz32(n)]);
+			result2 = crc32_multiply_rv_zbc(result2, RapidYenc::crc_power[ctz32(n)]);
 			n &= n-1;
 		}
 	}
@@ -238,7 +238,7 @@ uint32_t crc32_shift_rv_zbc(uint32_t crc1, uint32_t n) {
 #endif
 
 
-void crc_riscv_set_funcs() {
+void RapidYenc::crc_riscv_set_funcs() {
 	_do_crc32_incremental = &do_crc32_incremental_rv_zbc;
 	_crc32_multiply = &crc32_multiply_rv_zbc;
 #if defined(__GNUC__) || defined(_MSC_VER)
@@ -247,5 +247,5 @@ void crc_riscv_set_funcs() {
 	_crc32_isa = ISA_FEATURE_ZBC;
 }
 #else
-void crc_riscv_set_funcs() {}
+void RapidYenc::crc_riscv_set_funcs() {}
 #endif

package/src/decoder.cc

@@ -3,29 +3,358 @@
 #include "decoder_common.h"
 #include "decoder.h"
 
-extern "C" {
+
+
+// TODO: add branch probabilities
+
+
+// state var: refers to the previous state - only used for incremental processing
+template<bool isRaw>
+static size_t do_decode_noend_scalar(const unsigned char* src, unsigned char* dest, size_t len, RapidYenc::YencDecoderState* state) {
+	using namespace RapidYenc;
+	
+	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;
+	
+	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>
+static RapidYenc::YencDecoderEnd do_decode_end_scalar(const unsigned char** src, unsigned char** dest, size_t len, RapidYenc::YencDecoderState* state) {
+	using namespace RapidYenc;
+	
+	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)
+			} else if(es[i] == '=') {
+				i++;
+				YDEC_CHECK_END(YDEC_STATE_CRLFEQ)
+				goto do_decode_endable_scalar_ceq;
+			} else
+				break;
+			// fall-through
+		case YDEC_STATE_CRLFDT:
+			if(isRaw && es[i] == '\r') {
+				i++;
+				YDEC_CHECK_END(YDEC_STATE_CRLFDTCR)
+			} 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;
+			// fall-through
+		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>
+RapidYenc::YencDecoderEnd RapidYenc::do_decode_scalar(const unsigned char** src, unsigned char** dest, size_t len, RapidYenc::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;
+}
+
+
+namespace RapidYenc {
 	YencDecoderEnd (*_do_decode)(const unsigned char**, unsigned char**, size_t, YencDecoderState*) = &do_decode_scalar<false, false>;
 	YencDecoderEnd (*_do_decode_raw)(const unsigned char**, unsigned char**, size_t, YencDecoderState*) = &do_decode_scalar<true, false>;
 	YencDecoderEnd (*_do_decode_end_raw)(const unsigned char**, unsigned char**, size_t, YencDecoderState*) = &do_decode_end_scalar<true>;
 	
 	int _decode_isa = ISA_GENERIC;
+	
+	template YencDecoderEnd do_decode_scalar<true, true>(const unsigned char**, unsigned char**, size_t, YencDecoderState*);
 }
 
-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 defined(PLATFORM_X86) && defined(YENC_BUILD_NATIVE) && YENC_BUILD_NATIVE!=0
 # if defined(__AVX2__) && !defined(YENC_DISABLE_AVX256)
 #  include "decoder_avx2_base.h"
 static inline void decoder_set_native_funcs() {
 	ALIGN_ALLOC(lookups, sizeof(*lookups), 16);
+	using namespace RapidYenc;
 	decoder_init_lut(lookups->compact);
 	_do_decode = &do_decode_simd<false, false, sizeof(__m256i)*2, do_decode_avx2<false, false, ISA_NATIVE> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m256i)*2, do_decode_avx2<true, false, ISA_NATIVE> >;
@@ -35,6 +364,7 @@ static inline void decoder_set_native_funcs() {
 # else
 #  include "decoder_sse_base.h"
 static inline void decoder_set_native_funcs() {
+	using namespace RapidYenc;
 	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_NATIVE> >;
@@ -47,7 +377,7 @@ static inline void decoder_set_native_funcs() {
 
 
 #if defined(PLATFORM_X86) || defined(PLATFORM_ARM)
-void decoder_init_lut(void* compactLUT) {
+void RapidYenc::decoder_init_lut(void* compactLUT) {
 	#ifdef YENC_DEC_USE_THINTABLE
 	const int tableSize = 8;
 	#else
@@ -70,7 +400,7 @@ void decoder_init_lut(void* compactLUT) {
 #endif
 
 
-void decoder_init() {
+void RapidYenc::decoder_init() {
 #ifdef PLATFORM_X86
 # if defined(YENC_BUILD_NATIVE) && YENC_BUILD_NATIVE!=0
 	decoder_set_native_funcs();

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,9 +1,9 @@
 #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() {
+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> >;
@@ -12,8 +12,7 @@ void decoder_set_avx_funcs() {
 	_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->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;
+	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

@@ -49,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);
@@ -429,8 +431,9 @@ 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)) {
-				maskEq = fix_eqMask<uint64_t>(maskEq & ~(uint64_t)escFirst);
+			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 = maskEq>>63;
 				// next, eliminate anything following a `=` from the special char mask; this eliminates cases of `=\r` so that they aren't removed
@@ -611,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