resample 0.1.1

A library based on libsamplerate for converting samplerates
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

use std::ffi::CStr;

use libsamplerate_rs::src_get_description;
use libsamplerate_rs::src_get_name;
use libsamplerate_rs::SRC_LINEAR;
use libsamplerate_rs::SRC_SINC_BEST_QUALITY;
use libsamplerate_rs::SRC_SINC_FASTEST;
use libsamplerate_rs::SRC_SINC_MEDIUM_QUALITY;
use libsamplerate_rs::SRC_ZERO_ORDER_HOLD;


/// The resampler type used to distinguish the interpolation function
/// used by `libsamplerate`.
///
/// Has a great impact on quality and performance.
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum ResampleType {
    SincBestQuality = SRC_SINC_BEST_QUALITY as isize,
    SincMediumQuality = SRC_SINC_MEDIUM_QUALITY as isize,
    SincFastest = SRC_SINC_FASTEST as isize,
    ZeroOrderHold = SRC_ZERO_ORDER_HOLD as isize,
    Linear = SRC_LINEAR as isize,
}

impl ResampleType {
    /// Return a human-readable name for this type of resampler.
    pub fn name(&self) -> &'static str {
        // SAFETY: `src_get_name` is always safe to call.
        let ptr = unsafe { src_get_name(*self as i32) };
        // SANITY: `src_get_name` always returns a valid pointer for a
        //         valid convert and we only have known convert types.
        assert!(!ptr.is_null());

        // SAFETY: `ptr` is not NULL and guaranteed to be valid.
        unsafe { CStr::from_ptr(ptr) }.to_str().unwrap()
    }

    /// Return the human-readable description for this type of resampler.
    pub fn description(&self) -> &'static str {
        // SAFETY: `src_get_description` is always safe to call.
        let ptr = unsafe { src_get_description(*self as i32) };
        // SANITY: `src_get_description` always returns a valid pointer
        //         for a valid convert and we only have known convert
        //         types.
        assert!(!ptr.is_null());

        // SAFETY: `ptr` is not NULL and guaranteed to be valid.
        unsafe { CStr::from_ptr(ptr) }.to_str().unwrap()
    }
}


#[cfg(test)]
mod tests {
    use super::*;


    #[test]
    fn name() {
        assert_eq!(
            ResampleType::SincBestQuality.name(),
            "Best Sinc Interpolator"
        );
        assert_eq!(
            ResampleType::SincMediumQuality.name(),
            "Medium Sinc Interpolator"
        );
        assert_eq!(
            ResampleType::SincFastest.name(),
            "Fastest Sinc Interpolator"
        );
        assert_eq!(ResampleType::ZeroOrderHold.name(), "ZOH Interpolator");
        assert_eq!(ResampleType::Linear.name(), "Linear Interpolator");
    }

    #[test]
    fn description() {
        assert_eq!(
            ResampleType::SincBestQuality.description(),
            "Band limited sinc interpolation, best quality, 144dB SNR, 96% BW."
        );
        assert_eq!(
            ResampleType::SincMediumQuality.description(),
            "Band limited sinc interpolation, medium quality, 121dB SNR, 90% BW."
        );
        assert_eq!(
            ResampleType::SincFastest.description(),
            "Band limited sinc interpolation, fastest, 97dB SNR, 80% BW."
        );
        assert_eq!(
            ResampleType::ZeroOrderHold.description(),
            "Zero order hold interpolator, very fast, poor quality."
        );
        assert_eq!(
            ResampleType::Linear.description(),
            "Linear interpolator, very fast, poor quality."
        );
    }
}