239 lines
7.3 KiB
Rust
239 lines
7.3 KiB
Rust
//! 32-band frequency spectrum display with optional peak hold.
|
|
|
|
use crate::theme;
|
|
use ratatui::buffer::Buffer;
|
|
use ratatui::layout::Rect;
|
|
use ratatui::style::Color;
|
|
use ratatui::widgets::Widget;
|
|
use std::cell::RefCell;
|
|
|
|
const BLOCKS: [char; 8] = ['\u{2581}', '\u{2582}', '\u{2583}', '\u{2584}', '\u{2585}', '\u{2586}', '\u{2587}', '\u{2588}'];
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Default)]
|
|
pub enum SpectrumStyle {
|
|
#[default]
|
|
Bars,
|
|
Line,
|
|
Filled,
|
|
}
|
|
|
|
thread_local! {
|
|
static PEAKS: RefCell<[f32; 32]> = const { RefCell::new([0.0; 32]) };
|
|
static PATTERNS: RefCell<Vec<u8>> = const { RefCell::new(Vec::new()) };
|
|
}
|
|
|
|
/// 32-band spectrum analyzer using block characters.
|
|
pub struct Spectrum<'a> {
|
|
data: &'a [f32; 32],
|
|
gain: f32,
|
|
style: SpectrumStyle,
|
|
peaks: bool,
|
|
}
|
|
|
|
impl<'a> Spectrum<'a> {
|
|
pub fn new(data: &'a [f32; 32]) -> Self {
|
|
Self {
|
|
data,
|
|
gain: 1.0,
|
|
style: SpectrumStyle::Bars,
|
|
peaks: false,
|
|
}
|
|
}
|
|
|
|
pub fn gain(mut self, g: f32) -> Self {
|
|
self.gain = g;
|
|
self
|
|
}
|
|
|
|
pub fn style(mut self, s: SpectrumStyle) -> Self {
|
|
self.style = s;
|
|
self
|
|
}
|
|
|
|
pub fn peaks(mut self, enabled: bool) -> Self {
|
|
self.peaks = enabled;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Widget for Spectrum<'_> {
|
|
fn render(self, area: Rect, buf: &mut Buffer) {
|
|
if area.width == 0 || area.height == 0 {
|
|
return;
|
|
}
|
|
|
|
// Update peak hold state
|
|
let peak_values = if self.peaks {
|
|
Some(PEAKS.with(|p| {
|
|
let mut peaks = p.borrow_mut();
|
|
for (i, &mag) in self.data.iter().enumerate() {
|
|
let v = (mag * self.gain).min(1.0);
|
|
if v >= peaks[i] {
|
|
peaks[i] = v;
|
|
} else {
|
|
peaks[i] = (peaks[i] - 0.02).max(v);
|
|
}
|
|
}
|
|
*peaks
|
|
}))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
match self.style {
|
|
SpectrumStyle::Bars => render_bars(self.data, area, buf, self.gain, peak_values.as_ref()),
|
|
SpectrumStyle::Line => render_braille(self.data, area, buf, self.gain, false, peak_values.as_ref()),
|
|
SpectrumStyle::Filled => render_braille(self.data, area, buf, self.gain, true, peak_values.as_ref()),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn band_color(ratio: f32, colors: &theme::ThemeColors) -> Color {
|
|
if ratio < 0.33 {
|
|
Color::Rgb(colors.meter.low_rgb.0, colors.meter.low_rgb.1, colors.meter.low_rgb.2)
|
|
} else if ratio < 0.66 {
|
|
Color::Rgb(colors.meter.mid_rgb.0, colors.meter.mid_rgb.1, colors.meter.mid_rgb.2)
|
|
} else {
|
|
Color::Rgb(colors.meter.high_rgb.0, colors.meter.high_rgb.1, colors.meter.high_rgb.2)
|
|
}
|
|
}
|
|
|
|
fn render_bars(data: &[f32; 32], area: Rect, buf: &mut Buffer, gain: f32, peaks: Option<&[f32; 32]>) {
|
|
let colors = theme::get();
|
|
let height = area.height as f32;
|
|
let base = area.width as usize / 32;
|
|
let remainder = area.width as usize % 32;
|
|
if base == 0 && remainder == 0 {
|
|
return;
|
|
}
|
|
|
|
let mut x_start = area.x;
|
|
for (band, &mag) in data.iter().enumerate() {
|
|
let w = base + if band < remainder { 1 } else { 0 };
|
|
if w == 0 {
|
|
continue;
|
|
}
|
|
let bar_height = (mag * gain).min(1.0) * height;
|
|
let full_cells = bar_height as usize;
|
|
let frac = bar_height - full_cells as f32;
|
|
let frac_idx = (frac * 8.0) as usize;
|
|
|
|
// Peak hold row
|
|
let peak_row = peaks.map(|p| {
|
|
let ph = p[band] * height;
|
|
let row = (height - ph).max(0.0) as usize;
|
|
row.min(area.height as usize - 1)
|
|
});
|
|
|
|
for row in 0..area.height as usize {
|
|
let y = area.y + area.height - 1 - row as u16;
|
|
let ratio = row as f32 / area.height as f32;
|
|
let color = band_color(ratio, &colors);
|
|
|
|
for dx in 0..w as u16 {
|
|
let x = x_start + dx;
|
|
if row < full_cells {
|
|
buf[(x, y)].set_char(BLOCKS[7]).set_fg(color);
|
|
} else if row == full_cells && frac_idx > 0 {
|
|
buf[(x, y)].set_char(BLOCKS[frac_idx - 1]).set_fg(color);
|
|
} else if let Some(pr) = peak_row {
|
|
// peak_row is from top (0 = top), row is from bottom
|
|
let from_top = area.height as usize - 1 - row;
|
|
if from_top == pr {
|
|
buf[(x, y)].set_char('─').set_fg(colors.meter.high);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
x_start += w as u16;
|
|
}
|
|
}
|
|
|
|
fn render_braille(
|
|
data: &[f32; 32],
|
|
area: Rect,
|
|
buf: &mut Buffer,
|
|
gain: f32,
|
|
filled: bool,
|
|
peaks: Option<&[f32; 32]>,
|
|
) {
|
|
let colors = theme::get();
|
|
let width = area.width as usize;
|
|
let height = area.height as usize;
|
|
let fine_w = width * 2;
|
|
let fine_h = height * 4;
|
|
|
|
PATTERNS.with(|p| {
|
|
let mut patterns = p.borrow_mut();
|
|
patterns.clear();
|
|
patterns.resize(width * height, 0);
|
|
|
|
// Interpolate 32 bands across fine_w columns
|
|
for fx in 0..fine_w {
|
|
let band_f = fx as f32 * 31.0 / (fine_w - 1).max(1) as f32;
|
|
let lo = band_f as usize;
|
|
let hi = (lo + 1).min(31);
|
|
let t = band_f - lo as f32;
|
|
let mag = ((data[lo] * (1.0 - t) + data[hi] * t) * gain).min(1.0);
|
|
let fy = ((1.0 - mag) * (fine_h - 1) as f32).round() as usize;
|
|
let fy = fy.min(fine_h - 1);
|
|
|
|
if filled {
|
|
for y in fy..fine_h {
|
|
let cy = y / 4;
|
|
let dy = y % 4;
|
|
let cx = fx / 2;
|
|
let dx = fx % 2;
|
|
patterns[cy * width + cx] |= braille_bit(dx, dy);
|
|
}
|
|
} else {
|
|
let cy = fy / 4;
|
|
let dy = fy % 4;
|
|
let cx = fx / 2;
|
|
let dx = fx % 2;
|
|
patterns[cy * width + cx] |= braille_bit(dx, dy);
|
|
}
|
|
|
|
// Peak dots
|
|
if let Some(pk) = peaks {
|
|
let pv = (pk[lo] * (1.0 - t) + pk[hi] * t).min(1.0);
|
|
let py = ((1.0 - pv) * (fine_h - 1) as f32).round() as usize;
|
|
let py = py.min(fine_h - 1);
|
|
let cy = py / 4;
|
|
let dy = py % 4;
|
|
let cx = fx / 2;
|
|
let dx = fx % 2;
|
|
patterns[cy * width + cx] |= braille_bit(dx, dy);
|
|
}
|
|
}
|
|
|
|
for cy in 0..height {
|
|
for cx in 0..width {
|
|
let pattern = patterns[cy * width + cx];
|
|
if pattern != 0 {
|
|
let ratio = 1.0 - (cy as f32 / height as f32);
|
|
let color = band_color(ratio, &colors);
|
|
let ch = char::from_u32(0x2800 + pattern as u32).unwrap_or(' ');
|
|
buf[(area.x + cx as u16, area.y + cy as u16)]
|
|
.set_char(ch)
|
|
.set_fg(color);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
fn braille_bit(dot_x: usize, dot_y: usize) -> u8 {
|
|
match (dot_x, dot_y) {
|
|
(0, 0) => 0x01,
|
|
(0, 1) => 0x02,
|
|
(0, 2) => 0x04,
|
|
(0, 3) => 0x40,
|
|
(1, 0) => 0x08,
|
|
(1, 1) => 0x10,
|
|
(1, 2) => 0x20,
|
|
(1, 3) => 0x80,
|
|
_ => unreachable!(),
|
|
}
|
|
}
|