/* * Copyright 2026 The LibYuv Project Authors. All rights reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "libyuv/compare_row.h" #include "libyuv/row.h" #if !defined(LIBYUV_DISABLE_WASM) && defined(__wasm_simd128__) #include #ifdef __cplusplus namespace libyuv { extern "C" { #endif // Add the 4 32 bit lanes. static inline uint32_t SumLanes_WASMSIMD(v128_t sum) { sum = wasm_i32x4_add(sum, wasm_i64x2_shuffle(sum, sum, 1, 0)); sum = wasm_i32x4_add(sum, wasm_i32x4_shuffle(sum, sum, 1, 0, 3, 2)); return wasm_u32x4_extract_lane(sum, 0); } #if defined(HAS_HAMMINGDISTANCE_WASMSIMD) // Bit counts of 64 bytes are added as bytes, then pairs of bytes are added // to 16 bit sums, which hold up to 64 per 64 bytes, so count can be up to // 65535. Count is a multiple of 64. uint32_t HammingDistance_WASMSIMD(const uint8_t* src_a, const uint8_t* src_b, int count) { v128_t sum = wasm_i16x8_splat(0); while (count > 0) { v128_t c = wasm_i8x16_splat(0); int i; for (i = 0; i < 64; i += 16) { c = wasm_i8x16_add( c, wasm_i8x16_popcnt(wasm_v128_xor(wasm_v128_load(src_a + i), wasm_v128_load(src_b + i)))); } sum = wasm_i16x8_add(sum, wasm_u16x8_extadd_pairwise_u8x16(c)); src_a += 64; src_b += 64; count -= 64; } return SumLanes_WASMSIMD(wasm_u32x4_extadd_pairwise_u16x8(sum)); } #endif // HAS_HAMMINGDISTANCE_WASMSIMD #if defined(HAS_SUMSQUAREERROR_WASMSIMD) // Differences are widened to signed 16 bits and squared with i32x4.dot. // Count is a multiple of 16. uint32_t SumSquareError_WASMSIMD(const uint8_t* src_a, const uint8_t* src_b, int count) { v128_t sum = wasm_i32x4_splat(0); while (count > 0) { v128_t a = wasm_v128_load(src_a); v128_t b = wasm_v128_load(src_b); v128_t lo = wasm_i16x8_sub(wasm_u16x8_extend_low_u8x16(a), wasm_u16x8_extend_low_u8x16(b)); v128_t hi = wasm_i16x8_sub(wasm_u16x8_extend_high_u8x16(a), wasm_u16x8_extend_high_u8x16(b)); sum = wasm_i32x4_add(sum, wasm_i32x4_add(wasm_i32x4_dot_i16x8(lo, lo), wasm_i32x4_dot_i16x8(hi, hi))); src_a += 16; src_b += 16; count -= 16; } return SumLanes_WASMSIMD(sum); } #endif // HAS_SUMSQUAREERROR_WASMSIMD #if defined(HAS_HASHDJB2_WASMSIMD) static const uint32_t kHashMul_WASMSIMD[24] = { // 33 ^ (30 - 2 * i) for byte pair i of 32 bytes. 0xccc4cfc1, 0xd61beb81, 0x13791741, 0xac185301, // 33 ^ 30 .. 24 0xc8359ec1, 0x510cfa81, 0xb0da6641, 0x92d9e201, // 33 ^ 22 .. 16 0xa3476dc1, 0x4f5f0981, 0x855cb541, 0x747c7101, // 33 ^ 14 .. 8 0x4cfa3cc1, 0x00121881, 0x00000441, 0x00000001, // 33 ^ 6 .. 0 0x1137c401, 0x1137c401, 0x1137c401, 0x1137c401, // 33 ^ 32 0x00010021, 0x00010021, 0x00010021, 0x00010021, // 16 bit 33, 1 }; // Sum of 16 bytes times 33 ^ n, as 4 lanes. Byte pairs are combined as // src[2 * i] * 33 + src[2 * i + 1] with i32x4.dot, then multiplied by // 33 ^ n for the pair. static inline v128_t HashMul16_WASMSIMD(const uint8_t* src, const v128_t* m, v128_t k33) { v128_t s = wasm_v128_load(src); v128_t lo = wasm_i32x4_dot_i16x8(wasm_u16x8_extend_low_u8x16(s), k33); v128_t hi = wasm_i32x4_dot_i16x8(wasm_u16x8_extend_high_u8x16(s), k33); return wasm_i32x4_add(wasm_i32x4_mul(lo, m[0]), wasm_i32x4_mul(hi, m[1])); } // HashDjb2 of n bytes is hash * 33 ^ n + sum(src[i] * 33 ^ (n - 1 - i)). // Products are summed per lane, multiplying the sums by 33 ^ 32 for each 32 // bytes, so one horizontal add is done at the end. // Count is a multiple of 16. uint32_t HashDjb2_WASMSIMD(const uint8_t* src, int count, uint32_t seed) { const v128_t* m = (const v128_t*)kHashMul_WASMSIMD; v128_t sum = wasm_i32x4_make(0, 0, 0, (int32_t)seed); // Load constants into Wasm locals outside the loop, instead of v128.const // in the loop. asm("" : "+r"(m)); const v128_t k33_32 = m[4]; const v128_t k33 = m[5]; if (count & 16) { // Lane 3 of m[1] is 33 ^ 16, and lanes 0..2 of sum are 0. sum = wasm_i32x4_add(wasm_i32x4_mul(sum, m[1]), HashMul16_WASMSIMD(src, m + 2, k33)); src += 16; count -= 16; } while (count > 0) { sum = wasm_i32x4_add( wasm_i32x4_mul(sum, k33_32), wasm_i32x4_add(HashMul16_WASMSIMD(src, m, k33), HashMul16_WASMSIMD(src + 16, m + 2, k33))); src += 32; count -= 32; } return SumLanes_WASMSIMD(sum); } #endif // HAS_HASHDJB2_WASMSIMD #if defined(HAS_SSIM4X4ROW_WASMSIMD) void Ssim4x4Row_WASMSIMD(const uint8_t* src_a, int stride_a, const uint8_t* src_b, int stride_b, uint32_t* dst, int width) { const uint8_t* src_a1 = src_a + stride_a; const uint8_t* src_a2 = src_a1 + stride_a; const uint8_t* src_a3 = src_a2 + stride_a; const uint8_t* src_b1 = src_b + stride_b; const uint8_t* src_b2 = src_b1 + stride_b; const uint8_t* src_b3 = src_b2 + stride_b; const v128_t mask = wasm_i16x8_splat(0x00ff); for (; width > 0; width -= 16) { v128_t a0 = wasm_v128_load(src_a); v128_t a1 = wasm_v128_load(src_a1); v128_t a2 = wasm_v128_load(src_a2); v128_t a3 = wasm_v128_load(src_a3); v128_t b0 = wasm_v128_load(src_b); v128_t b1 = wasm_v128_load(src_b1); v128_t b2 = wasm_v128_load(src_b2); v128_t b3 = wasm_v128_load(src_b3); v128_t a0_ev = wasm_v128_and(a0, mask); v128_t a0_od = wasm_u16x8_shr(a0, 8); v128_t a1_ev = wasm_v128_and(a1, mask); v128_t a1_od = wasm_u16x8_shr(a1, 8); v128_t a2_ev = wasm_v128_and(a2, mask); v128_t a2_od = wasm_u16x8_shr(a2, 8); v128_t a3_ev = wasm_v128_and(a3, mask); v128_t a3_od = wasm_u16x8_shr(a3, 8); v128_t b0_ev = wasm_v128_and(b0, mask); v128_t b0_od = wasm_u16x8_shr(b0, 8); v128_t b1_ev = wasm_v128_and(b1, mask); v128_t b1_od = wasm_u16x8_shr(b1, 8); v128_t b2_ev = wasm_v128_and(b2, mask); v128_t b2_od = wasm_u16x8_shr(b2, 8); v128_t b3_ev = wasm_v128_and(b3, mask); v128_t b3_od = wasm_u16x8_shr(b3, 8); v128_t sum_a_16 = wasm_i16x8_add(wasm_i16x8_add(wasm_i16x8_add(a0_ev, a0_od), wasm_i16x8_add(a1_ev, a1_od)), wasm_i16x8_add(wasm_i16x8_add(a2_ev, a2_od), wasm_i16x8_add(a3_ev, a3_od))); v128_t sum_b_16 = wasm_i16x8_add(wasm_i16x8_add(wasm_i16x8_add(b0_ev, b0_od), wasm_i16x8_add(b1_ev, b1_od)), wasm_i16x8_add(wasm_i16x8_add(b2_ev, b2_od), wasm_i16x8_add(b3_ev, b3_od))); v128_t sum_a = wasm_u32x4_extadd_pairwise_u16x8(sum_a_16); v128_t sum_b = wasm_u32x4_extadd_pairwise_u16x8(sum_b_16); v128_t sum_axb = wasm_i32x4_add( wasm_i32x4_add(wasm_i32x4_add(wasm_i32x4_dot_i16x8(a0_ev, b0_ev), wasm_i32x4_dot_i16x8(a0_od, b0_od)), wasm_i32x4_add(wasm_i32x4_dot_i16x8(a1_ev, b1_ev), wasm_i32x4_dot_i16x8(a1_od, b1_od))), wasm_i32x4_add(wasm_i32x4_add(wasm_i32x4_dot_i16x8(a2_ev, b2_ev), wasm_i32x4_dot_i16x8(a2_od, b2_od)), wasm_i32x4_add(wasm_i32x4_dot_i16x8(a3_ev, b3_ev), wasm_i32x4_dot_i16x8(a3_od, b3_od)))); v128_t sq0 = wasm_i32x4_add(wasm_i32x4_add(wasm_i32x4_dot_i16x8(a0_ev, a0_ev), wasm_i32x4_dot_i16x8(a0_od, a0_od)), wasm_i32x4_add(wasm_i32x4_dot_i16x8(b0_ev, b0_ev), wasm_i32x4_dot_i16x8(b0_od, b0_od))); v128_t sq1 = wasm_i32x4_add(wasm_i32x4_add(wasm_i32x4_dot_i16x8(a1_ev, a1_ev), wasm_i32x4_dot_i16x8(a1_od, a1_od)), wasm_i32x4_add(wasm_i32x4_dot_i16x8(b1_ev, b1_ev), wasm_i32x4_dot_i16x8(b1_od, b1_od))); v128_t sq2 = wasm_i32x4_add(wasm_i32x4_add(wasm_i32x4_dot_i16x8(a2_ev, a2_ev), wasm_i32x4_dot_i16x8(a2_od, a2_od)), wasm_i32x4_add(wasm_i32x4_dot_i16x8(b2_ev, b2_ev), wasm_i32x4_dot_i16x8(b2_od, b2_od))); v128_t sq3 = wasm_i32x4_add(wasm_i32x4_add(wasm_i32x4_dot_i16x8(a3_ev, a3_ev), wasm_i32x4_dot_i16x8(a3_od, a3_od)), wasm_i32x4_add(wasm_i32x4_dot_i16x8(b3_ev, b3_ev), wasm_i32x4_dot_i16x8(b3_od, b3_od))); v128_t sum_sq_ab = wasm_i32x4_add(wasm_i32x4_add(sq0, sq1), wasm_i32x4_add(sq2, sq3)); v128_t t0 = wasm_i32x4_shuffle(sum_a, sum_b, 0, 4, 1, 5); v128_t t1 = wasm_i32x4_shuffle(sum_a, sum_b, 2, 6, 3, 7); v128_t t2 = wasm_i32x4_shuffle(sum_sq_ab, sum_axb, 0, 4, 1, 5); v128_t t3 = wasm_i32x4_shuffle(sum_sq_ab, sum_axb, 2, 6, 3, 7); wasm_v128_store(dst, wasm_i64x2_shuffle(t0, t2, 0, 2)); wasm_v128_store(dst + 4, wasm_i64x2_shuffle(t0, t2, 1, 3)); wasm_v128_store(dst + 8, wasm_i64x2_shuffle(t1, t3, 0, 2)); wasm_v128_store(dst + 12, wasm_i64x2_shuffle(t1, t3, 1, 3)); src_a += 16; src_a1 += 16; src_a2 += 16; src_a3 += 16; src_b += 16; src_b1 += 16; src_b2 += 16; src_b3 += 16; dst += 16; } } #endif // HAS_SSIM4X4ROW_WASMSIMD #ifdef __cplusplus } // extern "C" } // namespace libyuv #endif #endif // !defined(LIBYUV_DISABLE_WASM) && defined(__wasm_simd128__)