use core::arch::aarch64::*;
use super::{ALPHABET, HASH_B64_LEN, SALT_B64_LEN};
static IDX_A: [u8; 16] = [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 9, 9, 10, 11];
static IDX_B: [u8; 16] = [0, 1, 2, 0, 0, 4, 5, 0, 0, 7, 8, 0, 0, 10, 11, 0];
static IDX_A2_16: [u8; 16] = [12, 12, 13, 14, 15, 15, 16, 17, 18, 18, 19, 20, 21, 21, 22, 23];
static IDX_B2_16: [u8; 16] = [0, 13, 14, 0, 0, 16, 17, 0, 0, 19, 20, 0, 0, 22, 23, 0];
static IDX_A2_23: [u8; 16] = [12, 12, 13, 14, 15, 15, 17, 18, 19, 19, 20, 21, 22, 22, 23, 24];
static IDX_B2_23: [u8; 16] = [0, 13, 14, 0, 0, 17, 18, 0, 0, 20, 21, 0, 0, 23, 24, 0];
static SHIFT_A: [i8; 16] = [-2, 4, 2, 0, -2, 4, 2, 0, -2, 4, 2, 0, -2, 4, 2, 0];
static SHIFT_B: [i8; 16] = [0, -4, -6, 0, 0, -4, -6, 0, 0, -4, -6, 0, 0, -4, -6, 0];
static MASK_A: [u8; 16] = [0x3f, 0x30, 0x3c, 0x3f, 0x3f, 0x30, 0x3c, 0x3f, 0x3f, 0x30, 0x3c, 0x3f, 0x3f, 0x30, 0x3c, 0x3f];
static MASK_B: [u8; 16] = [0x00, 0x0f, 0x03, 0x00, 0x00, 0x0f, 0x03, 0x00, 0x00, 0x0f, 0x03, 0x00, 0x00, 0x0f, 0x03, 0x00];
static HI_TAB: [u8; 16] = [0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0, 0, 0, 0, 0, 0, 0, 0];
static LO_TAB: [u8; 16] = [0x2A, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3C, 0x14, 0x14, 0x14, 0x15, 0x15];
static OFF_TAB: [u8; 16] = [0, 0, 210, 6, 193, 193, 187, 187, 0, 0, 0, 0, 0, 0, 0, 0];
static PK_A: [u8; 16] = [0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 0, 0, 0, 0];
static PK_B: [u8; 16] = [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 0, 0, 0, 0];
static PK_SA: [i8; 16] = [2, 4, 6, 2, 4, 6, 2, 4, 6, 2, 4, 6, 0, 0, 0, 0];
static PK_SB: [i8; 16] = [-4, -2, 0, -4, -2, 0, -4, -2, 0, -4, -2, 0, 0, 0, 0, 0];
fn encode_core(head: uint8x16_t, tail: uint8x16_t, a2: &[u8; 16], b2: &[u8; 16]) -> (uint8x16_t, uint8x16_t) {
unsafe {
let tab = uint8x16x2_t(head, tail);
let lut = uint8x16x4_t(
vld1q_u8(ALPHABET.as_ptr()),
vld1q_u8(ALPHABET.as_ptr().add(16)),
vld1q_u8(ALPHABET.as_ptr().add(32)),
vld1q_u8(ALPHABET.as_ptr().add(48)),
);
let sa = vld1q_s8(SHIFT_A.as_ptr());
let sb = vld1q_s8(SHIFT_B.as_ptr());
let ma = vld1q_u8(MASK_A.as_ptr());
let mb = vld1q_u8(MASK_B.as_ptr());
let enc = |ia: uint8x16_t, ib: uint8x16_t| {
let a = vqtbl2q_u8(tab, ia);
let b = vqtbl2q_u8(tab, ib);
let fields = vorrq_u8(vandq_u8(vshlq_u8(a, sa), ma), vandq_u8(vshlq_u8(b, sb), mb));
vqtbl4q_u8(lut, fields)
};
(
enc(vld1q_u8(IDX_A.as_ptr()), vld1q_u8(IDX_B.as_ptr())),
enc(vld1q_u8(a2.as_ptr()), vld1q_u8(b2.as_ptr())),
)
}
}
pub(crate) fn encode_16(bytes: &[u8; 16]) -> [u8; SALT_B64_LEN] {
let mut out = [0u8; SALT_B64_LEN];
unsafe {
let head = vld1q_u8(bytes.as_ptr());
let (c0, c1) = encode_core(head, vdupq_n_u8(0), &IDX_A2_16, &IDX_B2_16);
vst1q_u8(out.as_mut_ptr(), c0);
vst1q_u8(out.as_mut_ptr().add(6), vextq_u8::<6>(c0, c1));
}
out
}
pub(crate) fn encode_23(bytes: &[u8; 23]) -> [u8; HASH_B64_LEN] {
let mut out = [0u8; HASH_B64_LEN];
unsafe {
let head = vld1q_u8(bytes.as_ptr());
let tail = vcombine_u8(vld1_u8(bytes.as_ptr().add(15)), vdup_n_u8(0));
let (c0, c1) = encode_core(head, tail, &IDX_A2_23, &IDX_B2_23);
vst1q_u8(out.as_mut_ptr(), c0);
vst1q_u8(out.as_mut_ptr().add(15), vextq_u8::<15>(c0, c1));
}
out
}
fn translate(c: uint8x16_t) -> (uint8x16_t, uint8x16_t) {
unsafe {
let lo = vandq_u8(c, vdupq_n_u8(0x0F));
let hi = vshrq_n_u8::<4>(c);
let mlo = vqtbl1q_u8(vld1q_u8(LO_TAB.as_ptr()), lo);
let mhi = vqtbl1q_u8(vld1q_u8(HI_TAB.as_ptr()), hi);
let off = vqtbl1q_u8(vld1q_u8(OFF_TAB.as_ptr()), hi);
(vaddq_u8(c, off), vtstq_u8(mlo, mhi))
}
}
fn pack(v: uint8x16_t) -> uint8x16_t {
unsafe {
let wa = vqtbl1q_u8(v, vld1q_u8(PK_A.as_ptr()));
let wb = vqtbl1q_u8(v, vld1q_u8(PK_B.as_ptr()));
let la = vshlq_u8(wa, vld1q_s8(PK_SA.as_ptr()));
let lb = vshlq_u8(wb, vld1q_s8(PK_SB.as_ptr()));
vorrq_u8(la, lb)
}
}
fn decode_packed(s: &[u8]) -> Result<[u8; 24], ()> {
debug_assert!(s.len() == SALT_B64_LEN || s.len() == HASH_B64_LEN);
let mut buf = [b'.'; 32];
buf[..s.len()].copy_from_slice(s);
let mut out = [0u8; 24];
unsafe {
let (v0, m0) = translate(vld1q_u8(buf.as_ptr()));
let (v1, m1) = translate(vld1q_u8(buf.as_ptr().add(16)));
if vminvq_u8(vandq_u8(m0, m1)) == 0 {
return Err(());
}
let p1 = pack(v1);
vst1q_u8(out.as_mut_ptr(), pack(v0));
vst1_u8(out.as_mut_ptr().add(12), vget_low_u8(p1));
let hi = vgetq_lane_u32::<2>(vreinterpretq_u32_u8(p1));
(out.as_mut_ptr().add(20) as *mut u32).write_unaligned(hi);
}
Ok(out)
}
pub(crate) fn decode_16(s: &[u8]) -> Result<[u8; 16], ()> {
if s.len() != SALT_B64_LEN {
return Err(());
}
let packed = decode_packed(s)?;
let mut out = [0u8; 16];
out.copy_from_slice(&packed[..16]);
Ok(out)
}
pub(crate) fn decode_23(s: &[u8]) -> Result<[u8; 23], ()> {
if s.len() != HASH_B64_LEN {
return Err(());
}
let packed = decode_packed(s)?;
let mut out = [0u8; 23];
out.copy_from_slice(&packed[..23]);
Ok(out)
}