soundchip 0.4.61

Software sinth with configurable channels for authentic sounding virtual sound chips.
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

use crate::prelude::KnotValue;
use core::{
    fmt::{Display, Formatter},
    u16,
};

/// Stored internally as u16, allows converting to/from a 0.0 to 1.0 f32 range.
/// Any f32 value outside of this range will be clipped.
#[derive(Clone, Copy, Default)]
pub struct Normal(u16);

const MAX: f32 = u16::MAX as f32;

impl Normal {
    pub const ZERO: Self = Self(0);
    pub const QUARTER: Self = Self(u16::MAX / 4);
    pub const HALF: Self = Self(u16::MAX / 2);
    pub const THREE_QUARTER: Self = Self((u16::MAX / 4) * 3);
    pub const ONE: Self = Self(u16::MAX);
}

/// Returns an f32 value between -1.0 and 1.0 (inclusive).
impl Into<f32> for Normal {
    fn into(self) -> f32 {
        self.0 as f32 / MAX
    }
}

/// Will clamp values outside valid range of 0.0 to 1.0.
impl From<f32> for Normal {
    fn from(value: f32) -> Self {
        let clamped = (value.clamp(0.0, 1.0) * MAX) as u16;
        Self(clamped)
    }
}

impl Display for Normal {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        let n = self.0 as f32 / MAX;
        f.write_fmt(format_args!("{}", n))
    }
}

impl core::fmt::Debug for Normal {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        let n = self.0 as f32 / MAX;
        f.write_fmt(format_args!("Normal({})", n))
    }
}

impl PartialEq for Normal {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}

impl KnotValue for Normal {}

#[test]
fn normal_value_clip() {
    let a = -0.5;
    let a_normal = Normal::from(a);
    let a_converted: f32 = a_normal.into();
    assert_eq!(a_converted, 0.0); // clipped to 0.0

    let a = 1.5;
    let a_normal = Normal::from(a);
    let a_converted: f32 = a_normal.into();
    assert_eq!(a_converted, 1.0); // clipped to 1.0
}

#[test]
// NOT lossless, tiny changes can occur.
// Good up to about 5 decimals.
fn normal_value_precision() {
    for n in 0..10 {
        let a = n as f32 / 10.0;
        let a_normal = Normal::from(a);
        let a_converted: f32 = a_normal.into();
        assert!((a_converted - a).abs() < 0.00001);
    }
}