ksynth 0.18.0

Patch manipulation for Kawai digital synths
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

//! Data model for the pitch envelope.
//!

use std::fmt;

use crate::{
    SystemExclusiveData,
    ParseError
};
use crate::k5000::{
    PitchEnvelopeLevel,
    PitchEnvelopeTime,
    VelocitySensitivity
};

/// Pitch envelope.
#[derive(Debug)]
pub struct Envelope {
    /// Envelope start level.
    pub start: PitchEnvelopeLevel,

    /// Envelope attack time.
    pub attack_time: PitchEnvelopeTime,

    /// Envelope attack level.
    pub attack_level: PitchEnvelopeLevel,

    /// Envelope decay time.
    pub decay_time: PitchEnvelopeTime,

    /// Time velocity sensitivity.
    pub time_vel_sens: VelocitySensitivity,

    /// Level velocity sensitivity.
    pub level_vel_sens: VelocitySensitivity,
}

impl Envelope {
    /// Creates a new envelope with default values.
    pub fn new() -> Envelope {
        Envelope {
            start: PitchEnvelopeLevel::new(0),
            attack_time: PitchEnvelopeTime::new(0),
            attack_level: PitchEnvelopeLevel::new(0),
            decay_time: PitchEnvelopeTime::new(0),
            time_vel_sens: VelocitySensitivity::new(0),
            level_vel_sens: VelocitySensitivity::new(0),
        }
    }
}

impl Default for Envelope {
    fn default() -> Self {
        Self::new()
    }
}

impl fmt::Display for Envelope {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Start Level={} Attack Time={} Attack Level={} Decay Time={}\nVelocity to: Level={} Time={}\n",
            self.start, self.attack_time, self.attack_level, self.decay_time, self.level_vel_sens, self.time_vel_sens
        )
    }
}

impl SystemExclusiveData for Envelope {
    fn from_bytes(data: &[u8]) -> Result<Self, ParseError> {
        Ok(Envelope {
            start: PitchEnvelopeLevel::from(data[0]),
            attack_time: PitchEnvelopeTime::from(data[1]),
            attack_level: PitchEnvelopeLevel::from(data[2]),
            decay_time: PitchEnvelopeTime::from(data[3]),
            time_vel_sens: VelocitySensitivity::from(data[4]),
            level_vel_sens: VelocitySensitivity::from(data[5]),
        })
    }

    fn to_bytes(&self) -> Vec<u8> {
        vec![
            self.start.into(),
            self.attack_time.into(),
            self.attack_level.into(),
            self.decay_time.into(),
            self.time_vel_sens.into(),
            self.level_vel_sens.into()
        ]
    }

    fn data_size() -> usize { 6 }
}