singe-npp 0.1.0-alpha.8

Safe Rust wrappers for NVIDIA Performance Primitives library (NPP).
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

use super::*;

impl_filter_wiener_border!(
    filter_wiener_border_u8_c1,
    u8,
    C1,
    1,
    nppiFilterWienerBorder_8u_C1R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_u8_c3,
    u8,
    C3,
    3,
    nppiFilterWienerBorder_8u_C3R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_u8_c4,
    u8,
    C4,
    4,
    nppiFilterWienerBorder_8u_C4R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_u8_ac4,
    u8,
    AC4,
    3,
    nppiFilterWienerBorder_8u_AC4R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_i16_c1,
    i16,
    C1,
    1,
    nppiFilterWienerBorder_16s_C1R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_i16_c3,
    i16,
    C3,
    3,
    nppiFilterWienerBorder_16s_C3R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_i16_c4,
    i16,
    C4,
    4,
    nppiFilterWienerBorder_16s_C4R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_i16_ac4,
    i16,
    AC4,
    3,
    nppiFilterWienerBorder_16s_AC4R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_f32_c1,
    f32,
    C1,
    1,
    nppiFilterWienerBorder_32f_C1R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_f32_c3,
    f32,
    C3,
    3,
    nppiFilterWienerBorder_32f_C3R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_f32_c4,
    f32,
    C4,
    4,
    nppiFilterWienerBorder_32f_C4R_Ctx
);
impl_filter_wiener_border!(
    filter_wiener_border_f32_ac4,
    f32,
    AC4,
    3,
    nppiFilterWienerBorder_32f_AC4R_Ctx
);

pub trait FilterWienerBorder<L: ChannelLayout, const N: usize>: DataTypeLike {
    fn filter_wiener_border(
        stream_context: &StreamContext,
        source: &ImageView<'_, Self, L>,
        source_offset: Point,
        destination: &mut ImageViewMut<'_, Self, L>,
        mask_size: Size,
        anchor: Point,
        noise: &mut [f32; N],
        border_type: BorderType,
    ) -> Result<()>;
}

macro_rules! impl_filter_wiener_border_dispatch {
    ($pixel_ty:ty, $layout:ty, $noise_len:expr, $name:ident) => {
        impl FilterWienerBorder<$layout, $noise_len> for $pixel_ty {
            fn filter_wiener_border(
                stream_context: &StreamContext,
                source: &ImageView<'_, Self, $layout>,
                source_offset: Point,
                destination: &mut ImageViewMut<'_, Self, $layout>,
                mask_size: Size,
                anchor: Point,
                noise: &mut [f32; $noise_len],
                border_type: BorderType,
            ) -> Result<()> {
                $name(
                    stream_context,
                    source,
                    source_offset,
                    destination,
                    mask_size,
                    anchor,
                    noise,
                    border_type,
                )
            }
        }
    };
}

impl_filter_wiener_border_dispatch!(u8, C1, 1, filter_wiener_border_u8_c1);
impl_filter_wiener_border_dispatch!(u8, C3, 3, filter_wiener_border_u8_c3);
impl_filter_wiener_border_dispatch!(u8, C4, 4, filter_wiener_border_u8_c4);
impl_filter_wiener_border_dispatch!(u8, AC4, 3, filter_wiener_border_u8_ac4);
impl_filter_wiener_border_dispatch!(i16, C1, 1, filter_wiener_border_i16_c1);
impl_filter_wiener_border_dispatch!(i16, C3, 3, filter_wiener_border_i16_c3);
impl_filter_wiener_border_dispatch!(i16, C4, 4, filter_wiener_border_i16_c4);
impl_filter_wiener_border_dispatch!(i16, AC4, 3, filter_wiener_border_i16_ac4);
impl_filter_wiener_border_dispatch!(f32, C1, 1, filter_wiener_border_f32_c1);
impl_filter_wiener_border_dispatch!(f32, C3, 3, filter_wiener_border_f32_c3);
impl_filter_wiener_border_dispatch!(f32, C4, 4, filter_wiener_border_f32_c4);
impl_filter_wiener_border_dispatch!(f32, AC4, 3, filter_wiener_border_f32_ac4);

pub fn filter_wiener_border<T, L, const N: usize>(
    stream_context: &StreamContext,
    source: &ImageView<'_, T, L>,
    source_offset: Point,
    destination: &mut ImageViewMut<'_, T, L>,
    mask_size: Size,
    anchor: Point,
    noise: &mut [f32; N],
    border_type: BorderType,
) -> Result<()>
where
    T: FilterWienerBorder<L, N>,
    L: ChannelLayout,
{
    T::filter_wiener_border(
        stream_context,
        source,
        source_offset,
        destination,
        mask_size,
        anchor,
        noise,
        border_type,
    )
}