jack 0.13.5

Real time audio and midi with JACK.
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

use std::env;

fn main() {
    let (client, _status) =
        jack::Client::new("rust_jack_trans", jack::ClientOptions::default()).unwrap();

    let transport = client.transport();

    let usage = || {
        let commands = [
            "start",
            "stop",
            "bpm <value>",
            "sig <numerator> <denominator>",
            "locate <bar> <beat> <tick>",
        ];
        println!("usage:");
        for cmd in commands.iter() {
            println!("\t {} {}", env::args().next().unwrap(), cmd);
        }
    };

    if env::args().len() == 1 {
        usage();
    } else {
        let jack::TransportStatePosition { mut pos, state: _ } =
            transport.query().expect("failed to query transport");

        let mut bbt = pos.bbt().unwrap_or_default();
        pos.set_frame(pos.frame() + 44100);

        let mut new_bbt = None;
        let mut args = env::args().skip(1);
        let cmd = args.next().expect("failed to get command");
        match cmd.as_str() {
            "start" => transport.start().expect("failed to start"),
            "stop" => transport.stop().expect("failed to stop"),
            "bpm" => {
                new_bbt = Some(
                    bbt.with_bpm(
                        args.next()
                            .expect("failed to get bpm value")
                            .parse::<f64>()
                            .expect("failed to convert"),
                    ),
                );
            }
            "locate" => {
                new_bbt = Some(
                    bbt.with_bbt(
                        args.next()
                            .expect("failed to get bar value")
                            .parse::<usize>()
                            .expect("failed to convert"),
                        args.next()
                            .expect("failed to get beat value")
                            .parse::<usize>()
                            .expect("failed to convert"),
                        args.next()
                            .expect("failed to get tick value")
                            .parse::<usize>()
                            .expect("failed to convert"),
                    ),
                );
            }
            "sig" => {
                new_bbt = Some(
                    bbt.with_timesig(
                        args.next()
                            .expect("failed to get timesig numerator")
                            .parse::<f32>()
                            .expect("failed to convert"),
                        args.next()
                            .expect("failed to get timesig denominator")
                            .parse::<f32>()
                            .expect("failed to convert"),
                    ),
                );
            }
            c => {
                println!("unknown command {c}");
                usage();
                return;
            }
        };

        if let Some(bbt) = new_bbt {
            let bbt = bbt.validated().expect("transport bbt failed to validate");
            pos.set_bbt(Some(bbt)).expect("error setting bbt");
            transport.reposition(&pos).expect("failed to reposition");
        }
    }
}