atradio 0.1.0

atradio.fm in your terminal — a TUI radio player on the AT Protocol
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
166
167
168

//! The Rockbox DSP chain, modelled to match the web app's audio settings
//! (`apps/web/src/atoms/audioSettings.ts` + `fm.atradio.audio.settings`).

use rockbox_playback::{
    BassEnhancement, ChannelMode, Compressor, Crossfeed, CrossfeedMode, EqBand, Equalizer, Player,
    Surround, ToneControls, EQ_BAND_FREQUENCIES, EQ_BANDS,
};

/// Band centre frequencies (Hz), from the engine: 32 … 16 000.
pub const EQ_FREQS: [i32; EQ_BANDS] = EQ_BAND_FREQUENCIES;

/// The full user-facing DSP state. Defaults mirror `DEFAULT_AUDIO_SETTINGS`.
#[derive(Clone, Debug)]
pub struct AudioSettings {
    pub eq_enabled: bool,
    /// Per-band gain in dB (−24 … 24), one per [`EQ_BANDS`].
    pub eq_gains: [f32; EQ_BANDS],
    pub bass: i32,   // dB
    pub treble: i32, // dB
    pub crossfeed_mode: CrossfeedMode,
    pub crossfeed_direct: f32, // dB (≤ 0)
    pub pbe: i32,              // 0 … 100 %
    pub pbe_precut: i32,      // dB cut (≥ 0)
    pub surround_delay: i32,  // ms (0 = off)
    pub surround_balance: i32, // %
    pub comp_threshold: i32,  // dB (0 = off)
    pub comp_ratio: i32,      // 2 … 10
    pub channel_mode: ChannelMode,
    pub stereo_width: i32, // %
}

impl Default for AudioSettings {
    fn default() -> Self {
        Self {
            eq_enabled: false,
            eq_gains: [0.0; EQ_BANDS],
            bass: 0,
            treble: 0,
            crossfeed_mode: CrossfeedMode::Off,
            crossfeed_direct: -1.5,
            pbe: 0,
            pbe_precut: 0,
            surround_delay: 0,
            surround_balance: 35,
            comp_threshold: 0,
            comp_ratio: 2,
            channel_mode: ChannelMode::Stereo,
            stereo_width: 100,
        }
    }
}

impl AudioSettings {
    /// Push the whole chain to the engine. Safe to call live.
    pub fn apply(&self, p: &Player) {
        // Equalizer.
        p.set_eq_enabled(self.eq_enabled);
        for (i, &gain) in self.eq_gains.iter().enumerate() {
            p.set_eq_band(
                i,
                EqBand {
                    cutoff_hz: EQ_FREQS[i],
                    q: 1.0,
                    gain_db: gain,
                },
            );
        }
        // Tone.
        p.set_tone(ToneControls {
            bass_db: self.bass,
            treble_db: self.treble,
            bass_cutoff_hz: 0,
            treble_cutoff_hz: 0,
        });
        // Crossfeed (direct gain is in tenths of a dB).
        p.set_crossfeed(Crossfeed {
            mode: self.crossfeed_mode,
            direct_gain: (self.crossfeed_direct * 10.0).round() as i32,
            ..Default::default()
        });
        // Perceptual bass enhancement (precut is tenths of a dB, ≤ 0).
        p.set_bass_enhancement(BassEnhancement {
            strength: self.pbe,
            precut: -(self.pbe_precut * 10),
        });
        // Haas surround.
        p.set_surround(Surround {
            delay_ms: self.surround_delay,
            balance: self.surround_balance,
            cutoff_low_hz: 0,
            cutoff_high_hz: 0,
        });
        // Compressor.
        p.set_compressor(Compressor {
            threshold_db: self.comp_threshold,
            makeup_gain: 1,
            ratio: ratio_index(self.comp_ratio),
            knee: 2,
            attack_ms: 5,
            release_ms: 200,
        });
        // Channel / stereo width.
        p.set_channel_mode(self.channel_mode);
        p.set_stereo_width(self.stereo_width);
    }

    /// Build the full [`Equalizer`] value (for one-shot pushes).
    pub fn equalizer(&self) -> Equalizer {
        Equalizer {
            enabled: self.eq_enabled,
            precut_db: 0.0,
            bands: self
                .eq_gains
                .iter()
                .enumerate()
                .map(|(i, &g)| EqBand {
                    cutoff_hz: EQ_FREQS[i],
                    q: 1.0,
                    gain_db: g,
                })
                .collect(),
        }
    }
}

/// Map a plain N:1 ratio to the engine's ratio index.
fn ratio_index(ratio: i32) -> i32 {
    match ratio {
        r if r <= 2 => 0, // 2:1
        r if r <= 4 => 1, // 4:1
        r if r <= 6 => 2, // 6:1
        _ => 3,           // 10:1
    }
}

/// The DSP "rows" shown in the equalizer/settings panel, in order.
pub const CROSSFEED_MODES: [CrossfeedMode; 3] =
    [CrossfeedMode::Off, CrossfeedMode::Meier, CrossfeedMode::Custom];

pub const CHANNEL_MODES: [ChannelMode; 7] = [
    ChannelMode::Stereo,
    ChannelMode::Mono,
    ChannelMode::Custom,
    ChannelMode::MonoLeft,
    ChannelMode::MonoRight,
    ChannelMode::Karaoke,
    ChannelMode::Swap,
];

pub fn crossfeed_label(m: CrossfeedMode) -> &'static str {
    match m {
        CrossfeedMode::Off => "Off",
        CrossfeedMode::Meier => "Meier",
        CrossfeedMode::Custom => "Custom",
    }
}

pub fn channel_label(m: ChannelMode) -> &'static str {
    match m {
        ChannelMode::Stereo => "Stereo",
        ChannelMode::Mono => "Mono",
        ChannelMode::Custom => "Custom",
        ChannelMode::MonoLeft => "Mono L",
        ChannelMode::MonoRight => "Mono R",
        ChannelMode::Karaoke => "Karaoke",
        ChannelMode::Swap => "Swap",
    }
}