tixonome 0.3.0

A simple CLI metronome in Rust
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

/*  Copyright (c) 2021, Momozor <momozor4@gmail.com>
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree.
 */

use rodio::source::{SineWave, Source};
use rodio::{OutputStream, OutputStreamHandle, Sink};
use simple_logger::SimpleLogger;
use std::process;
use std::time::Duration;
use structopt::StructOpt;

#[derive(Debug, StructOpt)]
struct Opt {
    #[structopt(short, default_value = "80")]
    beats_per_minute: u32,
    #[structopt(short = "a", default_value = "4")]
    beats_per_bar: u8,
}

fn main() {
    SimpleLogger::new().init().unwrap();

    let (_stream, stream_handle) = OutputStream::try_default().unwrap_or_else(|error| {
        log::error!("Cannot open output stream.\n More info: {}", error);
        process::exit(1);
    });

    run(Opt::from_args(), &stream_handle);
}

fn play_sound(stream_handle: &OutputStreamHandle, is_accent: bool) {
    let low_pitch = 440;
    let amplification = 0.20;
    let beep_duration = 0.050;

    let sink = Sink::try_new(stream_handle).unwrap_or_else(|error| {
        log::error!("Cannot open sink stream!\n More info: {}", error);
        process::exit(1);
    });

    let small_hertz_leap = 40;
    let medium_pitch = low_pitch + small_hertz_leap;
    let source = SineWave::new(match is_accent {
        true => medium_pitch,
        _ => low_pitch,
    })
    .take_duration(Duration::from_secs_f32(beep_duration))
    .amplify(amplification);

    sink.append(source);
    sink.sleep_until_end();
}

fn is_bpm_valid(opt: &Opt) -> bool {
    let minimum = 40;
    let maximum = 180;
    
    opt.beats_per_minute >= minimum && opt.beats_per_minute <= maximum
}

fn is_bpb_valid(opt: &Opt) -> bool {
    let minimum = 2;
    let maximum = 4;
    
    opt.beats_per_bar >= minimum && opt.beats_per_bar <= maximum
}

fn run(opt: Opt, stream_handle: &OutputStreamHandle) {
    if !is_bpm_valid(&opt) {
        log::error!("Beats per minute must be in range of 40 to 180");
        process::exit(1);
    }
    if !is_bpb_valid(&opt) {
        log::error!("Beats per bar must be in range of 2 to 4");
        process::exit(1);
    }
    
    let minute = 60.0;
    let duration = minute / opt.beats_per_minute as f32;
    let mut counter: u8 = 0;

    println!("Ctrl+C to quit");
    loop {
        counter += 1;
        if counter % opt.beats_per_bar as u8 != 0 {
            play_sound(stream_handle, false);
        } else {
            play_sound(stream_handle, true);
            counter = 0;
        }
        
        std::thread::sleep(Duration::from_secs_f32(duration));
    }
}