tunein-cli 0.6.0

Browse and listen to thousands of radio stations across the globe right from your terminal 🌎 📻 🎵✨
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

use std::{num::ParseIntError, str::FromStr};

#[derive(Debug, PartialEq, Clone)]
pub enum Tone {
    C,
    Db,
    D,
    Eb,
    E,
    F,
    Gb,
    G,
    Ab,
    A,
    Bb,
    B,
}

#[derive(Debug, thiserror::Error, derive_more::Display)]
pub struct ToneError();

#[derive(Debug, PartialEq, Clone)]
pub struct Note {
    tone: Tone,
    octave: u32,
}

#[derive(Debug, thiserror::Error, derive_more::From, derive_more::Display)]
pub enum NoteError {
    InvalidOctave(ParseIntError),
    InalidNote(ToneError),
}

impl FromStr for Note {
    type Err = NoteError;

    fn from_str(txt: &str) -> Result<Self, Self::Err> {
        let trimmed = txt.trim();
        let mut split = 0;
        for c in trimmed.chars() {
            if !c.is_ascii_digit() {
                split += 1;
            } else {
                break;
            }
        }
        Ok(Note {
            tone: trimmed[..split].parse::<Tone>()?,
            octave: trimmed[split..].parse::<u32>().unwrap_or(0),
        })
    }
}

impl FromStr for Tone {
    type Err = ToneError;

    fn from_str(txt: &str) -> Result<Self, Self::Err> {
        match txt {
            "C" => Ok(Tone::C),
            "C#" | "Db" => Ok(Tone::Db),
            "D" => Ok(Tone::D),
            "D#" | "Eb" => Ok(Tone::Eb),
            "E" => Ok(Tone::E),
            "F" => Ok(Tone::F),
            "F#" | "Gb" => Ok(Tone::Gb),
            "G" => Ok(Tone::G),
            "G#" | "Ab" => Ok(Tone::Ab),
            "A" => Ok(Tone::A),
            "A#" | "Bb" => Ok(Tone::Bb),
            "B" => Ok(Tone::B),
            _ => Err(ToneError()),
        }
    }
}

impl Note {
    pub fn tune_buffer_size(&self, sample_rate: u32) -> u32 {
        let t = 1.0 / self.tone.freq(self.octave); // periodo ?
        let buf = (sample_rate as f32) * t;
        buf.round() as u32
    }
}

impl Tone {
    pub fn freq(&self, octave: u32) -> f32 {
        match octave {
            0 => match self {
                Tone::C => 16.35,
                Tone::Db => 17.32,
                Tone::D => 18.35,
                Tone::Eb => 19.45,
                Tone::E => 20.60,
                Tone::F => 21.83,
                Tone::Gb => 23.12,
                Tone::G => 24.50,
                Tone::Ab => 25.96,
                Tone::A => 27.50,
                Tone::Bb => 29.14,
                Tone::B => 30.87,
            },
            _ => {
                let mut freq = self.freq(0);
                for _ in 0..octave {
                    freq *= 2.0;
                }
                freq
            }
        }
    }
}