owl_patch 0.8.0

Rust SDK for Rebel Technology Owl2/3 devices
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

//! FFT instances using CMSIS via FFI. Use the [ProgramVector] instance to create an fft processor.
//! See the [vocoder] example for more
//!
//! [ProgramVector]: crate::program_vector::ProgramVector
//! [vocoder]: https://github.com/orukusaki/owl_patch/blob/main/examples/src/bin/vocoder.rs
use cmsis_dsp_sys_pregenerated::{
    arm_cfft_f32, arm_cfft_instance_f32, arm_rfft_fast_f32, arm_rfft_fast_instance_f32,
};
use num::Complex;

/// FFT Size.
///
/// <div class="warning">Avoid Size128 for RealFFT, as it seems to be broken in the current device firmware</div>
#[derive(Clone, Copy)]
#[repr(usize)]
pub enum FftSize {
    /// FFT Size 32
    Size32 = 32,
    /// FFT Size 64
    Size64 = 64,
    /// FFT Size 28
    Size128 = 128,
    /// FFT Size 56
    Size256 = 256,
    /// FFT Size 12
    Size512 = 512,
    /// FFT Size 24
    Size1024 = 1024,
    /// FFT Size 48
    Size2048 = 2048,
    /// FFT Size 96
    Size4096 = 4096,
}

/// Real FFT Processor - a wrapper around arm_rfft_fast_instance_f32.
///
/// Create using [ProgramVector::fft_real()]
///
/// [ProgramVector::fft_real()]: crate::program_vector::ProgramVector::fft_real
pub struct RealFft {
    instance: arm_rfft_fast_instance_f32,
}

impl RealFft {
    pub(crate) fn new(instance: arm_rfft_fast_instance_f32) -> Self {
        Self { instance }
    }
    /// FFT Size in real samples
    pub fn real_size(&self) -> usize {
        self.instance.fftLenRFFT as usize
    }
    /// Complex size: real_size() / 2
    pub fn complex_size(&self) -> usize {
        (self.instance.fftLenRFFT / 2) as usize
    }
    /// Perform forward FFT transform.
    ///
    /// The length of `src` must be >= the Real Fft Length
    /// `dest` must have a length >= the complex size (real size / 2)
    pub fn fft(&self, src: &mut [f32], dest: &mut [Complex<f32>]) {
        assert!(src.len() >= self.real_size(), "Input slice too small");
        assert!(dest.len() >= self.complex_size(), "Output slice too small");

        unsafe {
            arm_rfft_fast_f32(
                &self.instance as *const arm_rfft_fast_instance_f32,
                src.as_mut_ptr(),
                dest.as_mut_ptr() as *mut f32,
                0,
            );
        }
    }
    /// Perform inverse FFT transform
    ///
    /// The length of `src` must be >= the complex size (real size / 2)
    /// `dest` must have a length >= the Real Fft Length
    pub fn ifft(&self, src: &mut [Complex<f32>], dest: &mut [f32]) {
        assert!(src.len() >= self.complex_size(), "Input slice too small");
        assert!(dest.len() >= self.real_size(), "Output slice too small");

        unsafe {
            arm_rfft_fast_f32(
                &self.instance as *const arm_rfft_fast_instance_f32,
                src.as_mut_ptr() as *mut f32,
                dest.as_mut_ptr(),
                1,
            );
        }
    }
}

impl Clone for RealFft {
    fn clone(&self) -> Self {
        Self {
            instance: arm_rfft_fast_instance_f32 {
                Sint: arm_cfft_instance_f32 {
                    fftLen: self.instance.Sint.fftLen,
                    pTwiddle: self.instance.Sint.pTwiddle,
                    pBitRevTable: self.instance.Sint.pBitRevTable,
                    bitRevLength: self.instance.Sint.bitRevLength,
                },

                fftLenRFFT: self.instance.fftLenRFFT,
                pTwiddleRFFT: self.instance.pTwiddleRFFT,
            },
        }
    }
}

unsafe impl Send for RealFft {}
unsafe impl Sync for RealFft {}

/// Real Complex Processor - a wrapper around arm_cfft_instance_f32.
///
/// Create using [ProgramVector::fft_complex()]
///
/// [ProgramVector::fft_complex()]: crate::program_vector::ProgramVector::fft_complex
pub struct ComplexFft {
    instance: arm_cfft_instance_f32,
}

impl ComplexFft {
    pub(crate) fn new(instance: arm_cfft_instance_f32) -> Self {
        Self { instance }
    }
    /// FFT Size
    pub fn size(&self) -> usize {
        self.instance.fftLen as usize
    }
    /// Perform forward FFT transform
    pub fn fft(&self, buff: &mut [Complex<f32>]) {
        assert!(buff.len() >= self.size(), "Input slice too small");

        unsafe {
            arm_cfft_f32(
                &self.instance as *const arm_cfft_instance_f32,
                buff.as_mut_ptr() as *mut f32,
                0,
                0,
            );
        }
    }
    /// Perform inverse FFT transform
    pub fn ifft(&self, buff: &mut [Complex<f32>]) {
        assert!(buff.len() >= self.size(), "Input slice too small");

        unsafe {
            arm_cfft_f32(
                &self.instance as *const arm_cfft_instance_f32,
                buff.as_mut_ptr() as *mut f32,
                1,
                0,
            );
        }
    }
}

impl Clone for ComplexFft {
    fn clone(&self) -> Self {
        Self {
            instance: arm_cfft_instance_f32 {
                fftLen: self.instance.fftLen,
                pTwiddle: self.instance.pTwiddle,
                pBitRevTable: self.instance.pBitRevTable,
                bitRevLength: self.instance.bitRevLength,
            },
        }
    }
}

unsafe impl Send for ComplexFft {}
unsafe impl Sync for ComplexFft {}