sim-lib-view-daw 0.1.2

DAW timeline, mixer, plugin rack, and synth lenses for SIM Web.
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

//! Stream inspector Scene builders.

use sim_kernel::{Expr, Symbol};
use sim_lib_scene::{data_map, node, sym};
use sim_lib_stream_core::{StreamInspectorSnapshot, StreamItem, StreamPacket};
use sim_value::build::uint;

/// Stable lens id for the stream list view.
pub const STREAM_LIST_VIEW_ID: &str = "view:stream-list";
/// Stable lens id for the single-stream detail view.
pub const STREAM_DETAIL_VIEW_ID: &str = "view:stream-detail";
/// Stable lens id for the stream packet preview table.
pub const STREAM_PACKET_PREVIEW_VIEW_ID: &str = "view:stream-packet-preview";
/// Stable lens id for the stream diagnostic timeline.
pub const STREAM_DIAGNOSTIC_TIMELINE_VIEW_ID: &str = "view:stream-diagnostic-timeline";

/// Builds the stream list Scene from inspector snapshots.
pub fn stream_list_view(streams: &[StreamInspectorSnapshot]) -> Expr {
    node(
        "stack",
        vec![
            ("lens", sym(STREAM_LIST_VIEW_ID)),
            ("role", sym("stream-list")),
            ("dir", sym("column")),
            (
                "streams",
                Expr::List(streams.iter().map(stream_row).collect()),
            ),
        ],
    )
}

/// Builds the detail Scene for a single stream snapshot.
pub fn stream_detail_view(stream: &StreamInspectorSnapshot) -> Expr {
    node(
        "box",
        vec![
            ("lens", sym(STREAM_DETAIL_VIEW_ID)),
            ("role", sym("stream-detail")),
            ("id", Expr::Symbol(stream.stream_id.clone())),
            ("route", Expr::Symbol(stream.route.clone())),
            ("media", Expr::Symbol(stream.media.symbol())),
            ("profile", Expr::Symbol(stream.profile.clone())),
            ("clock", Expr::Symbol(stream.clock.clone())),
            ("status", Expr::Symbol(stream.status.symbol())),
            ("queue-depth", uint(stream.queue_depth as u64)),
            ("dropped", uint(stream.dropped_count)),
            (
                "last-sequence",
                stream.last_sequence.map(uint).unwrap_or(Expr::Nil),
            ),
        ],
    )
}

/// Builds the packet preview table Scene from stream items.
pub fn stream_packet_preview_view(items: &[StreamItem]) -> Expr {
    node(
        "table",
        vec![
            ("lens", sym(STREAM_PACKET_PREVIEW_VIEW_ID)),
            ("role", sym("stream-packet-preview")),
            (
                "packets",
                Expr::List(
                    items
                        .iter()
                        .enumerate()
                        .map(|(index, item)| {
                            data_map(vec![
                                ("index", uint(index as u64)),
                                ("media", Expr::Symbol(item.packet().media().symbol())),
                                ("packet-kind", Expr::Symbol(packet_kind(item.packet()))),
                                ("ticks", uint(item.ticks().len() as u64)),
                            ])
                        })
                        .collect(),
                ),
            ),
        ],
    )
}

/// Builds the diagnostic timeline Scene for a stream snapshot.
pub fn stream_diagnostic_timeline_view(stream: &StreamInspectorSnapshot) -> Expr {
    node(
        "timeline",
        vec![
            ("lens", sym(STREAM_DIAGNOSTIC_TIMELINE_VIEW_ID)),
            ("role", sym("stream-diagnostic-timeline")),
            ("stream", Expr::Symbol(stream.stream_id.clone())),
            (
                "diagnostics",
                Expr::List(
                    stream
                        .recent_diagnostics
                        .iter()
                        .cloned()
                        .map(Expr::Symbol)
                        .collect(),
                ),
            ),
        ],
    )
}

fn stream_row(stream: &StreamInspectorSnapshot) -> Expr {
    data_map(vec![
        ("id", Expr::Symbol(stream.stream_id.clone())),
        ("route", Expr::Symbol(stream.route.clone())),
        ("media", Expr::Symbol(stream.media.symbol())),
        ("profile", Expr::Symbol(stream.profile.clone())),
        ("clock", Expr::Symbol(stream.clock.clone())),
        ("status", Expr::Symbol(stream.status.symbol())),
        ("queue-depth", uint(stream.queue_depth as u64)),
        ("dropped", uint(stream.dropped_count)),
    ])
}

fn packet_kind(packet: &StreamPacket) -> Symbol {
    match packet {
        StreamPacket::Pcm(_) => Symbol::qualified("stream/packet", "pcm"),
        StreamPacket::Midi(_) => Symbol::qualified("stream/packet", "midi"),
        StreamPacket::Diagnostic(diagnostic) => diagnostic.kind().clone(),
        StreamPacket::Data(data) => data.kind.clone(),
    }
}