yencode 1.1.5 → 1.2.0

package/src/decoder_rvv.cc

@@ -0,0 +1,274 @@
+#include "common.h"
+#ifdef __riscv_vector
+#include "decoder_common.h"
+
+
+#ifdef __riscv_v_intrinsic
+# define RV_vmerge_vxm_u8m2 RV(vmerge_vxm_u8m2)
+# define RV_vmerge_vxm_u16m2 RV(vmerge_vxm_u16m2)
+#else
+# define RV_vmerge_vxm_u8m2(v, x, m, vl) RV(vmerge_vxm_u8m2)(m, v, x, vl)
+# define RV_vmerge_vxm_u16m2(v, x, m, vl) RV(vmerge_vxm_u16m2)(m, v, x, vl)
+#endif
+
+#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 12000
+# define RV_VEC_CAST(masksz, vecsz, vec) RV(vreinterpret_v_b##masksz##_u##vecsz##m1)(vec)
+#else
+# define RV_VEC_CAST(masksz, vecsz, vec) *(vuint##vecsz##m1_t*)(&(vec))
+#endif
+
+
+template<int shift>
+static inline vbool4_t mask_lshift(vbool4_t m, unsigned shiftIn, size_t vl) {
+	vuint8m1_t mv = RV_VEC_CAST(4, 8, m);
+	vuint8m1_t mvl = RV(vsll_vx_u8m1)(mv, shift, vl/8);
+	vuint8m1_t mvr = RV(vsrl_vx_u8m1)(mv, 8-shift, vl/8);
+	mvr = RV(vslide1up_vx_u8m1)(mvr, shiftIn, vl/8);
+	
+	return RV(vmor_mm_b4)(
+		RV_MASK_CAST(4, 8, mvl), RV_MASK_CAST(4, 8, mvr), vl
+	);
+}
+
+static inline vuint8m2_t set_first_vu8(vuint8m2_t src, uint8_t item, size_t vl) {
+#ifdef __riscv_v_intrinsic
+	return RV(vmv_s_x_u8m2_tu)(src, item, vl);
+#else
+	vuint8m1_t m = RV(vslide1up_vx_u8m1)(RV(vmv_v_x_u8m1)(0, ~0), 1, ~0);
+	return RV_vmerge_vxm_u8m2(src, item, RV_MASK_CAST(4, 8, m), vl);
+#endif
+}
+static inline vuint16m2_t set_first_vu16(vuint16m2_t src, uint16_t item, size_t vl) {
+#ifdef __riscv_v_intrinsic
+	return RV(vmv_s_x_u16m2_tu)(src, item, vl);
+#else
+	vuint16m1_t m = RV(vslide1up_vx_u16m1)(RV(vmv_v_x_u16m1)(0, ~0), 1, ~0);
+	return RV_vmerge_vxm_u16m2(src, item, RV_MASK_CAST(8, 16, m), vl);
+#endif
+}
+
+
+
+template<bool isRaw, bool searchEnd>
+HEDLEY_ALWAYS_INLINE void do_decode_rvv(const uint8_t* src, long& len, unsigned char*& outp, unsigned char& escFirst, uint16_t& nextMask) {
+	HEDLEY_ASSUME(escFirst == 0 || escFirst == 1);
+	HEDLEY_ASSUME(nextMask == 0 || nextMask == 1 || nextMask == 2);
+	
+	size_t vl2 = RV(vsetvlmax_e8m2)();
+	
+	vuint8m2_t yencOffset = RV(vmv_v_x_u8m2)(42, vl2);
+	if(escFirst) yencOffset = set_first_vu8(yencOffset, 42+64, vl2);
+	vuint8m2_t lfCompare = RV(vmv_v_x_u8m2)('\n', vl2);
+	if(nextMask && isRaw) {
+		lfCompare = RV(vreinterpret_v_u16m2_u8m2)(
+			set_first_vu16(RV(vreinterpret_v_u8m2_u16m2)(lfCompare), nextMask == 1 ? 0x0a2e /*".\n"*/ : 0x2e0a /*"\n."*/, vl2/2)
+		);
+	}
+	
+	// mask where only the highest bit is set
+	vbool4_t lastBit = RV(vmseq_vx_u8m2_b4)(
+		RV(vslide1down_vx_u8m2)(RV(vmv_v_x_u8m2)(0, vl2), 1, vl2),
+		1, vl2
+	);
+	
+	decoder_set_nextMask<isRaw>(src, len, nextMask);
+	
+	// TODO: consider exploiting partial vector capability
+	long inpos;
+	for(inpos = -len; inpos; inpos += vl2) {
+		vuint8m2_t data = RV(vle8_v_u8m2)(src + inpos, vl2);
+		
+		// search for special chars
+		vbool4_t cmpEq = RV(vmseq_vx_u8m2_b4)(data, '=', vl2);
+		vbool4_t cmpCr = RV(vmseq_vx_u8m2_b4)(data, '\r', vl2);
+		// note: cmp is always negated (unlike cmpEq/Cr)
+		vbool4_t cmp = RV(vmnor_mm_b4)(
+			RV(vmor_mm_b4)(cmpEq, cmpCr, vl2),
+			isRaw ? RV(vmseq_vv_u8m2_b4)(data, lfCompare, vl2) : RV(vmseq_vx_u8m2_b4)(data, '\n', vl2),
+			vl2
+		);
+		
+		size_t numOutputChars = RV(vcpop_m_b4)(cmp, vl2);
+		
+		if(numOutputChars != vl2) {
+			// dot-unstuffing + end detection
+			if((isRaw || searchEnd) && RV(vcpop_m_b4)(RV(vmxnor_mm_b4)(cmp, cmpEq, vl2), vl2)) {
+				uint32_t nextWord;
+				if(!searchEnd) {
+					memcpy(&nextWord, src + inpos + vl2, 2);
+				} else {
+					memcpy(&nextWord, src + inpos + vl2, 4);
+				}
+				vuint8m2_t nextData2 = RV(vreinterpret_v_u16m2_u8m2)(RV(vslide1down_vx_u16m2)(RV(vreinterpret_v_u8m2_u16m2)(data), nextWord, vl2/2));
+				
+				vbool4_t match2Cr_Dot, match3EqY;
+				vuint8m2_t nextData3;
+				if(isRaw) {
+					match2Cr_Dot = RV(vmand_mm_b4)(cmpCr, RV(vmseq_vx_u8m2_b4)(nextData2, '.', vl2), vl2);
+				}
+				
+				if(searchEnd) {
+					nextData3 = RV(vslide1down_vx_u8m2)(nextData2, nextWord>>16, vl2);
+					match3EqY = RV(vmand_mm_b4)(
+						RV(vmseq_vx_u8m2_b4)(nextData2, '=', vl2),
+						RV(vmseq_vx_u8m2_b4)(nextData3, 'y', vl2),
+						vl2
+					);
+				}
+				
+				// find patterns of \r_.
+				if(isRaw && LIKELIHOOD(0.001, RV(vcpop_m_b4)(match2Cr_Dot, vl2) > 0)) {
+					// find \r\n.
+					vuint8m2_t nextData1 = RV(vslide1down_vx_u8m2)(data, nextWord, vl2);
+					vbool4_t match1Lf = RV(vmseq_vx_u8m2_b4)(nextData1, '\n', vl2);
+					vbool4_t match2NlDot = RV(vmand_mm_b4)(match2Cr_Dot, match1Lf, vl2);
+					
+					if(searchEnd) {
+						vbool4_t match1Nl = RV(vmand_mm_b4)(cmpCr, match1Lf, vl2);
+						
+						vuint8m2_t nextData4 = RV(vreinterpret_v_u32m2_u8m2)(RV(vslide1down_vx_u32m2)(RV(vreinterpret_v_u8m2_u32m2)(data), nextWord, vl2/4));
+						
+						// match instances of \r\n.\r\n and \r\n.=y
+						vbool4_t match4Nl = RV(vmand_mm_b4)(
+							RV(vmseq_vx_u8m2_b4)(nextData3, '\r', vl2),
+							RV(vmseq_vx_u8m2_b4)(nextData4, '\n', vl2),
+							vl2
+						);
+						vbool4_t match4EqY = RV(vmand_mm_b4)(
+							RV(vmseq_vx_u8m2_b4)(nextData3, '=', vl2),
+							RV(vmseq_vx_u8m2_b4)(nextData4, 'y', vl2),
+							vl2
+						);
+						
+						// merge \r\n and =y matches
+						vbool4_t match4End = RV(vmor_mm_b4)(match4Nl, match4EqY, vl2);
+						// merge with \r\n.
+						match4End = RV(vmand_mm_b4)(match4End, match2NlDot, vl2);
+						// merge \r\n=y
+						vbool4_t match3End = RV(vmand_mm_b4)(match1Nl, match3EqY, vl2);
+						
+						vbool4_t matchEnd = RV(vmor_mm_b4)(match4End, match3End, vl2);
+						
+						// combine match sequences
+						if(LIKELIHOOD(0.001, RV(vcpop_m_b4)(matchEnd, vl2) > 0)) {
+							// terminator found
+							len += inpos;
+							nextMask = decoder_set_nextMask<isRaw>(src+inpos, ~RV(vmv_x_s_u8m1_u8)(RV_VEC_CAST(4, 8, cmp)));
+							break;
+						}
+					}
+					
+					// shift match2NlDot by 2
+					cmp = RV(vmandn_mm_b4)(cmp, mask_lshift<2>(match2NlDot, 0, vl2), vl2);
+					numOutputChars = RV(vcpop_m_b4)(cmp, vl2);
+					
+					vuint8mf4_t nextNlDot = RV(vslidedown_vx_u8mf4)(
+#ifndef __riscv_v_intrinsic
+						RV(vmv_v_x_u8mf4)(0, vl2/8),
+#endif
+						RV_VEC_U8MF4_CAST(match2NlDot), vl2/8-1, vl2/8
+					);
+					nextNlDot = RV(vsrl_vx_u8mf4)(nextNlDot, 6, vl2/8);
+					vuint8m1_t nextNlDotVec = RV(vlmul_ext_v_u8mf4_u8m1)(nextNlDot);
+					lfCompare = RV_vmerge_vxm_u8m2(RV(vmv_v_x_u8m2)('\n', vl2), '.', RV_MASK_CAST(4, 8, nextNlDotVec), vl2);
+				} else if(searchEnd) {
+					if(LIKELIHOOD(0.001, RV(vcpop_m_b4)(match3EqY, vl2) != 0)) {
+						vuint8m2_t nextData1 = RV(vslide1down_vx_u8m2)(data, nextWord, vl2);
+						vbool4_t match1Lf = RV(vmseq_vx_u8m2_b4)(nextData1, '\n', vl2);
+						vbool4_t matchEnd = RV(vmand_mm_b4)(RV(vmand_mm_b4)(match3EqY, cmpCr, vl2), match1Lf, vl2);
+						if(LIKELIHOOD(0.001, RV(vcpop_m_b4)(matchEnd, vl2) > 0)) {
+							len += inpos;
+							nextMask = decoder_set_nextMask<isRaw>(src+inpos, ~RV(vmv_x_s_u8m1_u8)(RV_VEC_CAST(4, 8, cmp)));
+							break;
+						}
+					}
+					if(isRaw)
+						lfCompare = RV(vmv_v_x_u8m2)('\n', vl2);
+				} else if(isRaw) // no \r_. found
+					lfCompare = RV(vmv_v_x_u8m2)('\n', vl2);
+			}
+			
+			// the second character in an escape sequence
+			vbool4_t cmpEqShift1 = mask_lshift<1>(cmpEq, escFirst, vl2);
+			
+			// 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, RV(vcpop_m_b4)(RV(vmandn_mm_b4)(cmpEqShift1, cmp, vl2), vl2) != 0)) {
+				// note: we assume that uintptr_t corresponds with __riscv_xlen
+				#if __riscv_xlen == 64
+				vuint64m1_t cmpEqW = RV_VEC_CAST(4, 64, cmpEq);
+				#else
+				vuint32m1_t cmpEqW = RV_VEC_CAST(4, 32, cmpEq);
+				#endif
+				size_t nextShiftDown = (vl2 > sizeof(uintptr_t)*8 ? sizeof(uintptr_t)*8 : vl2) - 1;
+				size_t wvl = (vl2 + sizeof(uintptr_t)*8 -1) / (sizeof(uintptr_t)*8);
+				for(size_t w=0; w<vl2; w+=sizeof(uintptr_t)*8) {
+					// extract bottom word
+					#if __riscv_xlen == 64
+					uintptr_t maskW = RV(vmv_x_s_u64m1_u64)(cmpEqW);
+					#else
+					uintptr_t maskW = RV(vmv_x_s_u32m1_u32)(cmpEqW);
+					#endif
+					
+					// fix it
+					maskW = fix_eqMask<uintptr_t>(maskW & ~(uintptr_t)escFirst);
+					uint8_t nextEscFirst = (maskW >> nextShiftDown) & 1;
+					
+					// shift it up (will be used for cmpEqShift1)
+					maskW = (maskW<<1) | escFirst; // TODO: should this be done using mask_lshift<1> instead?
+					escFirst = nextEscFirst;
+					
+					// slide the new value in from the top
+					#if __riscv_xlen == 64
+					cmpEqW = RV(vslide1down_vx_u64m1)(cmpEqW, maskW, wvl);
+					#else
+					cmpEqW = RV(vslide1down_vx_u32m1)(cmpEqW, maskW, wvl);
+					#endif
+				}
+				#if __riscv_xlen == 64
+				cmpEqShift1 = RV_MASK_CAST(4, 64, cmpEqW);
+				#else
+				cmpEqShift1 = RV_MASK_CAST(4, 32, cmpEqW);
+				#endif
+				cmp = RV(vmor_mm_b4)(cmpEqShift1, cmp, vl2); // ~(~cmp & ~cmpEqShift1)
+				numOutputChars = RV(vcpop_m_b4)(cmp, vl2);
+			} else {
+				// no invalid = sequences found - don't need to fix up cmpEq
+				escFirst = RV(vcpop_m_b4)(RV(vmand_mm_b4)(cmpEq, lastBit, vl2), vl2);
+			}
+			data = RV(vsub_vv_u8m2)(data, RV_vmerge_vxm_u8m2(yencOffset, 64+42, cmpEqShift1, vl2), vl2);
+			yencOffset = set_first_vu8(yencOffset, 42 | (escFirst<<6), vl2);
+			
+			// all that's left is to remove unwanted chars
+#ifdef __riscv_v_intrinsic
+			data = RV(vcompress_vm_u8m2)(data, cmp, vl2);
+#else
+			data = RV(vcompress_vm_u8m2)(cmp, data, data, vl2);
+#endif
+			RV(vse8_v_u8m2)(outp, data, vl2);
+		} else {
+			data = RV(vsub_vv_u8m2)(data, yencOffset, vl2);
+			RV(vse8_v_u8m2)(outp, data, vl2);
+			// TODO: should these be done at LMUL=1? or, it might not be worth this strategy (e.g. do an additional OR instead), considering the cost of LMUL=2
+			yencOffset = RV(vmv_v_x_u8m2)(42, vl2);
+			if(isRaw) lfCompare = RV(vmv_v_x_u8m2)('\n', vl2);
+			escFirst = 0;
+		}
+		outp += numOutputChars;
+	}
+}
+
+size_t decoder_rvv_width() {
+	return RV(vsetvlmax_e8m2)();
+}
+
+void decoder_set_rvv_funcs() {
+	_do_decode = &do_decode_simd<false, false, decoder_rvv_width, do_decode_rvv<false, false> >;
+	_do_decode_raw = &do_decode_simd<true, false, decoder_rvv_width, do_decode_rvv<true, false> >;
+	_do_decode_end_raw = &do_decode_simd<true, true, decoder_rvv_width, do_decode_rvv<true, true> >;
+	_decode_isa = ISA_LEVEL_RVV;
+}
+#else
+void decoder_set_rvv_funcs() {}
+#endif

package/src/decoder_sse2.cc

@@ -4,9 +4,30 @@
 #include "decoder_common.h"
 #include "decoder_sse_base.h"
 
+void decoder_sse_init(SSELookups* HEDLEY_RESTRICT& lookups) {
+	ALIGN_ALLOC(lookups, sizeof(SSELookups), 16);
+	for(int i=0; i<256; i++) {
+		lookups->BitsSetTable256inv[i] = 8 - (
+			(i & 1) + ((i>>1) & 1) + ((i>>2) & 1) + ((i>>3) & 1) + ((i>>4) & 1) + ((i>>5) & 1) + ((i>>6) & 1) + ((i>>7) & 1)
+		);
+		
+		#define _X(n, k) ((((n) & (1<<k)) ? 192ULL : 0ULL) << (k*8))
+		lookups->eqAdd[i] = _X(i, 0) | _X(i, 1) | _X(i, 2) | _X(i, 3) | _X(i, 4) | _X(i, 5) | _X(i, 6) | _X(i, 7);
+		#undef _X
+	}
+	for(int i=0; i<32; i++) {
+		for(int j=0; j<16; j++) {
+			if(i >= 16) // only used for LZCNT
+				lookups->unshufMask[i*16 + j] = ((31-i)>j ? -1 : 0);
+			else // only used for BSR
+				lookups->unshufMask[i*16 + j] = (i>j ? -1 : 0);
+		}
+	}
+}
+
 void decoder_set_sse2_funcs() {
-	decoder_sse_init();
-	decoder_init_lut(lookups->eqFix, lookups->compact);
+	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_SSE2> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_LEVEL_SSE2> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_LEVEL_SSE2> >;

package/src/decoder_sse_base.h

@@ -26,13 +26,13 @@
 #endif
 
 #pragma pack(16)
-static struct {
+typedef struct {
 	unsigned char BitsSetTable256inv[256];
 	/*align16*/ struct { char bytes[16]; } compact[32768];
-	uint8_t eqFix[256];
 	/*align8*/ uint64_t eqAdd[256];
 	/*align16*/ int8_t unshufMask[32*16];
-} * HEDLEY_RESTRICT lookups;
+} SSELookups;
+static SSELookups* HEDLEY_RESTRICT lookups;
 #pragma pack()
 
 
@@ -45,27 +45,7 @@ static HEDLEY_ALWAYS_INLINE __m128i force_align_read_128(const void* p) {
 #endif
 }
 
-
-static void decoder_sse_init() {
-	ALIGN_ALLOC(lookups, sizeof(*lookups), 16);
-	for(int i=0; i<256; i++) {
-		lookups->BitsSetTable256inv[i] = 8 - (
-			(i & 1) + ((i>>1) & 1) + ((i>>2) & 1) + ((i>>3) & 1) + ((i>>4) & 1) + ((i>>5) & 1) + ((i>>6) & 1) + ((i>>7) & 1)
-		);
-		
-		#define _X(n, k) ((((n) & (1<<k)) ? 192ULL : 0ULL) << (k*8))
-		lookups->eqAdd[i] = _X(i, 0) | _X(i, 1) | _X(i, 2) | _X(i, 3) | _X(i, 4) | _X(i, 5) | _X(i, 6) | _X(i, 7);
-		#undef _X
-	}
-	for(int i=0; i<32; i++) {
-		for(int j=0; j<16; j++) {
-			if(i >= 16) // only used for LZCNT
-				lookups->unshufMask[i*16 + j] = ((31-i)>j ? -1 : 0);
-			else // only used for BSR
-				lookups->unshufMask[i*16 + j] = (i>j ? -1 : 0);
-		}
-	}
-}
+void decoder_sse_init(SSELookups* HEDLEY_RESTRICT& lookups); // defined in decoder_sse2.cc
 
 
 // for LZCNT/BSR
@@ -521,17 +501,9 @@ HEDLEY_ALWAYS_INLINE void do_decode_sse(const uint8_t* src, long& len, unsigned
 				dataB = _mm_add_epi8(oDataB, _mm_set1_epi8(-42));
 			
 			if(LIKELIHOOD(0.0001, (mask & ((maskEq << 1) + escFirst)) != 0)) {
-				// resolve invalid sequences of = to deal with cases like '===='
-				unsigned tmp = lookups->eqFix[(maskEq&0xff) & ~escFirst];
-				uint32_t maskEq2 = tmp;
-				for(int j=8; j<32; j+=8) {
-					tmp = lookups->eqFix[((maskEq>>j)&0xff) & ~(tmp>>7)];
-					maskEq2 |= tmp<<j;
-				}
-				maskEq = maskEq2;
-				
+				maskEq = fix_eqMask<uint32_t>(maskEq & ~escFirst);
 				mask &= ~escFirst;
-				escFirst = (maskEq >> 31);
+				escFirst = maskEq >> 31;
 				// 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;

package/src/decoder_ssse3.cc

@@ -4,8 +4,8 @@
 #include "decoder_common.h"
 #include "decoder_sse_base.h"
 void decoder_set_ssse3_funcs() {
-	decoder_sse_init();
-	decoder_init_lut(lookups->eqFix, lookups->compact);
+	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> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_LEVEL_SSSE3> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_LEVEL_SSSE3> >;

package/src/decoder_vbmi2.cc

@@ -12,9 +12,6 @@ const bool decoder_has_avx10 = false;
 # ifndef YENC_DISABLE_AVX256
 #  include "decoder_avx2_base.h"
 void decoder_set_vbmi2_funcs() {
-	ALIGN_ALLOC(lookups, sizeof(*lookups), 16);
-	// TODO: consider removing compact LUT
-	decoder_init_lut(lookups->eqFix, lookups->compact);
 	_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> >;
@@ -23,8 +20,6 @@ void decoder_set_vbmi2_funcs() {
 # else
 #  include "decoder_sse_base.h"
 void decoder_set_vbmi2_funcs() {
-	decoder_sse_init();
-	decoder_init_lut(lookups->eqFix, lookups->compact);
 	_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> >;

package/src/encoder.cc

@@ -2,6 +2,31 @@
 #include "encoder_common.h"
 #include "encoder.h"
 
+
+// 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 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
+#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 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

package/src/encoder_common.h

@@ -2,26 +2,8 @@
 #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
+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);

package/src/encoder_rvv.cc

@@ -4,13 +4,6 @@
 #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
@@ -112,7 +105,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 +115,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 +123,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 +134,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

package/src/platform.cc

@@ -138,14 +138,14 @@ int cpu_supports_isa() {
 						_cpuidX(cpuInfo2, 7, 1);
 						if(cpuInfo2[3] & 0x80000) {
 							_cpuidX(cpuInfo2, 0x24, 0);
-							if((cpuInfo2[2] & 0xff) >= 1 && ( // minimum AVX10.1
+							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;
+								if(((xcr & 0xE0) == 0xE0) && (cpuInfo2[1] & 0x40000)) ret |= ISA_FEATURE_EVEX512;
 								return ret | ISA_LEVEL_VBMI2;
 							}
 						}

package/src/yencode.cc

@@ -383,7 +383,7 @@ FUNC(CRC32Combine) {
 	uint32_t crc1 = read_crc32(args[0]), crc2 = read_crc32(args[1]);
 	size_t len = (size_t)ARG_TO_INT(args[2]);
 	
-	crc1 = do_crc32_combine(crc1, crc2, len);
+	crc1 = crc32_combine(crc1, crc2, len);
 	RETURN_VAL(pack_crc32(ISOLATE crc1));
 }
 
@@ -399,11 +399,51 @@ FUNC(CRC32Zeroes) {
 			RETURN_ERROR("Second argument must be a 4 byte buffer");
 		crc1 = read_crc32(args[1]);
 	}
-	size_t len = (size_t)ARG_TO_INT(args[0]);
-	crc1 = do_crc32_zeros(crc1, len);
+	int len = ARG_TO_INT(args[0]);
+	if(len < 0)
+		crc1 = crc32_unzero(crc1, -len);
+	else
+		crc1 = crc32_zeros(crc1, len);
 	RETURN_VAL(pack_crc32(ISOLATE crc1));
 }
 
+FUNC(CRC32Multiply) {
+	FUNC_START;
+	
+	if (args.Length() < 2)
+		RETURN_ERROR("At least 2 arguments required");
+	
+	if (!node::Buffer::HasInstance(args[0]) || node::Buffer::Length(args[0]) != 4
+	|| !node::Buffer::HasInstance(args[1]) || node::Buffer::Length(args[1]) != 4)
+		RETURN_ERROR("You must supply a 4 byte Buffer for the first two arguments");
+	
+	uint32_t crc1 = read_crc32(args[0]);
+	uint32_t crc2 = read_crc32(args[1]);
+	crc1 = crc32_multiply(crc1, crc2);
+	RETURN_VAL(pack_crc32(ISOLATE crc1));
+}
+
+FUNC(CRC32Shift) {
+	FUNC_START;
+	
+	if (args.Length() < 1)
+		RETURN_ERROR("At least 1 argument required");
+	
+	uint32_t crc1 = 0x80000000;
+	if (args.Length() >= 2) {
+		if (!node::Buffer::HasInstance(args[1]) || node::Buffer::Length(args[1]) != 4)
+			RETURN_ERROR("Second argument must be a 4 byte buffer");
+		crc1 = read_crc32(args[1]);
+	}
+	int n = ARG_TO_INT(args[0]);
+	if(n < 0)
+		crc1 = crc32_shift(crc1, ~crc32_powmod(-n));
+	else
+		crc1 = crc32_shift(crc1, crc32_powmod(n));
+	RETURN_VAL(pack_crc32(ISOLATE crc1));
+}
+
+
 static void init_all() {
 	encoder_init();
 	decoder_init();
@@ -436,6 +476,8 @@ void yencode_init(
 	NODE_SET_METHOD(exports, "crc32", CRC32);
 	NODE_SET_METHOD(exports, "crc32_combine", CRC32Combine);
 	NODE_SET_METHOD(exports, "crc32_zeroes", CRC32Zeroes);
+	NODE_SET_METHOD(exports, "crc32_multiply", CRC32Multiply);
+	NODE_SET_METHOD(exports, "crc32_shift", CRC32Shift);
 	
 #if NODE_VERSION_AT_LEAST(10, 7, 0)
 	uv_once(&init_once, init_all);

package/test/testcrc.js

@@ -14,7 +14,7 @@ var ycrc32 = function(s) {
 };
 var doTest = function(msg, f, test, expected) {
 	if(!Array.isArray(test)) test = [test];
-	test[0] = Buffer(test[0]);
+	if(!Buffer.isBuffer(test[0])) test[0] = Buffer(test[0]);
 	if(!expected && test.length == 1 && f == 'crc32') expected = crc32(test[0]).toString('hex');
 	else if(Buffer.isBuffer(expected)) expected = expected.toString('hex');
 	assert.equal(y[f].apply(null, test).toString('hex'), expected, msg);
@@ -45,6 +45,22 @@ assert.equal(y.crc32_zeroes(1, ycrc32('')).toString('hex'), 'd202ef8d', 'Zeroes-
 assert.equal(y.crc32_zeroes(0, ycrc32('z')).toString('hex'), crc32('z').toString('hex'), 'Zeroes Empty Join');
 assert.equal(y.crc32_zeroes(4, ycrc32('z')).toString('hex'), crc32('z\u0000\u0000\u0000\u0000').toString('hex'), 'Zeroes (4) Join');
 
+assert.equal(y.crc32_zeroes(4, y.crc32_zeroes(-4)).toString('hex'), '00000000', 'Zeroes (-4+4)');
+assert.equal(y.crc32_zeroes(-4, y.crc32_zeroes(4)).toString('hex'), '00000000', 'Zeroes (4-4)');
+assert.equal(y.crc32_zeroes(6, y.crc32_zeroes(-2, ycrc32('z'))).toString('hex'), crc32('z\u0000\u0000\u0000\u0000').toString('hex'), 'Zeroes (-2+6) Join');
+
+
+assert.equal(y.crc32_multiply(Buffer([1,2,3,4]), ycrc32('')).toString('hex'), '00000000', 'Multiply by 0');
+assert.equal(y.crc32_multiply(Buffer([0x80,0,0,0]), Buffer([0x80,0,0,0])).toString('hex'), '80000000', 'Multiply by 1');
+assert.equal(y.crc32_multiply(Buffer([1,2,3,4]), Buffer([5,6,7,8])).toString('hex'), '81e243a3', 'Multiply random');
+
+assert.equal(y.crc32_shift(0).toString('hex'), '80000000', '2^0');
+assert.equal(y.crc32_shift(1).toString('hex'), '40000000', '2^1');
+assert.equal(y.crc32_shift(2).toString('hex'), '20000000', '2^2');
+assert.equal(y.crc32_shift(-1).toString('hex'), 'db710641', '2^-1');
+assert.equal(y.crc32_shift(-1, y.crc32_shift(1)).toString('hex'), '80000000', '2^(1-1)');
+assert.equal(y.crc32_shift(4, y.crc32_shift(-2)).toString('hex'), '20000000', '2^(-2+4)');
+
 
 doTest('Random', 'crc32', 'fj[-oqijnw34-59n26 4345j8yn89032q78t9ab9gabh023quhoiBO Z GEB780a sdasdq2345673-98hq2-9348h-na9we8zdfgh-n9  8qwhn-098');
 doTest('Random Continue', 'crc32', ['KZSHZ5EDOVAmDdakZZOrGSUGGKSpCJoWH7M0MHy6ohnSzvHY4DjpxXmyfWYJQoJ7tKdNhGcuRVUzrgXM', ycrc32('BdenbmoBgiB10ZkeUBjrsZV3dg2Da2fhHqU9TMdi69AHhLRck3Nk60YuFBXh6lvtefBpjdTxbeEmsaEm')], crc32('BdenbmoBgiB10ZkeUBjrsZV3dg2Da2fhHqU9TMdi69AHhLRck3Nk60YuFBXh6lvtefBpjdTxbeEmsaEmKZSHZ5EDOVAmDdakZZOrGSUGGKSpCJoWH7M0MHy6ohnSzvHY4DjpxXmyfWYJQoJ7tKdNhGcuRVUzrgXM'));