sim-lib-music-core 0.1.0

SIM workspace package for sim lib music core.
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use num_rational::Ratio;
use sim_kernel::{Expr, Symbol};
use sim_lib_midi_core::U7;

use crate::{
    Articulation, AutomationCell, Channel, ControlChangeCell, DrumCell, LaneId, LaneKind, Music,
    Note, ObjectCell, PerformanceEvent, PerformanceIntent, PerformanceTake, PianoRoll,
    PianoRollCell, PianoRollLane, ScaleDegreeCell, Tick, TimedNote,
};

fn note(midi: u8) -> Note {
    Note::new(
        Ratio::new(1, 4),
        crate::Pitch::from_midi(midi),
        100,
        Channel::new(0).expect("channel"),
        Articulation::Normal,
    )
    .expect("note")
}

fn tick(ticks: i64) -> Tick {
    Tick::new(ticks, 480).expect("tick")
}

#[test]
fn piano_roll_lanes_keep_supported_cell_families() {
    let channel = Channel::new(0).expect("channel");
    let roll = PianoRoll::from_lanes(vec![
        PianoRollLane::new(
            LaneId::new("notes"),
            LaneKind::Note,
            vec![PianoRollCell::Note(TimedNote {
                onset: Ratio::new(1, 4),
                note: note(64),
            })],
        )
        .expect("note lane"),
        PianoRollLane::new(
            LaneId::new("drums"),
            LaneKind::Drum,
            vec![PianoRollCell::Drum(DrumCell {
                onset: Ratio::new(0, 1),
                duration: Ratio::new(1, 8),
                key: U7(36),
                velocity: U7(100),
                channel,
            })],
        )
        .expect("drum lane"),
        PianoRollLane::new(
            LaneId::new("scale"),
            LaneKind::ScaleDegree,
            vec![PianoRollCell::ScaleDegree(ScaleDegreeCell {
                onset: Ratio::new(1, 2),
                duration: Ratio::new(1, 8),
                degree: 5,
                octave: 0,
                velocity: U7(96),
                channel,
            })],
        )
        .expect("scale lane"),
        PianoRollLane::new(
            LaneId::new("objects"),
            LaneKind::Object,
            vec![PianoRollCell::Object(ObjectCell {
                onset: Ratio::new(3, 4),
                duration: Ratio::new(1, 4),
                object: Symbol::qualified("music/playable", "phrase"),
            })],
        )
        .expect("object lane"),
        PianoRollLane::new(
            LaneId::new("automation"),
            LaneKind::Automation,
            vec![PianoRollCell::Automation(AutomationCell {
                time: Ratio::new(1, 8),
                target: Symbol::qualified("music/param", "cutoff"),
                value: 42,
            })],
        )
        .expect("automation lane"),
        PianoRollLane::new(
            LaneId::new("control"),
            LaneKind::Control,
            vec![PianoRollCell::ControlChange(ControlChangeCell {
                time: Ratio::new(1, 8),
                channel,
                controller: U7(74),
                value: U7(64),
            })],
        )
        .expect("control lane"),
    ])
    .expect("roll");

    assert_eq!(roll.lanes.len(), 6);
    assert_eq!(roll.items.len(), 2);
    assert_eq!(roll.items[0].note.pitch.to_midi(), Some(36));
    assert_eq!(roll.items[1].note.pitch.to_midi(), Some(64));
    assert!(matches!(roll.to_expr(), Expr::Map(entries) if entries.len() == 4));
}

#[test]
fn lane_kind_mismatch_is_rejected() {
    let err = PianoRollLane::new(
        LaneId::new("wrong"),
        LaneKind::Control,
        vec![PianoRollCell::Note(TimedNote {
            onset: Ratio::new(0, 1),
            note: note(60),
        })],
    )
    .expect_err("mismatch");

    assert!(matches!(
        err,
        crate::MusicError::PianoRollLaneCellMismatch { .. }
    ));
}

#[test]
fn captured_performance_take_imports_as_editable_cells() {
    let channel = Channel::new(0).expect("channel");
    let take = PerformanceTake::new(
        Symbol::qualified("music/performance-source", "keyboard"),
        Symbol::qualified("music/performance-take", "take-1"),
        vec![
            PerformanceEvent {
                lane_id: LaneId::new("perf"),
                source_id: Symbol::qualified("music/performance-source", "keyboard"),
                input_time: tick(0),
                time: tick(0),
                intent: PerformanceIntent::NoteOn {
                    pitch: crate::Pitch::from_midi(60),
                    velocity: 100,
                    channel,
                },
            },
            PerformanceEvent {
                lane_id: LaneId::new("perf"),
                source_id: Symbol::qualified("music/performance-source", "keyboard"),
                input_time: tick(120),
                time: tick(120),
                intent: PerformanceIntent::NoteOff {
                    pitch: crate::Pitch::from_midi(60),
                    velocity: 64,
                    channel,
                },
            },
        ],
    )
    .expect("take");

    let roll = PianoRoll::from_performance_take(&take).expect("roll");
    assert_eq!(roll.items.len(), 1);
    assert_eq!(roll.lanes[0].id.as_ref(), "performance-notes");
    assert_eq!(roll.items[0].note.duration, Ratio::new(1, 16));

    let Music::PianoRoll(clip) = take.as_clip().expect("clip") else {
        panic!("expected piano-roll clip");
    };
    assert_eq!(clip, roll);
}