mkaudiolibrary 2.1.0

Modular audio processing library including MKAU plugin format based on Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! ARM NEON SIMD backend — 4-wide f32 using float32x4_t.
//!
//! Enabled with `--features neon` on aarch64 targets.

#[cfg(target_arch = "aarch64")]
use core::arch::aarch64::*;

use super::traits::SimdFloat;

/// 4-wide f32 SIMD type using ARM NEON.
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct F32x4(#[cfg(target_arch = "aarch64")] float32x4_t);

#[cfg(target_arch = "aarch64")]
impl SimdFloat for F32x4 {
    const WIDTH: usize = 4;

    #[inline(always)]
    unsafe fn load(ptr: *const f32) -> Self {
        F32x4(unsafe { vld1q_f32(ptr) })
    }

    #[inline(always)]
    unsafe fn store(self, ptr: *mut f32) {
        unsafe { vst1q_f32(ptr, self.0) };
    }

    #[inline(always)]
    fn splat(v: f32) -> Self {
        F32x4(unsafe { vdupq_n_f32(v) })
    }

    #[inline(always)]
    fn add(self, rhs: Self) -> Self {
        F32x4(unsafe { vaddq_f32(self.0, rhs.0) })
    }

    #[inline(always)]
    fn sub(self, rhs: Self) -> Self {
        F32x4(unsafe { vsubq_f32(self.0, rhs.0) })
    }

    #[inline(always)]
    fn mul(self, rhs: Self) -> Self {
        F32x4(unsafe { vmulq_f32(self.0, rhs.0) })
    }

    #[inline(always)]
    fn div(self, rhs: Self) -> Self {
        F32x4(unsafe { vdivq_f32(self.0, rhs.0) })
    }

    #[inline(always)]
    fn fma(self, b: Self, c: Self) -> Self {
        F32x4(unsafe { vfmaq_f32(c.0, self.0, b.0) })
    }

    #[inline(always)]
    fn max(self, rhs: Self) -> Self {
        F32x4(unsafe { vmaxq_f32(self.0, rhs.0) })
    }

    #[inline(always)]
    fn min(self, rhs: Self) -> Self {
        F32x4(unsafe { vminq_f32(self.0, rhs.0) })
    }

    #[inline(always)]
    fn abs(self) -> Self {
        F32x4(unsafe { vabsq_f32(self.0) })
    }

    #[inline(always)]
    fn neg(self) -> Self {
        F32x4(unsafe { vnegq_f32(self.0) })
    }

    #[inline(always)]
    fn cmp_ge(self, rhs: Self) -> Self {
        let mask = unsafe { vcgeq_f32(self.0, rhs.0) };
        F32x4(unsafe { vreinterpretq_f32_u32(mask) })
    }

    #[inline(always)]
    fn blend(mask: Self, a: Self, b: Self) -> Self {
        let mask_u32 = unsafe { vreinterpretq_u32_f32(mask.0) };
        F32x4(unsafe { vbslq_f32(mask_u32, a.0, b.0) })
    }

    #[inline(always)]
    fn first(self) -> f32 {
        unsafe { vgetq_lane_f32(self.0, 0) }
    }
}