Skip to main content

apple_accelerate/ffi/
mod.rs

1#![allow(missing_docs, non_camel_case_types, non_upper_case_globals)]
2
3use core::ffi::c_void;
4
5pub type vDSP_Length = usize;
6pub type vDSP_Stride = isize;
7pub type FFTDirection = i32;
8pub type FFTRadix = i32;
9
10pub enum OpaqueFFTSetup {}
11pub type FFTSetup = *mut OpaqueFFTSetup;
12
13pub enum vDSP_biquad_SetupStruct {}
14pub type vDSP_biquad_Setup = *mut vDSP_biquad_SetupStruct;
15
16#[repr(C)]
17pub struct DSPSplitComplex {
18    pub realp: *mut f32,
19    pub imagp: *mut f32,
20}
21
22pub type CBLAS_ORDER = i32;
23pub type CBLAS_TRANSPOSE = i32;
24
25pub type vImagePixelCount = u64;
26pub type vImage_Error = isize;
27pub type vImage_Flags = u32;
28pub type Pixel_8888 = [u8; 4];
29
30#[repr(C)]
31pub struct vImage_Buffer {
32    pub data: *mut c_void,
33    pub height: vImagePixelCount,
34    pub width: vImagePixelCount,
35    pub row_bytes: usize,
36}
37
38pub type BNNSFilter = *mut c_void;
39
40#[link(name = "Accelerate", kind = "framework")]
41unsafe extern "C" {
42    pub fn vDSP_create_fftsetup(log2n: vDSP_Length, radix: FFTRadix) -> FFTSetup;
43    pub fn vDSP_destroy_fftsetup(setup: FFTSetup);
44    pub fn vDSP_fft_zip(
45        setup: FFTSetup,
46        split_complex: *const DSPSplitComplex,
47        stride: vDSP_Stride,
48        log2n: vDSP_Length,
49        direction: FFTDirection,
50    );
51
52    pub fn vDSP_biquad_CreateSetup(
53        coefficients: *const f64,
54        sections: vDSP_Length,
55    ) -> vDSP_biquad_Setup;
56    pub fn vDSP_biquad_DestroySetup(setup: vDSP_biquad_Setup);
57    pub fn vDSP_biquad(
58        setup: vDSP_biquad_Setup,
59        delay: *mut f32,
60        input: *const f32,
61        input_stride: vDSP_Stride,
62        output: *mut f32,
63        output_stride: vDSP_Stride,
64        length: vDSP_Length,
65    );
66
67    pub fn vDSP_vadd(
68        a: *const f32,
69        a_stride: vDSP_Stride,
70        b: *const f32,
71        b_stride: vDSP_Stride,
72        c: *mut f32,
73        c_stride: vDSP_Stride,
74        length: vDSP_Length,
75    );
76    pub fn vDSP_vsub(
77        b: *const f32,
78        b_stride: vDSP_Stride,
79        a: *const f32,
80        a_stride: vDSP_Stride,
81        c: *mut f32,
82        c_stride: vDSP_Stride,
83        length: vDSP_Length,
84    );
85    pub fn vDSP_dotpr(
86        a: *const f32,
87        a_stride: vDSP_Stride,
88        b: *const f32,
89        b_stride: vDSP_Stride,
90        result: *mut f32,
91        length: vDSP_Length,
92    );
93    pub fn vDSP_maxv(input: *const f32, stride: vDSP_Stride, result: *mut f32, length: vDSP_Length);
94    pub fn vDSP_minv(input: *const f32, stride: vDSP_Stride, result: *mut f32, length: vDSP_Length);
95    pub fn vDSP_meanv(
96        input: *const f32,
97        stride: vDSP_Stride,
98        result: *mut f32,
99        length: vDSP_Length,
100    );
101    pub fn vDSP_sve(input: *const f32, stride: vDSP_Stride, result: *mut f32, length: vDSP_Length);
102    pub fn vDSP_hamm_window(output: *mut f32, length: vDSP_Length, flags: i32);
103    pub fn vDSP_blkman_window(output: *mut f32, length: vDSP_Length, flags: i32);
104
105    pub fn cblas_sdot(n: i32, x: *const f32, inc_x: i32, y: *const f32, inc_y: i32) -> f32;
106    pub fn cblas_sgemv(
107        order: CBLAS_ORDER,
108        transpose: CBLAS_TRANSPOSE,
109        m: i32,
110        n: i32,
111        alpha: f32,
112        a: *const f32,
113        lda: i32,
114        x: *const f32,
115        inc_x: i32,
116        beta: f32,
117        y: *mut f32,
118        inc_y: i32,
119    );
120    pub fn cblas_sgemm(
121        order: CBLAS_ORDER,
122        transpose_a: CBLAS_TRANSPOSE,
123        transpose_b: CBLAS_TRANSPOSE,
124        m: i32,
125        n: i32,
126        k: i32,
127        alpha: f32,
128        a: *const f32,
129        lda: i32,
130        b: *const f32,
131        ldb: i32,
132        beta: f32,
133        c: *mut f32,
134        ldc: i32,
135    );
136
137    pub fn vImageRotate_ARGB8888(
138        src: *const vImage_Buffer,
139        dest: *const vImage_Buffer,
140        temp_buffer: *mut c_void,
141        angle_in_radians: f32,
142        background_color: *const u8,
143        flags: vImage_Flags,
144    ) -> vImage_Error;
145    pub fn vImageBoxConvolve_ARGB8888(
146        src: *const vImage_Buffer,
147        dest: *const vImage_Buffer,
148        temp_buffer: *mut c_void,
149        src_offset_to_roi_x: vImagePixelCount,
150        src_offset_to_roi_y: vImagePixelCount,
151        kernel_height: u32,
152        kernel_width: u32,
153        background_color: *const u8,
154        flags: vImage_Flags,
155    ) -> vImage_Error;
156    pub fn vImageScale_ARGB8888(
157        src: *const vImage_Buffer,
158        dest: *const vImage_Buffer,
159        temp_buffer: *mut c_void,
160        flags: vImage_Flags,
161    ) -> vImage_Error;
162    pub fn vImageContrastStretch_Planar8(
163        src: *const vImage_Buffer,
164        dest: *const vImage_Buffer,
165        flags: vImage_Flags,
166    ) -> vImage_Error;
167
168    pub fn BNNSFilterCreateLayerConvolution(
169        layer_params: *const c_void,
170        filter_params: *const c_void,
171    ) -> BNNSFilter;
172    pub fn BNNSFilterCreateLayerFullyConnected(
173        layer_params: *const c_void,
174        filter_params: *const c_void,
175    ) -> BNNSFilter;
176    pub fn BNNSFilterApply(filter: BNNSFilter, input: *const c_void, output: *mut c_void) -> i32;
177    pub fn BNNSFilterDestroy(filter: BNNSFilter);
178}