feat: add visualizer that's like.. kinda okay

Author: 8sumint

Cargo.lock

@@ -19,6 +19,7 @@ fltk = "1.4.3"
 fltk-theme = "0.7.0"
 aes-gcm-siv = "0.11.1"
 hex = "0.4.3"
+spectrum-analyzer = "1.4.0"
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3", features = ["winuser", "dwmapi"] }

player/Cargo.toml

@@ -6,6 +6,9 @@ use cpal::{Sample, Stream};
 use opus::Decoder;
 use ringbuf::{LocalRb, Rb};
 
+use spectrum_analyzer;
+use spectrum_analyzer::scaling::{divide_by_N_sqrt, scale_to_zero_to_one, scale_20_times_log10};
+
 type Ringbuf<T> = LocalRb<T, Vec<MaybeUninit<T>>>;
 
 const PLAYER_BUFFER_SIZE: usize = 48000 * 10; // 10s of samples?
@@ -14,7 +17,8 @@ pub struct Player {
     decoder: Decoder,
     buffer: Arc<Mutex<Ringbuf<f32>>>,
     stream: Option<Stream>,
-    frames_received: usize,
+    pub frames_received: usize,
+    visualizer_buffer: Arc<Mutex<Vec<[f32; 480 * 5]>>>, // :3
 }
 impl Player {
     pub fn new() -> Self {
@@ -23,13 +27,14 @@ impl Player {
             buffer: Arc::new(Mutex::new(Ringbuf::<f32>::new(PLAYER_BUFFER_SIZE))),
             stream: None,
             frames_received: 0,
+            visualizer_buffer: Arc::new(Mutex::new(vec![])),
         }
     }
 
     // decode opus data when received and buffer the samples
     pub fn receive(&mut self, frame: Vec<u8>) {
         // allocate and decode into here
-        let mut pcm = vec![0.0; 960];
+        let mut pcm = [0.0; 960];
         self.decoder.decode_float(&frame, &mut pcm, false).unwrap();
         self.frames_received += 1;
 
@@ -41,6 +46,21 @@ impl Player {
             // otherwise just discard i guess
             println!("player buffer full... discarding :/")
         }
+
+        let chunk = self.frames_received % 5;
+        let mut buf = self.visualizer_buffer.lock().unwrap();
+        let bl = buf.len();
+
+        if chunk == 0 || bl == 0 {
+            buf.push([0.0;480*5]);
+        }
+
+        let bl = buf.len();
+
+        for (i, s) in pcm.iter().step_by(2).enumerate() {
+            let summed = s + pcm[i + 1] / 2.0;
+            buf[bl-1][chunk + i] = summed;
+        }
     }
 
     pub fn start(&mut self) {
@@ -127,6 +147,10 @@ impl Player {
     pub fn fake_frames_received(&mut self, frames: usize) {
         self.frames_received = frames;
     }
+    pub fn get_visualizer_buffer(&mut self) -> Arc<Mutex<Vec<[f32; 480 * 5]>>> {
+        assert!(self.frames_received % 5 == 0);
+        self.visualizer_buffer.clone()
+    }
 }
 
 // callback when the audio output needs more data
@@ -150,3 +174,46 @@ fn write_audio<T: Sample>(
         println!("write_audio: buffer has {} left", buffer.len());
     }
 }
+
+pub fn calculate_visualizer(samples: &[f32; 2400]) -> [u8; 14] {
+    let samples_truncated = &samples[..2048];
+    let hamming_window = spectrum_analyzer::windows::hann_window(samples_truncated);
+    let spectrum = spectrum_analyzer::samples_fft_to_spectrum(
+        &hamming_window,
+        48000,
+        spectrum_analyzer::FrequencyLimit::All,
+        Some(&scale_to_zero_to_one),
+    )
+    .unwrap();
+
+    let mut bars_float = [0.0; 14];
+    let min_freq = 20.0;
+    let max_freq = 20000.0;
+
+    for (fr, fr_val) in spectrum.data().iter() {
+        let fr = fr.val();
+        if fr < 25.0 {
+            continue;
+        }
+
+        let index = (-5.25062 * fr.log(0.06) - 7.56997).round().min(13.0) as usize;
+        //println!("{}, {}, {}", index, fr);
+        let lmao = if fr < 200.0 {
+            3.0
+        } else if fr < 500.0 {
+            2.0
+        } else {
+            1.0
+        };
+        bars_float[index] += fr_val.val() * lmao;
+    }
+    //println!("{:?}", bars_float);
+    let bars: [u8; 14] = bars_float
+        .iter()
+        .map(|&num| (num as f32 / 2.0).round().min(8.0) as u8)
+        .collect::<Vec<u8>>()
+        .try_into()
+        .unwrap();
+    //println!("{:?}", bars);
+    bars
+}

player/src/audio.rs

@@ -1,3 +1,6 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
 use fltk::app::Sender;
 use fltk::browser::*;
 use fltk::button::*;
@@ -12,6 +15,8 @@ use fltk::image::PngImage;
 use fltk::input::*;
 use fltk::prelude::*;
 use fltk::valuator::*;
+use fltk::widget;
+use fltk::widget_extends;
 use fltk::window::*;
 
 use crate::main;
@@ -26,6 +31,7 @@ pub struct MainWindow {
     pub lbl_time: Frame,
     pub lbl_title: Frame,
     pub lbl_data1: Frame,
+    pub visualizer: Visualizer,
 }
 impl MainWindow {
     pub fn make_window(s: Sender<UIEvent>) -> Self {
@@ -148,6 +154,10 @@ impl MainWindow {
         lbl_time.set_align(Align::Left | Align::Inside);
         //main_win.add(&lbl_time);
 
+        let mut visualizer = Visualizer::new(19, 60);
+        visualizer.update_values([0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3]);
+        display.add(&*visualizer);
+
         display.end();
         main_win.add(&display);
 
@@ -165,7 +175,6 @@ impl MainWindow {
         btn_queue.emit(s.clone(), UIEvent::BtnQueue);
         main_win.add(&btn_queue);
 
-
         main_win.end();
 
         Self {
@@ -177,6 +186,7 @@ impl MainWindow {
             lbl_time,
             lbl_title,
             lbl_data1,
+            visualizer
         }
     }
 
@@ -245,7 +255,7 @@ impl QueueWindow {
 
         let mut queue_browser =
             SelectBrowser::new(10, 24, main_grp.width() - 20, main_grp.height() - 40, "");
-        
+
         main_grp.add(&queue_browser);
 
         let mut btns_grp = Group::new(10, main_grp.height() - 15, 10, 10, "");
@@ -291,6 +301,56 @@ fn create_horizontal_gradient_frame(
     frame
 }
 
+pub struct Visualizer {
+    inner: widget::Widget,
+    values: Rc<RefCell<[u8; 14]>>, // 14 bars (height 0 to 8)
+}
+
+widget_extends!(Visualizer, widget::Widget, inner);
+
+impl Visualizer {
+    pub fn new(x: i32, y: i32) -> Self {
+        let mut inner = widget::Widget::default().with_size(41, 20).with_pos(x, y);
+        inner.set_frame(FrameType::FlatBox);
+
+        let values = [5; 14];
+        let values = Rc::from(RefCell::from(values));
+        let v = values.clone();
+
+        inner.draw(move |i| {
+            draw::draw_box(i.frame(), i.x(), i.y(), i.w(), i.h(), i.color());
+            draw::set_draw_color(Color::Black);
+            draw::draw_xyline(i.x(), i.y() + 16, i.x() + (14 * 3) - 2);
+            for bar in 0..14 {
+                let value = v.borrow()[bar] as i32;
+                for val in 0..value {
+                    let x = i.x() + bar as i32 * 3;
+                    let y = i.y() + (7 - val) * 2;
+                    draw::draw_xyline(x, y, x + 1);
+                }
+            }
+        });
+
+        Self { inner, values }
+    }
+    pub fn update_values(&mut self, values: [u8; 14]) {
+        {
+            let prev = self.values.borrow().clone();
+            let mut sv = self.values.borrow_mut();
+            for i in 0..14 {
+                if values[i] > prev[i] {
+                    sv[i] = ((prev[i] as usize + 2*values[i] as usize) / 3 as usize) as u8;
+                } else if sv[i] > 1 {
+                    sv[i] = sv[i] - 1;
+                } else {
+                    sv[i] = 0;
+                }
+            }
+        }
+        self.redraw();
+    }
+}
+
 use winapi::shared::windef::HWND;
 
 use winapi::um::winuser::{

player/src/gui.rs

@@ -178,6 +178,17 @@ impl Connection {
                         }
 
                         p.receive(frame.data);
+                        if p.frames_received % 5 == 0 {
+                            // visualization buffer ready
+                            let samples = p.get_visualizer_buffer();
+                            let mut samples = samples.lock().unwrap();
+                            if samples.len() < 20 {
+                                continue;
+                            }
+                            let bars = audio::calculate_visualizer(&samples.remove(0));
+                            tx.send(AudioStatus::Visualizer(bars)).unwrap();
+
+                        }
                     }
                     AudioData::Start => {
                         wants_play = true;
@@ -286,6 +297,9 @@ impl Connection {
                         AudioStatus::Finished => {
                             self.ui_status_default();
                         }
+                        AudioStatus::Visualizer(bars) => {
+                            self.ui_sender.send(UIEvent::Update(UIUpdateEvent::Visualizer(bars)))
+                        }
                     }
                 },
 
@@ -532,6 +546,9 @@ async fn main() -> std::io::Result<()> {
                             let progress = elapsed as f64 / total as f64;
                             gui.seek_bar.set_value(progress);
                         }
+                        UIUpdateEvent::Visualizer(bars) => {
+                            gui.visualizer.update_values(bars);
+                        }
                         UIUpdateEvent::Status(val) => {
                             gui.status_field.set_label(&val);
                         }
@@ -653,6 +670,7 @@ pub enum UIUpdateEvent {
     UpdateUserList(HashMap<String, String>),
     UpdateQueue(Option<Track>, VecDeque<Track>),
     Status(String),
+    Visualizer([u8; 14]),
 }
 
 struct UIState {
@@ -665,6 +683,7 @@ enum AudioStatus {
     Buffering,
     DoneBuffering,
     Finished,
+    Visualizer([u8; 14]),
 }
 
 #[derive(Debug, PartialEq)]