external/fast_image_resize
1
0
Fork 0
mirror of https://github.com/Cykooz/fast_image_resize.git synced 2026-10-08 01:11:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

alpha u8x4 passing

Browse Source
This commit is contained in:
Colin
2023-01-23 16:46:42 -05:00
committed by Colin Murphy
parent a71337a5c1
commit d5055fee0b
10 changed files with 855 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/alpha/u16x2/mod.rs
+10
View File
@@ -11,6 +11,8 @@ mod native;
mod neon;
#[cfg(target_arch = "x86_64")]
mod sse4;
#[cfg(target_arch = "wasm32")]
mod wasm32;
impl AlphaMulDiv for U16x2 {
fn multiply_alpha(
@@ -25,6 +27,8 @@ impl AlphaMulDiv for U16x2 {
CpuExtensions::Sse4_1 => unsafe { sse4::multiply_alpha(src_image, dst_image) },
#[cfg(target_arch = "aarch64")]
CpuExtensions::Neon => unsafe { neon::multiply_alpha(src_image, dst_image) },
#[cfg(target_arch = "wasm32")]
CpuExtensions::Wasm32 => unsafe { wasm32::multiply_alpha(src_image, dst_image) },
_ => native::multiply_alpha(src_image, dst_image),
}
}
@@ -37,6 +41,8 @@ impl AlphaMulDiv for U16x2 {
CpuExtensions::Sse4_1 => unsafe { sse4::multiply_alpha_inplace(image) },
#[cfg(target_arch = "aarch64")]
CpuExtensions::Neon => unsafe { neon::multiply_alpha_inplace(image) },
#[cfg(target_arch = "wasm32")]
CpuExtensions::Wasm32 => unsafe { wasm32::multiply_alpha_inplace(image) },
_ => native::multiply_alpha_inplace(image),
}
}
@@ -53,6 +59,8 @@ impl AlphaMulDiv for U16x2 {
CpuExtensions::Sse4_1 => unsafe { sse4::divide_alpha(src_image, dst_image) },
#[cfg(target_arch = "aarch64")]
CpuExtensions::Neon => unsafe { neon::divide_alpha(src_image, dst_image) },
#[cfg(target_arch = "wasm32")]
CpuExtensions::Wasm32 => unsafe { wasm32::divide_alpha(src_image, dst_image) },
_ => native::divide_alpha(src_image, dst_image),
}
}
@@ -65,6 +73,8 @@ impl AlphaMulDiv for U16x2 {
CpuExtensions::Sse4_1 => unsafe { sse4::divide_alpha_inplace(image) },
#[cfg(target_arch = "aarch64")]
CpuExtensions::Neon => unsafe { neon::divide_alpha_inplace(image) },
#[cfg(target_arch = "wasm32")]
CpuExtensions::Wasm32 => unsafe { wasm32::divide_alpha_inplace(image) },
_ => native::divide_alpha_inplace(image),
}
}
src/alpha/u16x2/wasm32.rs
+210
View File
@@ -0,0 +1,210 @@
use std::arch::wasm32::*;
use crate::pixels::U16x2;
use crate::utils::foreach_with_pre_reading;
use crate::{ImageView, ImageViewMut};
use super::native;
pub(crate) unsafe fn multiply_alpha(
src_image: &ImageView<U16x2>,
dst_image: &mut ImageViewMut<U16x2>,
) {
let src_rows = src_image.iter_rows(0);
let dst_rows = dst_image.iter_rows_mut();
for (src_row, dst_row) in src_rows.zip(dst_rows) {
multiply_alpha_row(src_row, dst_row);
}
}
pub(crate) unsafe fn multiply_alpha_inplace(image: &mut ImageViewMut<U16x2>) {
for row in image.iter_rows_mut() {
multiply_alpha_row_inplace(row);
}
}
#[inline]
pub(crate) unsafe fn multiply_alpha_row(src_row: &[U16x2], dst_row: &mut [U16x2]) {
let src_chunks = src_row.chunks_exact(4);
let src_remainder = src_chunks.remainder();
let mut dst_chunks = dst_row.chunks_exact_mut(4);
let src_dst = src_chunks.zip(&mut dst_chunks);
foreach_with_pre_reading(
src_dst,
|(src, dst)| {
let pixels = v128_load(src.as_ptr() as *const v128);
let dst_ptr = dst.as_mut_ptr() as *mut v128;
(pixels, dst_ptr)
},
|(mut pixels, dst_ptr)| {
pixels = multiplies_alpha_4_pixels(pixels);
v128_store(dst_ptr, pixels);
},
);
if !src_remainder.is_empty() {
let dst_reminder = dst_chunks.into_remainder();
native::multiply_alpha_row(src_remainder, dst_reminder);
}
}
#[inline]
pub(crate) unsafe fn multiply_alpha_row_inplace(row: &mut [U16x2]) {
let mut chunks = row.chunks_exact_mut(4);
foreach_with_pre_reading(
&mut chunks,
|chunk| {
let pixels = v128_load(chunk.as_ptr() as *const v128);
let dst_ptr = chunk.as_mut_ptr() as *mut v128;
(pixels, dst_ptr)
},
|(mut pixels, dst_ptr)| {
pixels = multiplies_alpha_4_pixels(pixels);
v128_store(dst_ptr, pixels);
},
);
let reminder = chunks.into_remainder();
if !reminder.is_empty() {
native::multiply_alpha_row_inplace(reminder);
}
}
#[inline]
unsafe fn multiplies_alpha_4_pixels(pixels: v128) -> v128 {
let zero = i64x2_splat(0);
let half = i32x4_splat(0x8000);
const MAX_A: i32 = 0xffff0000u32 as i32;
let max_alpha = i32x4_splat(MAX_A);
/*
|L0 A0 | |L1 A1 | |L2 A2 | |L3 A3 |
|0001 0203| |0405 0607| |0809 1011| |1213 1415|
*/
let factor_mask = i8x16(2, 3, 2, 3, 6, 7, 6, 7, 10, 11, 10, 11, 14, 15, 14, 15);
let factor_pixels = u8x16_swizzle(pixels, factor_mask);
let factor_pixels = v128_or(factor_pixels, max_alpha);
let src_i32_lo = i16x8_shuffle::<0, 8, 1, 9, 2, 10, 3, 11>(pixels, zero);
let factors = i16x8_shuffle::<0, 8, 1, 9, 2, 10, 3, 11>(factor_pixels, zero);
let src_i32_lo = i32x4_add(i32x4_mul(src_i32_lo, factors), half);
let dst_i32_lo = i32x4_add(src_i32_lo, u32x4_shr(src_i32_lo, 16));
let dst_i32_lo = u32x4_shr(dst_i32_lo, 16);
let src_i32_hi = i16x8_shuffle::<4, 12, 5, 13, 6, 14, 7, 15>(pixels, zero);
let factors = i16x8_shuffle::<4, 12, 5, 13, 6, 14, 7, 15>(factor_pixels, zero);
let src_i32_hi = i32x4_add(i32x4_mul(src_i32_hi, factors), half);
let dst_i32_hi = i32x4_add(src_i32_hi, u32x4_shr(src_i32_hi, 16));
let dst_i32_hi = u32x4_shr(dst_i32_hi, 16);
u16x8_narrow_i32x4(dst_i32_lo, dst_i32_hi)
}
// Divide
pub(crate) unsafe fn divide_alpha(
src_image: &ImageView<U16x2>,
dst_image: &mut ImageViewMut<U16x2>,
) {
let src_rows = src_image.iter_rows(0);
let dst_rows = dst_image.iter_rows_mut();
for (src_row, dst_row) in src_rows.zip(dst_rows) {
divide_alpha_row(src_row, dst_row);
}
}
pub(crate) unsafe fn divide_alpha_inplace(image: &mut ImageViewMut<U16x2>) {
for row in image.iter_rows_mut() {
divide_alpha_row_inplace(row);
}
}
pub(crate) unsafe fn divide_alpha_row(src_row: &[U16x2], dst_row: &mut [U16x2]) {
let src_chunks = src_row.chunks_exact(4);
let src_remainder = src_chunks.remainder();
let mut dst_chunks = dst_row.chunks_exact_mut(4);
let src_dst = src_chunks.zip(&mut dst_chunks);
foreach_with_pre_reading(
src_dst,
|(src, dst)| {
let pixels = v128_load(src.as_ptr() as *const v128);
let dst_ptr = dst.as_mut_ptr() as *mut v128;
(pixels, dst_ptr)
},
|(mut pixels, dst_ptr)| {
pixels = divide_alpha_4_pixels(pixels);
v128_store(dst_ptr, pixels);
},
);
if !src_remainder.is_empty() {
let dst_reminder = dst_chunks.into_remainder();
let mut src_pixels = [U16x2::new([0, 0]); 4];
src_pixels
.iter_mut()
.zip(src_remainder)
.for_each(|(d, s)| *d = *s);
let mut dst_pixels = [U16x2::new([0, 0]); 4];
let mut pixels = v128_load(src_pixels.as_ptr() as *const v128);
pixels = divide_alpha_4_pixels(pixels);
v128_store(dst_pixels.as_mut_ptr() as *mut v128, pixels);
dst_pixels
.iter()
.zip(dst_reminder)
.for_each(|(s, d)| *d = *s);
}
}
pub(crate) unsafe fn divide_alpha_row_inplace(row: &mut [U16x2]) {
let mut chunks = row.chunks_exact_mut(4);
// Using a simple for-loop in this case is faster than implementation with pre-reading
for chunk in &mut chunks {
let mut pixels = v128_load(chunk.as_ptr() as *const v128);
pixels = divide_alpha_4_pixels(pixels);
v128_store(chunk.as_mut_ptr() as *mut v128, pixels);
}
let reminder = chunks.into_remainder();
if !reminder.is_empty() {
let mut src_pixels = [U16x2::new([0, 0]); 4];
src_pixels
.iter_mut()
.zip(reminder.iter())
.for_each(|(d, s)| *d = *s);
let mut dst_pixels = [U16x2::new([0, 0]); 4];
let mut pixels = v128_load(src_pixels.as_ptr() as *const v128);
pixels = divide_alpha_4_pixels(pixels);
v128_store(dst_pixels.as_mut_ptr() as *mut v128, pixels);
dst_pixels.iter().zip(reminder).for_each(|(s, d)| *d = *s);
}
}
#[inline]
unsafe fn divide_alpha_4_pixels(pixels: v128) -> v128 {
let alpha_mask = i32x4_splat(0xffff0000u32 as i32);
let luma_mask = i32x4_splat(0xffff);
let alpha_max = f32x4_splat(65535.0);
/*
|L0 A0 | |L1 A1 | |L2 A2 | |L3 A3 |
|0001 0203| |0405 0607| |0809 1011| |1213 1415|
*/
let alpha32_sh = i8x16(2, 3, -1, -1, 6, 7, -1, -1, 10, 11, -1, -1, 14, 15, -1, -1);
let alpha_f32x4 = f32x4_convert_i32x4(u8x16_swizzle(pixels, alpha32_sh));
let luma_f32x4 = f32x4_convert_i32x4(v128_and(pixels, luma_mask));
let scaled_luma_f32x4 = f32x4_mul(luma_f32x4, alpha_max);
let divided_luma_u32x4 = u32x4_trunc_sat_f32x4(f32x4_div(scaled_luma_f32x4, alpha_f32x4));
let alpha = v128_and(pixels, alpha_mask);
u8x16_shuffle::<0, 1, 18, 19, 4, 5, 22, 23, 8, 9, 26, 27, 12, 13, 30, 31>(
divided_luma_u32x4,
alpha,
)
}
src/alpha/u8x2/sse4.rs
-123
View File
@@ -3,8 +3,6 @@ use std::arch::x86_64::*;
use crate::pixels::U8x2;
use crate::utils::foreach_with_pre_reading;
use crate::{ImageView, ImageViewMut};
use std::fs;
use std::path::Path;
use super::native;
@@ -128,9 +126,6 @@ pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x2], dst_row: &mut [U8x2]) {
let src_remainder = src_chunks.remainder();
let mut dst_chunks = dst_row.chunks_exact_mut(8);
let src_dst = src_chunks.zip(&mut dst_chunks);
let file = "sse4";
let mut debugout = String::new();
let file_exists = Path::new(file).exists();
foreach_with_pre_reading(
src_dst,
|(src, dst)| {
@@ -140,13 +135,6 @@ pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x2], dst_row: &mut [U8x2]) {
},
|(mut pixels, dst_ptr)| {
pixels = divide_alpha_8_pixels(pixels);
if !file_exists {
debugout += &format!(
"142: {:?} {:?}\n",
_mm_extract_epi64(pixels, 0),
_mm_extract_epi64(pixels, 1)
);
}
_mm_storeu_si128(dst_ptr, pixels);
},
);
@@ -162,13 +150,6 @@ pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x2], dst_row: &mut [U8x2]) {
let mut dst_pixels = [U8x2::new(0); 8];
let mut pixels = _mm_loadu_si128(src_pixels.as_ptr() as *const __m128i);
pixels = divide_alpha_8_pixels(pixels);
if !file_exists {
debugout += &format!(
"164: {:?} {:?}\n",
_mm_extract_epi64(pixels, 0),
_mm_extract_epi64(pixels, 1)
);
}
_mm_storeu_si128(dst_pixels.as_mut_ptr() as *mut __m128i, pixels);
dst_pixels
@@ -176,9 +157,6 @@ pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x2], dst_row: &mut [U8x2]) {
.zip(dst_reminder)
.for_each(|(s, d)| *d = *s);
}
if !file_exists {
fs::write(file, debugout).unwrap();
}
}
#[inline]
@@ -218,16 +196,6 @@ pub(crate) unsafe fn divide_alpha_row_inplace(row: &mut [U8x2]) {
#[inline]
#[target_feature(enable = "sse4.1")]
unsafe fn divide_alpha_8_pixels(pixels: __m128i) -> __m128i {
let mut file: String = "sse48".to_string();
let mut debugout = String::new();
while Path::new(&file).exists() {
file += "a";
}
debugout += &format!(
"pixels: {:?} {:?}\n",
_mm_extract_epi64(pixels, 0),
_mm_extract_epi64(pixels, 1)
);
let alpha_mask = _mm_set1_epi16(0xff00u16 as i16);
let luma_mask = _mm_set1_epi16(0xff);
let alpha32_sh_lo = _mm_set_epi8(-1, -1, -1, 7, -1, -1, -1, 5, -1, -1, -1, 3, -1, -1, -1, 1);
@@ -237,106 +205,15 @@ unsafe fn divide_alpha_8_pixels(pixels: __m128i) -> __m128i {
let alpha_scale = _mm_set1_ps(255.0 * 256.0);
let alpha_lo_f32 = _mm_cvtepi32_ps(_mm_shuffle_epi8(pixels, alpha32_sh_lo));
debugout += &format!(
"alpha_lo_f32: {:?} {:?} {:?} {:?}\n",
f32::from_bits(_mm_extract_ps(alpha_lo_f32, 0) as u32),
f32::from_bits(_mm_extract_ps(alpha_lo_f32, 1) as u32),
f32::from_bits(_mm_extract_ps(alpha_lo_f32, 2) as u32),
f32::from_bits(_mm_extract_ps(alpha_lo_f32, 3) as u32),
);
let scaled_alpha_lo_i32 = _mm_cvtps_epi32(_mm_div_ps(alpha_scale, alpha_lo_f32));
debugout += &format!(
"scaled_alpha_lo_i32: {:?} {:?} {:?} {:?}\n",
_mm_extract_epi32(scaled_alpha_lo_i32, 0) as u32,
_mm_extract_epi32(scaled_alpha_lo_i32, 1) as u32,
_mm_extract_epi32(scaled_alpha_lo_i32, 2) as u32,
_mm_extract_epi32(scaled_alpha_lo_i32, 3) as u32,
);
debugout += &format!(
"as_i16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi16(scaled_alpha_lo_i32, 0) as u32,
_mm_extract_epi16(scaled_alpha_lo_i32, 1) as u32,
_mm_extract_epi16(scaled_alpha_lo_i32, 2) as u32,
_mm_extract_epi16(scaled_alpha_lo_i32, 3) as u32,
_mm_extract_epi16(scaled_alpha_lo_i32, 4) as u32,
_mm_extract_epi16(scaled_alpha_lo_i32, 5) as u32,
_mm_extract_epi16(scaled_alpha_lo_i32, 6) as u32,
_mm_extract_epi16(scaled_alpha_lo_i32, 7) as u32,
);
let alpha_hi_f32 = _mm_cvtepi32_ps(_mm_shuffle_epi8(pixels, alpha32_sh_hi));
debugout += &format!(
"alpha_hi_f32: {:?} {:?} {:?} {:?}\n",
f32::from_bits(_mm_extract_ps(alpha_hi_f32, 0) as u32),
f32::from_bits(_mm_extract_ps(alpha_hi_f32, 1) as u32),
f32::from_bits(_mm_extract_ps(alpha_hi_f32, 2) as u32),
f32::from_bits(_mm_extract_ps(alpha_hi_f32, 3) as u32),
);
let scaled_alpha_hi_i32 = _mm_cvtps_epi32(_mm_div_ps(alpha_scale, alpha_hi_f32));
debugout += &format!(
"scaled_alpha_hi_f32: {:?} {:?} {:?} {:?}\n",
f32::from_bits(_mm_extract_ps(_mm_div_ps(alpha_scale, alpha_hi_f32), 0) as u32),
f32::from_bits(_mm_extract_ps(_mm_div_ps(alpha_scale, alpha_hi_f32), 1) as u32),
f32::from_bits(_mm_extract_ps(_mm_div_ps(alpha_scale, alpha_hi_f32), 2) as u32),
f32::from_bits(_mm_extract_ps(_mm_div_ps(alpha_scale, alpha_hi_f32), 3) as u32),
);
debugout += &format!(
"scaled_alpha_hi_i32: {:?} {:?} {:?} {:?}\n",
_mm_extract_epi32(scaled_alpha_hi_i32, 0) as u32,
_mm_extract_epi32(scaled_alpha_hi_i32, 1) as u32,
_mm_extract_epi32(scaled_alpha_hi_i32, 2) as u32,
_mm_extract_epi32(scaled_alpha_hi_i32, 3) as u32,
);
debugout += &format!(
"as_i16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi16(scaled_alpha_hi_i32, 0) as u16,
_mm_extract_epi16(scaled_alpha_hi_i32, 1) as u16,
_mm_extract_epi16(scaled_alpha_hi_i32, 2) as u16,
_mm_extract_epi16(scaled_alpha_hi_i32, 3) as u16,
_mm_extract_epi16(scaled_alpha_hi_i32, 4) as u16,
_mm_extract_epi16(scaled_alpha_hi_i32, 5) as u16,
_mm_extract_epi16(scaled_alpha_hi_i32, 6) as u16,
_mm_extract_epi16(scaled_alpha_hi_i32, 7) as u16,
);
let scaled_alpha_i16 = _mm_packus_epi32(scaled_alpha_lo_i32, scaled_alpha_hi_i32);
debugout += &format!(
"scaled_alpha_i16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi16(scaled_alpha_i16, 0) as u16,
_mm_extract_epi16(scaled_alpha_i16, 1) as u16,
_mm_extract_epi16(scaled_alpha_i16, 2) as u16,
_mm_extract_epi16(scaled_alpha_i16, 3) as u16,
_mm_extract_epi16(scaled_alpha_i16, 4) as u16,
_mm_extract_epi16(scaled_alpha_i16, 5) as u16,
_mm_extract_epi16(scaled_alpha_i16, 6) as u16,
_mm_extract_epi16(scaled_alpha_i16, 7) as u16,
);
let luma_i16 = _mm_and_si128(pixels, luma_mask);
debugout += &format!(
"luma_i16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi16(luma_i16, 0) as u16,
_mm_extract_epi16(luma_i16, 1) as u16,
_mm_extract_epi16(luma_i16, 2) as u16,
_mm_extract_epi16(luma_i16, 3) as u16,
_mm_extract_epi16(luma_i16, 4) as u16,
_mm_extract_epi16(luma_i16, 5) as u16,
_mm_extract_epi16(luma_i16, 6) as u16,
_mm_extract_epi16(luma_i16, 7) as u16,
);
let scaled_luma_i16 = _mm_mullo_epi16(luma_i16, scaled_alpha_i16);
let scaled_luma_i16 = _mm_srli_epi16::<8>(scaled_luma_i16);
debugout += &format!(
"scaled_luma_i16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi16(scaled_luma_i16, 0) as u16,
_mm_extract_epi16(scaled_luma_i16, 1) as u16,
_mm_extract_epi16(scaled_luma_i16, 2) as u16,
_mm_extract_epi16(scaled_luma_i16, 3) as u16,
_mm_extract_epi16(scaled_luma_i16, 4) as u16,
_mm_extract_epi16(scaled_luma_i16, 5) as u16,
_mm_extract_epi16(scaled_luma_i16, 6) as u16,
_mm_extract_epi16(scaled_luma_i16, 7) as u16,
);
let alpha = _mm_and_si128(pixels, alpha_mask);
fs::write(file, debugout).unwrap();
_mm_blendv_epi8(scaled_luma_i16, alpha, alpha_mask)
}
src/alpha/u8x2/wasm32.rs
+7 -106
View File
@@ -216,130 +216,31 @@ pub(crate) unsafe fn divide_alpha_row_inplace(row: &mut [U8x2]) {
#[inline]
unsafe fn divide_alpha_8_pixels(pixels: v128) -> v128 {
let mut file: String = "wasm328".to_string();
let mut debugout = String::new();
//let file_exists = Path::new(file).exists();
while Path::new(&file).exists() {
file += "a";
}
debugout += &format!(
"pixels: {:?} {:?}\n",
i64x2_extract_lane::<0>(pixels),
i64x2_extract_lane::<1>(pixels)
);
let alpha_mask = i16x8_splat(0xff00u16 as i16);
let luma_mask = i16x8_splat(0xff);
//let scaled_max = f32x4_splat(1073741824f32);
let alpha32_sh_lo = i8x16(1, -1, -1, -1, 3, -1, -1, -1, 5, -1, -1, -1, 7, -1, -1, -1);
let alpha32_sh_hi = i8x16(
9, -1, -1, -1, 11, -1, -1, -1, 13, -1, -1, -1, 15, -1, -1, -1,
);
let alpha_scale = f32x4_splat(255.0 * 256.0);
// Tests pass without capping inf from dividing by zero, but scaled values will not match sse4.
let alpha_max = f32x4_splat(2147483648f32);
let alpha_lo_f32 = f32x4_convert_i32x4(i8x16_swizzle(pixels, alpha32_sh_lo));
debugout += &format!(
"alpha_lo_f32: {:?} {:?} {:?} {:?}\n",
f32x4_extract_lane::<0>(alpha_lo_f32),
f32x4_extract_lane::<1>(alpha_lo_f32),
f32x4_extract_lane::<2>(alpha_lo_f32),
f32x4_extract_lane::<3>(alpha_lo_f32)
);
let alpha_lo_f32 = f32x4_convert_u32x4(i8x16_swizzle(pixels, alpha32_sh_lo));
// trunc_sat will always round down. Adding f32x4_nearest would match _mm_cvtps_ep32 exactly,
// but would add extra instructions.
let scaled_alpha_lo_u32 =
u32x4_trunc_sat_f32x4(f32x4_nearest(f32x4_div(alpha_scale, alpha_lo_f32)));
debugout += &format!(
"scaled_alpha_lo_u32: {:?} {:?} {:?} {:?}\n",
u32x4_extract_lane::<0>(scaled_alpha_lo_u32),
u32x4_extract_lane::<1>(scaled_alpha_lo_u32),
u32x4_extract_lane::<2>(scaled_alpha_lo_u32),
u32x4_extract_lane::<3>(scaled_alpha_lo_u32)
);
debugout += &format!(
"as_u16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u16x8_extract_lane::<0>(scaled_alpha_lo_u32),
u16x8_extract_lane::<1>(scaled_alpha_lo_u32),
u16x8_extract_lane::<2>(scaled_alpha_lo_u32),
u16x8_extract_lane::<3>(scaled_alpha_lo_u32),
u16x8_extract_lane::<4>(scaled_alpha_lo_u32),
u16x8_extract_lane::<5>(scaled_alpha_lo_u32),
u16x8_extract_lane::<6>(scaled_alpha_lo_u32),
u16x8_extract_lane::<7>(scaled_alpha_lo_u32),
);
u32x4_trunc_sat_f32x4(f32x4_min(f32x4_div(alpha_scale, alpha_lo_f32), alpha_max));
let alpha_hi_f32 = f32x4_convert_u32x4(i8x16_swizzle(pixels, alpha32_sh_hi));
debugout += &format!(
"alpha_hi_f32: {:?} {:?} {:?} {:?}\n",
f32x4_extract_lane::<0>(alpha_hi_f32),
f32x4_extract_lane::<1>(alpha_hi_f32),
f32x4_extract_lane::<2>(alpha_hi_f32),
f32x4_extract_lane::<3>(alpha_hi_f32)
);
let scaled_alpha_hi_u32 =
u32x4_trunc_sat_f32x4(f32x4_nearest(f32x4_div(alpha_scale, alpha_hi_f32)));
debugout += &format!(
"scaled_alpha_hi_f32: {:?} {:?} {:?} {:?}\n",
f32x4_extract_lane::<0>(f32x4_nearest(f32x4_div(alpha_scale, alpha_hi_f32))),
f32x4_extract_lane::<1>(f32x4_nearest(f32x4_div(alpha_scale, alpha_hi_f32))),
f32x4_extract_lane::<2>(f32x4_nearest(f32x4_div(alpha_scale, alpha_hi_f32))),
f32x4_extract_lane::<3>(f32x4_nearest(f32x4_div(alpha_scale, alpha_hi_f32)))
);
debugout += &format!(
"scaled_alpha_hi_u32: {:?} {:?} {:?} {:?}\n",
u32x4_extract_lane::<0>(scaled_alpha_hi_u32),
u32x4_extract_lane::<1>(scaled_alpha_hi_u32),
u32x4_extract_lane::<2>(scaled_alpha_hi_u32),
u32x4_extract_lane::<3>(scaled_alpha_hi_u32),
);
debugout += &format!(
"as_u16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u16x8_extract_lane::<0>(scaled_alpha_hi_u32),
u16x8_extract_lane::<1>(scaled_alpha_hi_u32),
u16x8_extract_lane::<2>(scaled_alpha_hi_u32),
u16x8_extract_lane::<3>(scaled_alpha_hi_u32),
u16x8_extract_lane::<4>(scaled_alpha_hi_u32),
u16x8_extract_lane::<5>(scaled_alpha_hi_u32),
u16x8_extract_lane::<6>(scaled_alpha_hi_u32),
u16x8_extract_lane::<7>(scaled_alpha_hi_u32)
);
u32x4_trunc_sat_f32x4(f32x4_min(f32x4_div(alpha_scale, alpha_hi_f32), alpha_max));
let scaled_alpha_u16 = u16x8_narrow_i32x4(scaled_alpha_lo_u32, scaled_alpha_hi_u32);
debugout += &format!(
"scaled_alpha_u16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u16x8_extract_lane::<0>(scaled_alpha_u16),
u16x8_extract_lane::<1>(scaled_alpha_u16),
u16x8_extract_lane::<2>(scaled_alpha_u16),
u16x8_extract_lane::<3>(scaled_alpha_u16),
u16x8_extract_lane::<4>(scaled_alpha_u16),
u16x8_extract_lane::<5>(scaled_alpha_u16),
u16x8_extract_lane::<6>(scaled_alpha_u16),
u16x8_extract_lane::<7>(scaled_alpha_u16),
);
let luma_u16 = v128_and(pixels, luma_mask);
debugout += &format!(
"luma_u16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u16x8_extract_lane::<0>(luma_u16),
u16x8_extract_lane::<1>(luma_u16),
u16x8_extract_lane::<2>(luma_u16),
u16x8_extract_lane::<3>(luma_u16),
u16x8_extract_lane::<4>(luma_u16),
u16x8_extract_lane::<5>(luma_u16),
u16x8_extract_lane::<6>(luma_u16),
u16x8_extract_lane::<7>(luma_u16),
);
let scaled_luma_u16 = u16x8_mul(luma_u16, scaled_alpha_u16);
let scaled_luma_u16 = u16x8_shr(scaled_luma_u16, 8);
debugout += &format!(
"scaled_luma_u16: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u16x8_extract_lane::<0>(scaled_luma_u16),
u16x8_extract_lane::<1>(scaled_luma_u16),
u16x8_extract_lane::<2>(scaled_luma_u16),
u16x8_extract_lane::<3>(scaled_luma_u16),
u16x8_extract_lane::<4>(scaled_luma_u16),
u16x8_extract_lane::<5>(scaled_luma_u16),
u16x8_extract_lane::<6>(scaled_luma_u16),
u16x8_extract_lane::<7>(scaled_luma_u16),
);
let alpha = v128_and(pixels, alpha_mask);
fs::write(file, debugout).unwrap();
u8x16_shuffle::<0, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 29, 14, 31>(
scaled_luma_u16,
alpha,
src/alpha/u8x4/mod.rs
+10
View File
@@ -11,6 +11,8 @@ mod native;
mod neon;
#[cfg(target_arch = "x86_64")]
mod sse4;
#[cfg(target_arch = "wasm32")]
mod wasm32;
impl AlphaMulDiv for U8x4 {
fn multiply_alpha(
@@ -25,6 +27,8 @@ impl AlphaMulDiv for U8x4 {
CpuExtensions::Sse4_1 => unsafe { sse4::multiply_alpha(src_image, dst_image) },
#[cfg(target_arch = "aarch64")]
CpuExtensions::Neon => unsafe { neon::multiply_alpha(src_image, dst_image) },
#[cfg(target_arch = "wasm32")]
CpuExtensions::Wasm32 => unsafe { wasm32::multiply_alpha(src_image, dst_image) },
_ => native::multiply_alpha(src_image, dst_image),
}
}
@@ -37,6 +41,8 @@ impl AlphaMulDiv for U8x4 {
CpuExtensions::Sse4_1 => unsafe { sse4::multiply_alpha_inplace(image) },
#[cfg(target_arch = "aarch64")]
CpuExtensions::Neon => unsafe { neon::multiply_alpha_inplace(image) },
#[cfg(target_arch = "wasm32")]
CpuExtensions::Wasm32 => unsafe { wasm32::multiply_alpha_inplace(image) },
_ => native::multiply_alpha_inplace(image),
}
}
@@ -53,6 +59,8 @@ impl AlphaMulDiv for U8x4 {
CpuExtensions::Sse4_1 => unsafe { sse4::divide_alpha(src_image, dst_image) },
#[cfg(target_arch = "aarch64")]
CpuExtensions::Neon => unsafe { neon::divide_alpha(src_image, dst_image) },
#[cfg(target_arch = "wasm32")]
CpuExtensions::Wasm32 => unsafe { wasm32::divide_alpha(src_image, dst_image) },
_ => native::divide_alpha(src_image, dst_image),
}
}
@@ -65,6 +73,8 @@ impl AlphaMulDiv for U8x4 {
CpuExtensions::Sse4_1 => unsafe { sse4::divide_alpha_inplace(image) },
#[cfg(target_arch = "aarch64")]
CpuExtensions::Neon => unsafe { neon::divide_alpha_inplace(image) },
#[cfg(target_arch = "wasm32")]
CpuExtensions::Wasm32 => unsafe { wasm32::divide_alpha_inplace(image) },
_ => native::divide_alpha_inplace(image),
}
}
src/alpha/u8x4/sse4.rs
+174
View File
@@ -3,6 +3,8 @@ use std::arch::x86_64::*;
use crate::pixels::U8x4;
use crate::utils::foreach_with_pre_reading;
use crate::{ImageView, ImageViewMut};
use std::fs;
use std::path::Path;
use super::native;
@@ -118,6 +120,11 @@ pub(crate) unsafe fn divide_alpha_inplace(image: &mut ImageViewMut<U8x4>) {
#[inline]
#[target_feature(enable = "sse4.1")]
pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x4], dst_row: &mut [U8x4]) {
let mut file: String = "sse4r".to_string();
let mut debugout = String::new();
while Path::new(&file).exists() {
file += "b";
}
let src_chunks = src_row.chunks_exact(4);
let src_remainder = src_chunks.remainder();
let mut dst_chunks = dst_row.chunks_exact_mut(4);
@@ -131,6 +138,25 @@ pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x4], dst_row: &mut [U8x4]) {
},
|(mut pixels, dst_ptr)| {
pixels = divide_alpha_4_pixels(pixels);
debugout += &format!(
"143 pixels: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi8(pixels, 0) as u8,
_mm_extract_epi8(pixels, 1) as u8,
_mm_extract_epi8(pixels, 2) as u8,
_mm_extract_epi8(pixels, 3) as u8,
_mm_extract_epi8(pixels, 4) as u8,
_mm_extract_epi8(pixels, 5) as u8,
_mm_extract_epi8(pixels, 6) as u8,
_mm_extract_epi8(pixels, 7) as u8,
_mm_extract_epi8(pixels, 8) as u8,
_mm_extract_epi8(pixels, 9) as u8,
_mm_extract_epi8(pixels, 10) as u8,
_mm_extract_epi8(pixels, 11) as u8,
_mm_extract_epi8(pixels, 12) as u8,
_mm_extract_epi8(pixels, 13) as u8,
_mm_extract_epi8(pixels, 14) as u8,
_mm_extract_epi8(pixels, 15) as u8,
);
_mm_storeu_si128(dst_ptr, pixels);
},
);
@@ -146,6 +172,13 @@ pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x4], dst_row: &mut [U8x4]) {
let mut dst_buffer = [U8x4::new(0); 4];
let src_pixels = _mm_loadu_si128(src_buffer.as_ptr() as *const __m128i);
let dst_pixels = divide_alpha_4_pixels(src_pixels);
debugout += &format!(
"165 dst_pixels: {:?} {:?} {:?} {:?}\n",
_mm_extract_epi32(dst_pixels, 0) as u32,
_mm_extract_epi32(dst_pixels, 1) as u32,
_mm_extract_epi32(dst_pixels, 2) as u32,
_mm_extract_epi32(dst_pixels, 3) as u32,
);
_mm_storeu_si128(dst_buffer.as_mut_ptr() as *mut __m128i, dst_pixels);
dst_buffer
@@ -153,11 +186,17 @@ pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x4], dst_row: &mut [U8x4]) {
.zip(dst_reminder)
.for_each(|(s, d)| *d = *s);
}
fs::write(file, debugout).unwrap();
}
#[inline]
#[target_feature(enable = "sse4.1")]
pub(crate) unsafe fn divide_alpha_row_inplace(row: &mut [U8x4]) {
let mut file: String = "sse4i".to_string();
let mut debugout = String::new();
while Path::new(&file).exists() {
file += "c";
}
let mut chunks = row.chunks_exact_mut(4);
foreach_with_pre_reading(
&mut chunks,
@@ -168,6 +207,13 @@ pub(crate) unsafe fn divide_alpha_row_inplace(row: &mut [U8x4]) {
},
|(mut pixels, dst_ptr)| {
pixels = divide_alpha_4_pixels(pixels);
debugout += &format!(
"179 pixels: {:?} {:?} {:?} {:?}\n",
_mm_extract_epi32(pixels, 0) as u32,
_mm_extract_epi32(pixels, 1) as u32,
_mm_extract_epi32(pixels, 2) as u32,
_mm_extract_epi32(pixels, 3) as u32,
);
_mm_storeu_si128(dst_ptr, pixels);
},
);
@@ -183,15 +229,35 @@ pub(crate) unsafe fn divide_alpha_row_inplace(row: &mut [U8x4]) {
let mut dst_buffer = [U8x4::new(0); 4];
let src_pixels = _mm_loadu_si128(src_buffer.as_ptr() as *const __m128i);
let dst_pixels = divide_alpha_4_pixels(src_pixels);
debugout += &format!(
"201 dst_pixels: {:?} {:?} {:?} {:?}\n",
_mm_extract_epi32(dst_pixels, 0) as u32,
_mm_extract_epi32(dst_pixels, 1) as u32,
_mm_extract_epi32(dst_pixels, 2) as u32,
_mm_extract_epi32(dst_pixels, 3) as u32,
);
_mm_storeu_si128(dst_buffer.as_mut_ptr() as *mut __m128i, dst_pixels);
dst_buffer.iter().zip(tail).for_each(|(s, d)| *d = *s);
}
fs::write(file, debugout).unwrap();
}
#[inline]
#[target_feature(enable = "sse4.1")]
unsafe fn divide_alpha_4_pixels(src_pixels: __m128i) -> __m128i {
let mut file: String = "sse48".to_string();
let mut debugout = String::new();
while Path::new(&file).exists() {
file += "a";
}
debugout += &format!(
"src_pixels: {:?} {:?} {:?} {:?}\n",
_mm_extract_epi32(src_pixels, 0) as u32,
_mm_extract_epi32(src_pixels, 1) as u32,
_mm_extract_epi32(src_pixels, 2) as u32,
_mm_extract_epi32(src_pixels, 3) as u32,
);
let zero = _mm_setzero_si128();
let alpha_mask = _mm_set1_epi32(0xff000000u32 as i32);
let shuffle1 = _mm_set_epi8(5, 4, 5, 4, 5, 4, 5, 4, 1, 0, 1, 0, 1, 0, 1, 0);
@@ -199,8 +265,55 @@ unsafe fn divide_alpha_4_pixels(src_pixels: __m128i) -> __m128i {
let alpha_scale = _mm_set1_ps(255.0 * 256.0);
let alpha_f32 = _mm_cvtepi32_ps(_mm_srli_epi32::<24>(src_pixels));
debugout += &format!(
"shift24: {:?} {:?} {:?} {:?}\n",
_mm_extract_epi32(_mm_srli_epi32::<24>(src_pixels), 0) as u32,
_mm_extract_epi32(_mm_srli_epi32::<24>(src_pixels), 1) as u32,
_mm_extract_epi32(_mm_srli_epi32::<24>(src_pixels), 2) as u32,
_mm_extract_epi32(_mm_srli_epi32::<24>(src_pixels), 3) as u32,
);
debugout += &format!(
"alpha_f32: {:?} {:?} {:?} {:?}\n",
f32::from_bits(_mm_extract_ps(alpha_f32, 0) as u32),
f32::from_bits(_mm_extract_ps(alpha_f32, 1) as u32),
f32::from_bits(_mm_extract_ps(alpha_f32, 2) as u32),
f32::from_bits(_mm_extract_ps(alpha_f32, 3) as u32),
);
let scaled_alpha_f32 = _mm_div_ps(alpha_scale, alpha_f32);
debugout += &format!(
"scaled_alpha_f32: {:?} {:?} {:?} {:?}\n",
f32::from_bits(_mm_extract_ps(scaled_alpha_f32, 0) as u32),
f32::from_bits(_mm_extract_ps(scaled_alpha_f32, 1) as u32),
f32::from_bits(_mm_extract_ps(scaled_alpha_f32, 2) as u32),
f32::from_bits(_mm_extract_ps(scaled_alpha_f32, 3) as u32),
);
let scaled_alpha_i32 = _mm_cvtps_epi32(scaled_alpha_f32);
debugout += &format!(
"scaled_alpha_u32: {:?} {:?} {:?} {:?}\n",
_mm_extract_epi32(scaled_alpha_i32, 0) as u32,
_mm_extract_epi32(scaled_alpha_i32, 1) as u32,
_mm_extract_epi32(scaled_alpha_i32, 2) as u32,
_mm_extract_epi32(scaled_alpha_i32, 3) as u32,
);
debugout += &format!(
"scaled_alpha_u32: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi8(scaled_alpha_i32, 0) as u8,
_mm_extract_epi8(scaled_alpha_i32, 1) as u8,
_mm_extract_epi8(scaled_alpha_i32, 2) as u8,
_mm_extract_epi8(scaled_alpha_i32, 3) as u8,
_mm_extract_epi8(scaled_alpha_i32, 4) as u8,
_mm_extract_epi8(scaled_alpha_i32, 5) as u8,
_mm_extract_epi8(scaled_alpha_i32, 6) as u8,
_mm_extract_epi8(scaled_alpha_i32, 7) as u8,
_mm_extract_epi8(scaled_alpha_i32, 8) as u8,
_mm_extract_epi8(scaled_alpha_i32, 9) as u8,
_mm_extract_epi8(scaled_alpha_i32, 10) as u8,
_mm_extract_epi8(scaled_alpha_i32, 11) as u8,
_mm_extract_epi8(scaled_alpha_i32, 12) as u8,
_mm_extract_epi8(scaled_alpha_i32, 13) as u8,
_mm_extract_epi8(scaled_alpha_i32, 14) as u8,
_mm_extract_epi8(scaled_alpha_i32, 15) as u8,
);
let mma0 = _mm_shuffle_epi8(scaled_alpha_i32, shuffle1);
let mma1 = _mm_shuffle_epi8(scaled_alpha_i32, shuffle2);
@@ -208,10 +321,71 @@ unsafe fn divide_alpha_4_pixels(src_pixels: __m128i) -> __m128i {
let pix1 = _mm_unpackhi_epi8(zero, src_pixels);
let pix0 = _mm_mulhi_epu16(pix0, mma0);
debugout += &format!(
"pix0: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi16(pix0, 0) as u16,
_mm_extract_epi16(pix0, 1) as u16,
_mm_extract_epi16(pix0, 2) as u16,
_mm_extract_epi16(pix0, 3) as u16,
_mm_extract_epi16(pix0, 4) as u16,
_mm_extract_epi16(pix0, 5) as u16,
_mm_extract_epi16(pix0, 6) as u16,
_mm_extract_epi16(pix0, 7) as u16,
);
let pix1 = _mm_mulhi_epu16(pix1, mma1);
debugout += &format!(
"pix1: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi16(pix1, 0) as u16,
_mm_extract_epi16(pix1, 1) as u16,
_mm_extract_epi16(pix1, 2) as u16,
_mm_extract_epi16(pix1, 3) as u16,
_mm_extract_epi16(pix1, 4) as u16,
_mm_extract_epi16(pix1, 5) as u16,
_mm_extract_epi16(pix1, 6) as u16,
_mm_extract_epi16(pix1, 7) as u16,
);
let alpha = _mm_and_si128(src_pixels, alpha_mask);
debugout += &format!(
"alpha: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi8(alpha, 0) as u8,
_mm_extract_epi8(alpha, 1) as u8,
_mm_extract_epi8(alpha, 2) as u8,
_mm_extract_epi8(alpha, 3) as u8,
_mm_extract_epi8(alpha, 4) as u8,
_mm_extract_epi8(alpha, 5) as u8,
_mm_extract_epi8(alpha, 6) as u8,
_mm_extract_epi8(alpha, 7) as u8,
_mm_extract_epi8(alpha, 8) as u8,
_mm_extract_epi8(alpha, 9) as u8,
_mm_extract_epi8(alpha, 10) as u8,
_mm_extract_epi8(alpha, 11) as u8,
_mm_extract_epi8(alpha, 12) as u8,
_mm_extract_epi8(alpha, 13) as u8,
_mm_extract_epi8(alpha, 14) as u8,
_mm_extract_epi8(alpha, 15) as u8,
);
let rgb = _mm_packus_epi16(pix0, pix1);
debugout += &format!(
"rgb: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
_mm_extract_epi8(rgb, 0) as u8,
_mm_extract_epi8(rgb, 1) as u8,
_mm_extract_epi8(rgb, 2) as u8,
_mm_extract_epi8(rgb, 3) as u8,
_mm_extract_epi8(rgb, 4) as u8,
_mm_extract_epi8(rgb, 5) as u8,
_mm_extract_epi8(rgb, 6) as u8,
_mm_extract_epi8(rgb, 7) as u8,
_mm_extract_epi8(rgb, 8) as u8,
_mm_extract_epi8(rgb, 9) as u8,
_mm_extract_epi8(rgb, 10) as u8,
_mm_extract_epi8(rgb, 11) as u8,
_mm_extract_epi8(rgb, 12) as u8,
_mm_extract_epi8(rgb, 13) as u8,
_mm_extract_epi8(rgb, 14) as u8,
_mm_extract_epi8(rgb, 15) as u8,
);
fs::write(file, debugout).unwrap();
_mm_blendv_epi8(rgb, alpha, alpha_mask)
}
src/alpha/u8x4/wasm32.rs
+394
View File
@@ -0,0 +1,394 @@
use std::arch::wasm32::*;
use crate::pixels::U8x4;
use crate::utils::foreach_with_pre_reading;
use crate::wasm32_utils;
use crate::{ImageView, ImageViewMut};
use std::fs;
use std::path::Path;
use super::native;
pub(crate) unsafe fn multiply_alpha(
src_image: &ImageView<U8x4>,
dst_image: &mut ImageViewMut<U8x4>,
) {
let src_rows = src_image.iter_rows(0);
let dst_rows = dst_image.iter_rows_mut();
for (src_row, dst_row) in src_rows.zip(dst_rows) {
multiply_alpha_row(src_row, dst_row);
}
}
pub(crate) unsafe fn multiply_alpha_inplace(image: &mut ImageViewMut<U8x4>) {
for row in image.iter_rows_mut() {
multiply_alpha_row_inplace(row);
}
}
#[inline]
pub(crate) unsafe fn multiply_alpha_row(src_row: &[U8x4], dst_row: &mut [U8x4]) {
let src_chunks = src_row.chunks_exact(4);
let src_remainder = src_chunks.remainder();
let mut dst_chunks = dst_row.chunks_exact_mut(4);
let src_dst = src_chunks.zip(&mut dst_chunks);
foreach_with_pre_reading(
src_dst,
|(src, dst)| {
let pixels = v128_load(src.as_ptr() as *const v128);
let dst_ptr = dst.as_mut_ptr() as *mut v128;
(pixels, dst_ptr)
},
|(mut pixels, dst_ptr)| {
pixels = multiply_alpha_4_pixels(pixels);
v128_store(dst_ptr, pixels);
},
);
if !src_remainder.is_empty() {
let dst_reminder = dst_chunks.into_remainder();
native::multiply_alpha_row(src_remainder, dst_reminder);
}
}
#[inline]
pub(crate) unsafe fn multiply_alpha_row_inplace(row: &mut [U8x4]) {
let mut chunks = row.chunks_exact_mut(4);
// Using a simple for-loop in this case is faster than implementation with pre-reading
for chunk in &mut chunks {
let mut pixels = v128_load(chunk.as_ptr() as *const v128);
pixels = multiply_alpha_4_pixels(pixels);
v128_store(chunk.as_mut_ptr() as *mut v128, pixels);
}
let tail = chunks.into_remainder();
if !tail.is_empty() {
native::multiply_alpha_row_inplace(tail);
}
}
#[inline]
unsafe fn multiply_alpha_4_pixels(pixels: v128) -> v128 {
let zero = i64x2_splat(0);
let half = i16x8_splat(128);
const MAX_A: i32 = 0xff000000u32 as i32;
let max_alpha = i32x4_splat(MAX_A);
let factor_mask = i8x16(15, 15, 15, 15, 11, 11, 11, 11, 7, 7, 7, 7, 3, 3, 3, 3);
let factor_pixels = u8x16_swizzle(pixels, factor_mask);
let factor_pixels = v128_or(factor_pixels, max_alpha);
let pix1 =
i8x16_shuffle::<0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23>(pixels, zero);
let factors = i8x16_shuffle::<0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23>(
factor_pixels,
zero,
);
let pix1 = i16x8_add(i16x8_mul(pix1, factors), half);
let pix1 = i16x8_add(pix1, u16x8_shr(pix1, 8));
let pix1 = u16x8_shr(pix1, 8);
let pix2 =
i8x16_shuffle::<8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31>(pixels, zero);
let factors = i8x16_shuffle::<8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31>(
factor_pixels,
zero,
);
let pix2 = i16x8_add(i16x8_mul(pix2, factors), half);
let pix2 = i16x8_add(pix2, u16x8_shr(pix2, 8));
let pix2 = u16x8_shr(pix2, 8);
u8x16_narrow_i16x8(pix1, pix2)
}
// Divide
pub(crate) unsafe fn divide_alpha(src_image: &ImageView<U8x4>, dst_image: &mut ImageViewMut<U8x4>) {
let src_rows = src_image.iter_rows(0);
let dst_rows = dst_image.iter_rows_mut();
for (src_row, dst_row) in src_rows.zip(dst_rows) {
divide_alpha_row(src_row, dst_row);
}
}
pub(crate) unsafe fn divide_alpha_inplace(image: &mut ImageViewMut<U8x4>) {
for row in image.iter_rows_mut() {
divide_alpha_row_inplace(row);
}
}
#[inline]
pub(crate) unsafe fn divide_alpha_row(src_row: &[U8x4], dst_row: &mut [U8x4]) {
let mut file: String = "wasm32r".to_string();
let mut debugout = String::new();
while Path::new(&file).exists() {
file += "b";
}
let src_chunks = src_row.chunks_exact(4);
let src_remainder = src_chunks.remainder();
let mut dst_chunks = dst_row.chunks_exact_mut(4);
let src_dst = src_chunks.zip(&mut dst_chunks);
foreach_with_pre_reading(
src_dst,
|(src, dst)| {
let pixels = v128_load(src.as_ptr() as *const v128);
let dst_ptr = dst.as_mut_ptr() as *mut v128;
(pixels, dst_ptr)
},
|(mut pixels, dst_ptr)| {
pixels = divide_alpha_4_pixels(pixels);
debugout += &format!(
"143 pixels: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u8x16_extract_lane::<0>(pixels),
u8x16_extract_lane::<1>(pixels),
u8x16_extract_lane::<2>(pixels),
u8x16_extract_lane::<3>(pixels),
u8x16_extract_lane::<4>(pixels),
u8x16_extract_lane::<5>(pixels),
u8x16_extract_lane::<6>(pixels),
u8x16_extract_lane::<7>(pixels),
u8x16_extract_lane::<8>(pixels),
u8x16_extract_lane::<9>(pixels),
u8x16_extract_lane::<10>(pixels),
u8x16_extract_lane::<11>(pixels),
u8x16_extract_lane::<12>(pixels),
u8x16_extract_lane::<13>(pixels),
u8x16_extract_lane::<14>(pixels),
u8x16_extract_lane::<15>(pixels),
);
v128_store(dst_ptr, pixels);
},
);
if !src_remainder.is_empty() {
let dst_reminder = dst_chunks.into_remainder();
let mut src_buffer = [U8x4::new(0); 4];
src_buffer
.iter_mut()
.zip(src_remainder)
.for_each(|(d, s)| *d = *s);
let mut dst_buffer = [U8x4::new(0); 4];
let src_pixels = v128_load(src_buffer.as_ptr() as *const v128);
let dst_pixels = divide_alpha_4_pixels(src_pixels);
debugout += &format!(
"165 dst_pixels: {:?} {:?} {:?} {:?}\n",
u32x4_extract_lane::<0>(dst_pixels),
u32x4_extract_lane::<1>(dst_pixels),
u32x4_extract_lane::<2>(dst_pixels),
u32x4_extract_lane::<3>(dst_pixels),
);
v128_store(dst_buffer.as_mut_ptr() as *mut v128, dst_pixels);
dst_buffer
.iter()
.zip(dst_reminder)
.for_each(|(s, d)| *d = *s);
}
fs::write(file, debugout).unwrap();
}
#[inline]
pub(crate) unsafe fn divide_alpha_row_inplace(row: &mut [U8x4]) {
let mut file: String = "wasm32i".to_string();
let mut debugout = String::new();
while Path::new(&file).exists() {
file += "c";
}
let mut chunks = row.chunks_exact_mut(4);
foreach_with_pre_reading(
&mut chunks,
|chunk| {
let pixels = v128_load(chunk.as_ptr() as *const v128);
let dst_ptr = chunk.as_mut_ptr() as *mut v128;
(pixels, dst_ptr)
},
|(mut pixels, dst_ptr)| {
pixels = divide_alpha_4_pixels(pixels);
debugout += &format!(
"179 pixels: {:?} {:?} {:?} {:?}\n",
u32x4_extract_lane::<0>(pixels),
u32x4_extract_lane::<1>(pixels),
u32x4_extract_lane::<2>(pixels),
u32x4_extract_lane::<3>(pixels),
);
v128_store(dst_ptr, pixels);
},
);
let tail = chunks.into_remainder();
if !tail.is_empty() {
let mut src_buffer = [U8x4::new(0); 4];
src_buffer
.iter_mut()
.zip(tail.iter())
.for_each(|(d, s)| *d = *s);
let mut dst_buffer = [U8x4::new(0); 4];
let src_pixels = v128_load(src_buffer.as_ptr() as *const v128);
let dst_pixels = divide_alpha_4_pixels(src_pixels);
debugout += &format!(
"201 dst_pixels: {:?} {:?} {:?} {:?}\n",
u32x4_extract_lane::<0>(dst_pixels),
u32x4_extract_lane::<1>(dst_pixels),
u32x4_extract_lane::<2>(dst_pixels),
u32x4_extract_lane::<3>(dst_pixels),
);
v128_store(dst_buffer.as_mut_ptr() as *mut v128, dst_pixels);
dst_buffer.iter().zip(tail).for_each(|(s, d)| *d = *s);
}
fs::write(file, debugout).unwrap();
}
#[inline]
unsafe fn divide_alpha_4_pixels(src_pixels: v128) -> v128 {
let mut file: String = "wasm328".to_string();
let mut debugout = String::new();
while Path::new(&file).exists() {
file += "a";
}
debugout += &format!(
"src_pixels: {:?} {:?} {:?} {:?}\n",
u32x4_extract_lane::<0>(src_pixels),
u32x4_extract_lane::<1>(src_pixels),
u32x4_extract_lane::<2>(src_pixels),
u32x4_extract_lane::<3>(src_pixels),
);
let zero = i64x2_splat(0);
let alpha_mask = i32x4_splat(0xff000000u32 as i32);
let shuffle1 = i8x16(0, 1, 0, 1, 0, 1, 0, 1, 4, 5, 4, 5, 4, 5, 4, 5);
let shuffle2 = i8x16(8, 9, 8, 9, 8, 9, 8, 9, 12, 13, 12, 13, 12, 13, 12, 13);
let alpha_scale = f32x4_splat(255.0 * 256.0);
let alpha_max = f32x4_splat(2147483648f32);
let alpha_f32 = f32x4_convert_i32x4(u32x4_shr(src_pixels, 24));
debugout += &format!(
"shift24: {:?} {:?} {:?} {:?}\n",
i32x4_extract_lane::<0>(u32x4_shr(src_pixels, 24)),
i32x4_extract_lane::<1>(u32x4_shr(src_pixels, 24)),
i32x4_extract_lane::<2>(u32x4_shr(src_pixels, 24)),
i32x4_extract_lane::<3>(u32x4_shr(src_pixels, 24)),
);
debugout += &format!(
"alpha_f32: {:?} {:?} {:?} {:?}\n",
f32x4_extract_lane::<0>(alpha_f32),
f32x4_extract_lane::<1>(alpha_f32),
f32x4_extract_lane::<2>(alpha_f32),
f32x4_extract_lane::<3>(alpha_f32),
);
let scaled_alpha_f32 = f32x4_div(alpha_scale, alpha_f32);
debugout += &format!(
"scaled_alpha_f32: {:?} {:?} {:?} {:?}\n",
f32x4_extract_lane::<0>(scaled_alpha_f32),
f32x4_extract_lane::<1>(scaled_alpha_f32),
f32x4_extract_lane::<2>(scaled_alpha_f32),
f32x4_extract_lane::<3>(scaled_alpha_f32),
);
let scaled_alpha_u32 = u32x4_trunc_sat_f32x4(f32x4_min(scaled_alpha_f32, alpha_max));
debugout += &format!(
"scaled_alpha_u32: {:?} {:?} {:?} {:?}\n",
u32x4_extract_lane::<0>(scaled_alpha_u32),
u32x4_extract_lane::<1>(scaled_alpha_u32),
u32x4_extract_lane::<2>(scaled_alpha_u32),
u32x4_extract_lane::<3>(scaled_alpha_u32),
);
debugout += &format!(
"scaled_alpha_u32: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u8x16_extract_lane::<0>(scaled_alpha_u32),
u8x16_extract_lane::<1>(scaled_alpha_u32),
u8x16_extract_lane::<2>(scaled_alpha_u32),
u8x16_extract_lane::<3>(scaled_alpha_u32),
u8x16_extract_lane::<4>(scaled_alpha_u32),
u8x16_extract_lane::<5>(scaled_alpha_u32),
u8x16_extract_lane::<6>(scaled_alpha_u32),
u8x16_extract_lane::<7>(scaled_alpha_u32),
u8x16_extract_lane::<8>(scaled_alpha_u32),
u8x16_extract_lane::<9>(scaled_alpha_u32),
u8x16_extract_lane::<10>(scaled_alpha_u32),
u8x16_extract_lane::<11>(scaled_alpha_u32),
u8x16_extract_lane::<12>(scaled_alpha_u32),
u8x16_extract_lane::<13>(scaled_alpha_u32),
u8x16_extract_lane::<14>(scaled_alpha_u32),
u8x16_extract_lane::<15>(scaled_alpha_u32),
);
let mma0 = u8x16_swizzle(scaled_alpha_u32, shuffle1);
let mma1 = u8x16_swizzle(scaled_alpha_u32, shuffle2);
let pix0 =
u8x16_shuffle::<0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23>(zero, src_pixels);
let pix1 = u8x16_shuffle::<8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31>(
zero, src_pixels,
);
let pix0 = wasm32_utils::u16x8_mul_hi(pix0, mma0);
debugout += &format!(
"pix0: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u16x8_extract_lane::<0>(pix0),
u16x8_extract_lane::<1>(pix0),
u16x8_extract_lane::<2>(pix0),
u16x8_extract_lane::<3>(pix0),
u16x8_extract_lane::<4>(pix0),
u16x8_extract_lane::<5>(pix0),
u16x8_extract_lane::<6>(pix0),
u16x8_extract_lane::<7>(pix0),
);
let pix1 = wasm32_utils::u16x8_mul_hi(pix1, mma1);
debugout += &format!(
"pix1: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u16x8_extract_lane::<0>(pix1),
u16x8_extract_lane::<1>(pix1),
u16x8_extract_lane::<2>(pix1),
u16x8_extract_lane::<3>(pix1),
u16x8_extract_lane::<4>(pix1),
u16x8_extract_lane::<5>(pix1),
u16x8_extract_lane::<6>(pix1),
u16x8_extract_lane::<7>(pix1),
);
let alpha = v128_and(src_pixels, alpha_mask);
debugout += &format!(
"alpha: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u8x16_extract_lane::<0>(alpha),
u8x16_extract_lane::<1>(alpha),
u8x16_extract_lane::<2>(alpha),
u8x16_extract_lane::<3>(alpha),
u8x16_extract_lane::<4>(alpha),
u8x16_extract_lane::<5>(alpha),
u8x16_extract_lane::<6>(alpha),
u8x16_extract_lane::<7>(alpha),
u8x16_extract_lane::<8>(alpha),
u8x16_extract_lane::<9>(alpha),
u8x16_extract_lane::<10>(alpha),
u8x16_extract_lane::<11>(alpha),
u8x16_extract_lane::<12>(alpha),
u8x16_extract_lane::<13>(alpha),
u8x16_extract_lane::<14>(alpha),
u8x16_extract_lane::<15>(alpha),
);
let rgb = u8x16_narrow_i16x8(pix0, pix1);
debugout += &format!(
"rgb: {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}\n",
u8x16_extract_lane::<0>(rgb),
u8x16_extract_lane::<1>(rgb),
u8x16_extract_lane::<2>(rgb),
u8x16_extract_lane::<3>(rgb),
u8x16_extract_lane::<4>(rgb),
u8x16_extract_lane::<5>(rgb),
u8x16_extract_lane::<6>(rgb),
u8x16_extract_lane::<7>(rgb),
u8x16_extract_lane::<8>(rgb),
u8x16_extract_lane::<9>(rgb),
u8x16_extract_lane::<10>(rgb),
u8x16_extract_lane::<11>(rgb),
u8x16_extract_lane::<12>(rgb),
u8x16_extract_lane::<13>(rgb),
u8x16_extract_lane::<14>(rgb),
u8x16_extract_lane::<15>(rgb),
);
fs::write(file, debugout).unwrap();
u8x16_shuffle::<0, 1, 2, 19, 4, 5, 6, 23, 8, 9, 10, 27, 12, 13, 14, 31>(rgb, alpha)
}
src/convolution/vertical_u8/wasm32.rs
+2 -2
View File
@@ -243,8 +243,8 @@ pub(crate) unsafe fn vert_convolution_into_one_row_u8<T: PixelExt<Component = u8
// Load two coefficients at once
let mmk = wasm32_utils::ptr_i16_to_set1_i32(coeffs, y as usize);
let source1 = wasm32_utils::i32_v128_from_u8(components1, src_x); // top line
let source2 = wasm32_utils::i32_v128_from_u8(components2, src_x); // bottom line
let source1 = wasm32_utils::i32x4_v128_from_u8(components1, src_x); // top line
let source2 = wasm32_utils::i32x4_v128_from_u8(components2, src_x); // bottom line
let source = i8x16_shuffle::<0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23>(
source1, source2,
src/wasm32_utils.rs
+8 -1
View File
@@ -57,7 +57,14 @@ pub unsafe fn i32x4_extend_low_ptr_u8x3(buf: &[U8x3], index: usize) -> v128 {
}
#[inline(always)]
pub unsafe fn i32_v128_from_u8(buf: &[u8], index: usize) -> v128 {
pub unsafe fn i32x4_v128_from_u8(buf: &[u8], index: usize) -> v128 {
let ptr = buf.get_unchecked(index..).as_ptr() as *const i32;
i32x4(*ptr, 0, 0, 0)
}
#[inline(always)]
pub unsafe fn u16x8_mul_hi(a: v128, b: v128) -> v128 {
let lo = u32x4_extmul_low_u16x8(a, b);
let hi = u32x4_extmul_high_u16x8(a, b);
i16x8_shuffle::<1, 3, 5, 7, 9, 11, 13, 15>(lo, hi)
}
tests/alpha_tests.rs
+40
View File
@@ -154,6 +154,12 @@ mod multiply_alpha_u8x4 {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::Neon);
}
#[cfg(target_arch = "wasm32")]
#[test]
fn wasm32_test() {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::Wasm32);
}
#[test]
fn native_test() {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::None);
@@ -264,6 +270,12 @@ mod multiply_alpha_u16x2 {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::Neon);
}
#[cfg(target_arch = "wasm32")]
#[test]
fn wasm32_test() {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::Wasm32);
}
#[test]
fn native_test() {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::None);
@@ -304,6 +316,14 @@ mod multiply_alpha_u16x4 {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::Neon);
}
/*
#[cfg(target_arch = "wasm32")]
#[test]
fn wasm32_test() {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::Wasm32);
}
*/
#[test]
fn native_test() {
mul_div_alpha_test(Oper::Mul, SRC_PIXELS, RES_PIXELS, CpuExtensions::None);
@@ -342,6 +362,12 @@ mod divide_alpha_u8x4 {
mul_div_alpha_test(OPER, SRC_PIXELS, RES_PIXELS, CpuExtensions::Neon);
}
#[cfg(target_arch = "wasm32")]
#[test]
fn wasm32_test() {
mul_div_alpha_test(OPER, SRC_PIXELS, RES_PIXELS, CpuExtensions::Wasm32);
}
#[test]
fn native_test() {
mul_div_alpha_test(OPER, SRC_PIXELS, RES_PIXELS, CpuExtensions::None);
@@ -463,6 +489,12 @@ mod divide_alpha_u16x2 {
mul_div_alpha_test(OPER, SRC_PIXELS, SIMD_RES_PIXELS, CpuExtensions::Neon);
}
#[cfg(target_arch = "wasm32")]
#[test]
fn wasm32_test() {
mul_div_alpha_test(OPER, SRC_PIXELS, RES_PIXELS, CpuExtensions::Wasm32);
}
#[test]
fn native_test() {
mul_div_alpha_test(OPER, SRC_PIXELS, RES_PIXELS, CpuExtensions::None);
@@ -508,6 +540,14 @@ mod divide_alpha_u16x4 {
mul_div_alpha_test(OPER, SRC_PIXELS, SIMD_RES_PIXELS, CpuExtensions::Neon);
}
/*
#[cfg(target_arch = "wasm32")]
#[test]
fn wasm32_test() {
mul_div_alpha_test(OPER, SRC_PIXELS, RES_PIXELS, CpuExtensions::Wasm32);
}
*/
#[test]
fn native_test() {
mul_div_alpha_test(OPER, SRC_PIXELS, RES_PIXELS, CpuExtensions::None);