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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::{
    ops::{Deref, DerefMut},
    ptr::{null_mut, NonNull},
};

use nnapi_sys::{
    ANeuralNetworksModel, ANeuralNetworksModel_addOperand, ANeuralNetworksModel_addOperation,
    ANeuralNetworksModel_create, ANeuralNetworksModel_finish, ANeuralNetworksModel_free,
    ANeuralNetworksModel_identifyInputsAndOutputs, ANeuralNetworksModel_setOperandValue,
    OperationCode, ResultCode, ANEURALNETWORKS_FUSED_NONE,
};

use crate::{
    error::{IntoResult, Result},
    Compilation, Operand,
};

pub struct Model {
    pub model: NonNull<ANeuralNetworksModel>,
}

impl Model {
    pub fn new() -> Result<Self> {
        let mut model: *mut ANeuralNetworksModel = null_mut();

        unsafe { ANeuralNetworksModel_create(&mut model) }.into_result()?;

        let model = NonNull::new(model).ok_or(ResultCode::ANEURALNETWORKS_UNEXPECTED_NULL)?;

        Ok(Self { model })
    }

    pub fn from_operands(operands: impl IntoIterator<Item = Operand>) -> Result<Self> {
        let mut model = Model::new()?;
        for operand in operands.into_iter() {
            model.add_operand(&operand)?;
        }

        Ok(model)
    }

    #[inline]
    pub fn add_operand(&mut self, operand: &Operand) -> Result<()> {
        unsafe { ANeuralNetworksModel_addOperand(self.model.as_mut(), &operand.inner) }
            .into_result()
    }

    // TODO:: add set operand value for buffers

    #[inline]
    pub fn set_activation_operand_value(&mut self, activation_idx: i32) -> Result<()> {
        let none_value = ANEURALNETWORKS_FUSED_NONE;
        unsafe {
            ANeuralNetworksModel_setOperandValue(
                &mut **self,
                activation_idx,
                &none_value as *const _ as *const _,
                4,
            )
        }
        .into_result()
    }

    #[inline]
    pub fn add_operation(
        &mut self,
        operation: OperationCode,
        inputs: &[u32],
        outputs: &[u32],
    ) -> Result<()> {
        unsafe {
            ANeuralNetworksModel_addOperation(
                &mut **self,
                operation as i32,
                inputs.len().try_into().unwrap(),
                inputs.as_ptr(),
                outputs.len().try_into().unwrap(),
                outputs.as_ptr(),
            )
        }
        .into_result()
    }

    pub fn identify_inputs_and_outputs(&mut self, inputs: &[u32], outputs: &[u32]) -> Result<()> {
        unsafe {
            ANeuralNetworksModel_identifyInputsAndOutputs(
                &mut **self,
                inputs.len().try_into().unwrap(),
                inputs.as_ptr(),
                outputs.len().try_into().unwrap(),
                outputs.as_ptr(),
            )
        }
        .into_result()
    }

    #[inline]
    pub fn finish(&mut self) -> Result<()> {
        unsafe { ANeuralNetworksModel_finish(&mut **self) }.into_result()
    }

    #[inline]
    pub fn compile(&mut self) -> Result<Compilation> {
        Compilation::new(self)
    }
}

impl Deref for Model {
    type Target = ANeuralNetworksModel;

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

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

impl Drop for Model {
    fn drop(&mut self) {
        unsafe { ANeuralNetworksModel_free(self.model.as_mut()) };
    }
}

#[cfg(test)]
mod tests {
    use crate::{error::Result, Model};

    #[test]
    fn test_compile() -> Result<()> {
        let mut model = Model::new()?;

        Ok(())
    }
}