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

use singe_npp_sys as sys;

use crate::{
    context::StreamContext,
    error::{Error, Result},
    signal::view::{SignalView, SignalViewMut},
    try_ffi,
    types::DataTypeLike,
    utility::{to_u64, to_usize},
    workspace::ScratchBuffer,
};

pub(crate) fn integral_i32_buffer_size(source: &SignalView<'_, i32>) -> Result<usize> {
    let mut bytes = 0;
    let len = source
        .len()
        .checked_add(1)
        .ok_or_else(|| Error::OutOfRange { name: "len".into() })?;
    let raw_len = to_u64(len, "len")?;
    unsafe {
        try_ffi!(sys::nppsIntegralGetBufferSize_32s(raw_len, &raw mut bytes,))?;
    }
    to_usize(bytes, "scratch bytes")
}

pub(crate) fn integral_i32_with_scratch(
    stream_context: &StreamContext,
    source: &SignalView<'_, i32>,
    destination: &mut SignalViewMut<'_, i32>,
    scratch: &mut ScratchBuffer,
) -> Result<()> {
    validate_integral_destination_len(source, destination)?;
    let required_bytes = integral_i32_buffer_size(source)?;
    scratch.require(required_bytes)?;

    unsafe {
        try_ffi!(sys::nppsIntegral_32s_Ctx(
            source.as_ptr(),
            destination.as_mut_ptr(),
            to_u64(destination.len(), "destination length")?,
            scratch.as_mut_ptr(),
            stream_context.as_raw(),
        ))?;
    }
    Ok(())
}

pub trait Integral: DataTypeLike {
    fn integral_buffer_size(source: &SignalView<'_, Self>) -> Result<usize>;

    fn integral_with_scratch(
        stream_context: &StreamContext,
        source: &SignalView<'_, Self>,
        destination: &mut SignalViewMut<'_, Self>,
        scratch: &mut ScratchBuffer,
    ) -> Result<()>;
}

impl Integral for i32 {
    fn integral_buffer_size(source: &SignalView<'_, Self>) -> Result<usize> {
        integral_i32_buffer_size(source)
    }

    fn integral_with_scratch(
        stream_context: &StreamContext,
        source: &SignalView<'_, Self>,
        destination: &mut SignalViewMut<'_, Self>,
        scratch: &mut ScratchBuffer,
    ) -> Result<()> {
        integral_i32_with_scratch(stream_context, source, destination, scratch)
    }
}

pub fn integral_buffer_size<T: Integral>(source: &SignalView<'_, T>) -> Result<usize> {
    T::integral_buffer_size(source)
}

pub fn integral_with_scratch<T: Integral>(
    stream_context: &StreamContext,
    source: &SignalView<'_, T>,
    destination: &mut SignalViewMut<'_, T>,
    scratch: &mut ScratchBuffer,
) -> Result<()> {
    T::integral_with_scratch(stream_context, source, destination, scratch)
}

pub fn integral<T: Integral>(
    stream_context: &StreamContext,
    source: &SignalView<'_, T>,
    destination: &mut SignalViewMut<'_, T>,
) -> Result<()> {
    let required_bytes = integral_buffer_size(source)?;
    let mut scratch = ScratchBuffer::create(required_bytes)?;
    integral_with_scratch(stream_context, source, destination, &mut scratch)
}

fn validate_integral_destination_len<T>(
    source: &SignalView<'_, T>,
    destination: &SignalViewMut<'_, T>,
) -> Result<()> {
    let expected = source
        .len()
        .checked_add(1)
        .ok_or_else(|| Error::OutOfRange { name: "len".into() })?;
    if destination.len() != expected {
        return Err(Error::LengthMismatch {
            name: "destination".into(),
            expected,
            actual: destination.len(),
        });
    }

    Ok(())
}