voxr 0.4.0

Audio and speech: codecs, DSP, G2P, voices, and TTS/ASR pipelines over boostr models
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

//! PCM sample formats the tempo stretcher reads and writes.

mod sealed {
    pub trait Sealed {}
    impl Sealed for f32 {}
    impl Sealed for i16 {}
}

/// A PCM sample format [`atempo_interleaved`](super::atempo_interleaved)
/// accepts: `f32` for float samples, `i16` for signed 16-bit PCM.
///
/// The format decides two things. The crossfade result rounds to it: `i16`
/// truncates toward zero and saturates at the type's range, `f32` keeps the
/// float. And when channels compete for the alignment signal, each sample's
/// magnitude counts up to [`PcmSample::CEILING`] only.
pub trait PcmSample: Copy + Default + sealed::Sealed {
    /// Largest magnitude a sample counts with when the loudest channel is
    /// picked for alignment: `1.0` for `f32`, `32767.0` for `i16`.
    const CEILING: f32;

    /// The sample as `f32`, unscaled: an `i16` of 1000 reads as `1000.0`.
    fn to_f32(self) -> f32;

    /// The format's value nearest `value` by truncation, saturating.
    fn from_f32(value: f32) -> Self;
}

impl PcmSample for f32 {
    const CEILING: f32 = 1.0;

    fn to_f32(self) -> f32 {
        self
    }

    fn from_f32(value: f32) -> Self {
        value
    }
}

impl PcmSample for i16 {
    const CEILING: f32 = i16::MAX as f32;

    fn to_f32(self) -> f32 {
        f32::from(self)
    }

    fn from_f32(value: f32) -> Self {
        // `as` truncates toward zero and saturates at the i16 range.
        value as i16
    }
}

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

    #[test]
    fn i16_truncates_toward_zero_and_saturates() {
        assert_eq!(i16::from_f32(12.9), 12);
        assert_eq!(i16::from_f32(-12.9), -12);
        assert_eq!(i16::from_f32(40_000.0), i16::MAX);
        assert_eq!(i16::from_f32(-40_000.0), i16::MIN);
        assert_eq!((-7i16).to_f32(), -7.0);
    }

    #[test]
    fn f32_passes_through() {
        assert_eq!(f32::from_f32(0.25), 0.25);
        assert_eq!((-0.5f32).to_f32(), -0.5);
    }
}