nnapi 0.2.0

Provides a safe abstraction of the Android NNAPI FFI bindings.
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

use std::{
    ffi::c_void,
    mem::size_of,
    ops::{Deref, DerefMut},
    ptr::{null_mut, NonNull},
};

use nnapi_sys::{
    ANeuralNetworksEvent, ANeuralNetworksExecution, ANeuralNetworksExecution_burstCompute,
    ANeuralNetworksExecution_create, ANeuralNetworksExecution_free,
    ANeuralNetworksExecution_setInput, ANeuralNetworksExecution_setOutput,
    ANeuralNetworksExecution_startCompute, ResultCode,
};

use crate::{Burst, Compilation, Event, IntoResult};

pub struct Execution {
    inner: NonNull<ANeuralNetworksExecution>,
}

impl Execution {
    pub fn new(compilation: &mut Compilation) -> crate::Result<Self> {
        let mut execution = null_mut();

        unsafe { ANeuralNetworksExecution_create(&mut **compilation, &mut execution) }
            .into_result()?;

        Ok(Execution {
            inner: NonNull::new(execution).ok_or(ResultCode::ANEURALNETWORKS_UNEXPECTED_NULL)?,
        })
    }

    #[inline]
    pub fn set_input<T>(&mut self, input_list_idx: i32, input: &[T]) -> crate::Result<()> {
        unsafe {
            self.set_input_raw(
                input_list_idx,
                input.as_ptr().cast(),
                input.len() * size_of::<T>(),
            )
        }
    }

    #[inline]
    pub unsafe fn set_input_raw(
        &mut self,
        input_list_idx: i32,
        buffer: *const c_void,
        length: usize,
    ) -> crate::Result<()> {
        ANeuralNetworksExecution_setInput(&mut **self, input_list_idx, null_mut(), buffer, length)
            .into_result()
    }

    #[inline]
    pub fn set_output<T>(&mut self, output_list_idx: i32, output: &mut [T]) -> crate::Result<()> {
        unsafe {
            self.set_output_raw(
                output_list_idx,
                output.as_mut_ptr().cast(),
                output.len() * size_of::<T>(),
            )
        }
    }

    #[inline]
    pub unsafe fn set_output_raw(
        &mut self,
        output_list_idx: i32,
        buffer: *mut c_void,
        length: usize,
    ) -> crate::Result<()> {
        unsafe {
            ANeuralNetworksExecution_setOutput(
                &mut **self,
                output_list_idx,
                null_mut(),
                buffer,
                length,
            )
        }
        .into_result()
    }

    #[inline]
    pub fn compute(&mut self) -> crate::Result<Event> {
        let mut end_event: *mut ANeuralNetworksEvent = null_mut();
        unsafe { ANeuralNetworksExecution_startCompute(&mut **self, &mut end_event) }
            .into_result()?;

        Ok(Event {
            inner: NonNull::new(end_event).ok_or(ResultCode::ANEURALNETWORKS_UNEXPECTED_NULL)?,
        })
    }

    #[inline]
    pub fn burst_compute(&mut self, burst: &mut Burst) -> crate::Result<()> {
        unsafe { ANeuralNetworksExecution_burstCompute(&mut **self, &mut **burst) }.into_result()
    }
}

impl Deref for Execution {
    type Target = ANeuralNetworksExecution;

    #[inline]
    fn deref(&self) -> &Self::Target {
        unsafe { self.inner.as_ref() }
    }
}

impl DerefMut for Execution {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { self.inner.as_mut() }
    }
}

impl Drop for Execution {
    fn drop(&mut self) {
        unsafe {
            ANeuralNetworksExecution_free(self.inner.as_mut());
        }
    }
}