rknpu2 0.0.9

Unofficial bindings to rknpu2 (librknnrt and librknnmrt)
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

use {
    crate::{
        query::{Io, QueryWithInput, TensorAttrView},
        tensor::{DataTypeKind, QuantTypeKind, TensorFormatKind},
    },
    rknpu2_sys::rknn_tensor_attr,
    std::ffi::CStr,
};

pub struct NativeNC1HWC2OutputAttr {
    pub(crate) inner: rknn_tensor_attr,
}

impl QueryWithInput for NativeNC1HWC2OutputAttr {
    const QUERY_TYPE: rknpu2_sys::_rknn_query_cmd::Type =
        rknpu2_sys::_rknn_query_cmd::RKNN_QUERY_NATIVE_NC1HWC2_OUTPUT_ATTR;

    type Input = u32;
    type Output = rknn_tensor_attr;

    fn prepare(input: Self::Input, output: &mut Self::Output) {
        output.index = input;
    }
}

impl From<rknn_tensor_attr> for NativeNC1HWC2OutputAttr {
    fn from(attr: rknn_tensor_attr) -> Self {
        Self { inner: attr }
    }
}

impl TensorAttrView for NativeNC1HWC2OutputAttr {
    fn io(&self) -> Io {
        Io::Output
    }

    fn index(&self) -> u32 {
        self.inner.index
    }

    fn num_dims(&self) -> u32 {
        self.inner.n_dims
    }

    fn dims(&self) -> &[u32] {
        &self.inner.dims[..self.inner.n_dims as usize]
    }

    fn name(&self) -> String {
        let cstr = unsafe { CStr::from_ptr(self.inner.name.as_ptr()) };
        cstr.to_string_lossy().into_owned()
    }

    fn num_elements(&self) -> u32 {
        self.inner.n_elems
    }

    fn size(&self) -> u32 {
        self.inner.size
    }

    fn format(&self) -> TensorFormatKind {
        self.inner.fmt.into()
    }

    fn dtype(&self) -> DataTypeKind {
        self.inner.type_.into()
    }

    fn qnt_type(&self) -> QuantTypeKind {
        self.inner.qnt_type.into()
    }

    fn fl(&self) -> i8 {
        self.inner.fl
    }

    fn scale(&self) -> f32 {
        self.inner.scale
    }

    fn zero_point(&self) -> i32 {
        self.inner.zp
    }

    fn h_stride(&self) -> u32 {
        self.inner.h_stride
    }

    fn w_stride(&self) -> u32 {
        self.inner.w_stride
    }

    fn size_with_stride(&self) -> u32 {
        self.inner.size_with_stride
    }
}