use core::arch::wasm32::{
i8x16_add, i8x16_eq, i8x16_gt, i8x16_shuffle, i8x16_splat, i8x16_swizzle, i16x8_shl,
i16x8_splat, i32x4_shl, i32x4_splat, u8x16_shr, u16x8_shr, u32x4_shr, v128, v128_and,
v128_any_true, v128_bitselect, v128_load, v128_or, v128_store, v128_xor,
};
use super::{HASH_B64_LEN, SALT_B64_LEN};
#[inline(always)]
fn translate_encode(vals: v128) -> v128 {
let biased = v128_xor(vals, i8x16_splat(-128));
let lt2 = i8x16_gt(i8x16_splat(-126), biased);
let lt28 = i8x16_gt(i8x16_splat(-100), biased);
let lt54 = i8x16_gt(i8x16_splat(-74), biased);
let off = v128_bitselect(
i8x16_splat(46),
v128_bitselect(
i8x16_splat(63),
v128_bitselect(i8x16_splat(69), i8x16_splat(-6), lt54),
lt28,
),
lt2,
);
i8x16_add(vals, off)
}
#[inline(always)]
fn encode_block(pairs: v128) -> v128 {
let lo = v128_or(
v128_or(
v128_and(u16x8_shr(pairs, 2), i16x8_splat(0x3f)),
i16x8_shl(v128_and(pairs, i16x8_splat(3)), 12),
),
v128_and(u16x8_shr(pairs, 4), i16x8_splat(0x0f00)),
);
let hi = v128_or(
v128_or(
v128_and(i16x8_shl(pairs, 2), i16x8_splat(0x3c)),
u16x8_shr(pairs, 14),
),
v128_and(pairs, i16x8_splat(0x3f00)),
);
let vals = i8x16_shuffle::<0, 1, 18, 19, 4, 5, 22, 23, 8, 9, 26, 27, 12, 13, 30, 31>(lo, hi);
translate_encode(vals)
}
#[inline(always)]
fn pairs_0_12(v: v128) -> v128 {
i8x16_shuffle::<0, 1, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11>(v, v)
}
#[inline(always)]
fn pairs_12_24(v: v128) -> v128 {
i8x16_shuffle::<4, 5, 5, 6, 7, 8, 8, 9, 10, 11, 11, 12, 13, 14, 14, 15>(v, v)
}
pub(crate) fn encode_16(bytes: &[u8; 16]) -> [u8; SALT_B64_LEN] {
let mut buf = [0u8; 24];
buf[..16].copy_from_slice(bytes);
let (v0, v1) = unsafe {
(
v128_load(buf.as_ptr().cast::<v128>()),
v128_load(buf.as_ptr().add(8).cast::<v128>()),
)
};
let c0 = encode_block(pairs_0_12(v0));
let c1 = encode_block(pairs_12_24(v1));
let mut scratch = [0u8; 32];
unsafe {
v128_store(scratch.as_mut_ptr().cast::<v128>(), c0);
v128_store(scratch.as_mut_ptr().add(16).cast::<v128>(), c1);
}
let mut out = [0u8; SALT_B64_LEN];
out.copy_from_slice(&scratch[..SALT_B64_LEN]);
out
}
pub(crate) fn encode_23(bytes: &[u8; 23]) -> [u8; HASH_B64_LEN] {
let mut buf = [0u8; 24];
buf[..23].copy_from_slice(bytes);
let (v0, v1) = unsafe {
(
v128_load(buf.as_ptr().cast::<v128>()),
v128_load(buf.as_ptr().add(8).cast::<v128>()),
)
};
let c0 = encode_block(pairs_0_12(v0));
let c1 = encode_block(pairs_12_24(v1));
let mut scratch = [0u8; 32];
unsafe {
v128_store(scratch.as_mut_ptr().cast::<v128>(), c0);
v128_store(scratch.as_mut_ptr().add(16).cast::<v128>(), c1);
}
let mut out = [0u8; HASH_B64_LEN];
out.copy_from_slice(&scratch[..HASH_B64_LEN]);
out
}
static LO_TAB: [u8; 16] = [
0x2A, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3C, 0x14, 0x14, 0x14, 0x15, 0x15,
];
static HI_TAB: [u8; 16] = [
0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
static OFF_TAB: [u8; 16] = [0, 0, 210, 6, 193, 193, 187, 187, 0, 0, 0, 0, 0, 0, 0, 0];
#[inline(always)]
fn decode_block(chars: v128) -> (v128, v128) {
let (lo_tab, hi_tab, off_tab) = unsafe {
(
v128_load(LO_TAB.as_ptr().cast::<v128>()),
v128_load(HI_TAB.as_ptr().cast::<v128>()),
v128_load(OFF_TAB.as_ptr().cast::<v128>()),
)
};
let lo = v128_and(chars, i8x16_splat(0x0f));
let hi = u8x16_shr(chars, 4);
let valid = v128_and(i8x16_swizzle(lo_tab, lo), i8x16_swizzle(hi_tab, hi));
let vals = i8x16_add(chars, i8x16_swizzle(off_tab, hi));
let bad = i8x16_eq(valid, i8x16_splat(0));
let b0 = v128_or(
v128_and(i32x4_shl(vals, 2), i32x4_splat(0xfc)),
v128_and(u32x4_shr(vals, 12), i32x4_splat(0x0f)),
);
let b1 = v128_or(
v128_and(i32x4_shl(vals, 4), i32x4_splat(0xf000)),
v128_and(u32x4_shr(vals, 10), i32x4_splat(0x3f00)),
);
let b2 = v128_or(
v128_and(i32x4_shl(vals, 6), i32x4_splat(0xc0_0000)),
v128_and(u32x4_shr(vals, 8), i32x4_splat(0x3f_0000)),
);
let packed = v128_or(v128_or(b0, b1), b2);
let compact =
i8x16_shuffle::<0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 16, 16, 16, 16>(packed, packed);
(compact, bad)
}
pub(crate) fn decode_16(s: &[u8]) -> Result<[u8; 16], ()> {
if s.len() != SALT_B64_LEN {
return Err(());
}
let mut buf = [0u8; 32];
buf[..SALT_B64_LEN].copy_from_slice(s);
buf[22] = b'.';
buf[23] = b'.';
let (v0, v1) = unsafe {
(
v128_load(buf.as_ptr().cast::<v128>()),
v128_load(buf.as_ptr().add(8).cast::<v128>()),
)
};
let (p0, bad0) = decode_block(v0);
let (p1, bad1) = decode_block(v1);
if v128_any_true(v128_or(bad0, bad1)) {
return Err(());
}
let mut scratch = [0u8; 32];
unsafe {
v128_store(scratch.as_mut_ptr().cast::<v128>(), p0);
v128_store(scratch.as_mut_ptr().add(6).cast::<v128>(), p1);
}
let mut out = [0u8; 16];
out.copy_from_slice(&scratch[..16]);
Ok(out)
}
pub(crate) fn decode_23(s: &[u8]) -> Result<[u8; 23], ()> {
if s.len() != HASH_B64_LEN {
return Err(());
}
let mut buf = [0u8; 32];
buf[..HASH_B64_LEN].copy_from_slice(s);
buf[31] = b'.';
let (v0, v1) = unsafe {
(
v128_load(buf.as_ptr().cast::<v128>()),
v128_load(buf.as_ptr().add(16).cast::<v128>()),
)
};
let (p0, bad0) = decode_block(v0);
let (p1, bad1) = decode_block(v1);
if v128_any_true(v128_or(bad0, bad1)) {
return Err(());
}
let mut scratch = [0u8; 32];
unsafe {
v128_store(scratch.as_mut_ptr().cast::<v128>(), p0);
v128_store(scratch.as_mut_ptr().add(12).cast::<v128>(), p1);
}
let mut out = [0u8; 23];
out.copy_from_slice(&scratch[..23]);
Ok(out)
}