feat: add audio visualization

feat: add audio visualization

remove comments

Cargo.lock

···
 checksum = "fbdcdcb6d86f71c5e97409ad45898af11cbc995b4ee8112d59095a28d376c935"
 
 [[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
+[[package]]
 name = "cookie"
 version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "num_cpus",
  "serde",
  "tokio",
+]
+
+[[package]]
+name = "derive_more"
+version = "0.99.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version 0.4.0",
+ "syn 1.0.107",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "num-complex"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23c6602fda94a57c990fe0df199a035d83576b496aa29f4e634a8ac6004e68a6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
 name = "num-derive"
 version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "proc-macro2",
  "quote",
  "syn 1.0.107",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
 ]
 
 [[package]]
···
 dependencies = [
  "proc-macro2",
  "syn 1.0.107",
+]
+
+[[package]]
+name = "primal-check"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9df7f93fd637f083201473dab4fee2db4c429d32e55e3299980ab3957ab916a0"
+dependencies = [
+ "num-integer",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
 dependencies = [
- "semver",
+ "semver 0.9.0",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver 1.0.22",
+]
+
+[[package]]
+name = "rustfft"
+version = "6.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43806561bc506d0c5d160643ad742e3161049ac01027b5e6d7524091fd401d86"
+dependencies = [
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "primal-check",
+ "strength_reduce",
+ "transpose",
+ "version_check",
 ]
 
 [[package]]
···
 dependencies = [
  "semver-parser",
 ]
+
+[[package]]
+name = "semver"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca"
 
 [[package]]
 name = "semver-parser"
···
 checksum = "d022496b16281348b52d0e30ae99e01a73d737b2f45d38fed4edf79f9325a1d5"
 dependencies = [
  "discard",
- "rustc_version",
+ "rustc_version 0.2.3",
  "stdweb-derive",
  "stdweb-internal-macros",
  "stdweb-internal-runtime",
···
 checksum = "213701ba3370744dcd1a12960caa4843b3d68b4d1c0a5d575e0d65b2ee9d16c0"
 
 [[package]]
+name = "strength_reduce"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
+
+[[package]]
 name = "strsim"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "thiserror"
-version = "1.0.38"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
+checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.38"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
+checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.51",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "transpose"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
+dependencies = [
+ "num-integer",
+ "strength_reduce",
+]
+
+[[package]]
 name = "try-lock"
 version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "tunein-cli"
-version = "0.2.5"
+version = "0.2.6"
 dependencies = [
  "anyhow",
  "clap",
  "cpal",
  "crossterm",
+ "derive_more",
  "futures",
  "futures-util",
  "hyper",
···
  "ratatui",
  "reqwest",
  "rodio",
+ "rustfft",
  "serde",
  "surf",
  "symphonia",
  "termion",
+ "thiserror",
  "tokio",
  "tonic",
  "tonic-build",

Cargo.toml

···
 name = "tunein-cli"
 readme = "README.md"
 repository = "https://github.com/tsirysndr/tunein-cli"
-version = "0.2.5"
+version = "0.2.6"
 
 [[bin]]
 name = "tunein"
···
 
 [workspace.metadata.cross.target.aarch64-unknown-linux-gnu]
 pre-build = [
-    "dpkg --add-architecture $CROSS_DEB_ARCH", 
-    "apt-get update && apt-get --assume-yes install libasound2-dev libasound2-dev:$CROSS_DEB_ARCH protobuf-compiler"
+  "dpkg --add-architecture $CROSS_DEB_ARCH",
+  "apt-get update && apt-get --assume-yes install libasound2-dev libasound2-dev:$CROSS_DEB_ARCH protobuf-compiler",
 ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
···
 clap = "3.2.20"
 cpal = "0.14.0"
 crossterm = "0.27.0"
+derive_more = "0.99.17"
 futures = "0.3.26"
 futures-util = "0.3.26"
 hyper = {version = "0.14.23", features = ["client", "stream", "tcp", "http1", "http2"]}
···
 ratatui = "0.26.1"
 reqwest = {version = "0.11.14", features = ["blocking", "rustls-tls"], default-features = false}
 rodio = {version = "0.16"}
+rustfft = "6.2.0"
 serde = "1.0.197"
 surf = {version = "2.3.2", features = ["h1-client-rustls"], default-features = false}
 symphonia = {version = "0.5.1", features = ["aac", "alac", "mp3", "isomp4", "flac"]}
 termion = "2.0.1"
+thiserror = "1.0.58"
 tokio = {version = "1.24.2", features = ["tokio-macros", "macros", "rt", "rt-multi-thread"]}
 tonic = "0.8.3"
 tonic-web = "0.4.0"

README.md

···
 Or download the latest release for your platform [here](https://github.com/tsirysndr/tunein-cli/releases).
 
 ## 📦 Downloads
-- `Mac`: arm64: [tunein_v0.2.5_aarch64-apple-darwin.tar.gz](https://github.com/tsirysndr/tunein-cli/releases/download/v0.2.5/tunein_v0.2.5_aarch64-apple-darwin.tar.gz) intel: [tunein_v0.2.5_x86_64-apple-darwin.tar.gz](https://github.com/tsirysndr/tunein-cli/releases/download/v0.2.5/tunein_v0.2.5_x86_64-apple-darwin.tar.gz)
-- `Linux`: [tunein_v0.2.5_x86_64-unknown-linux-gnu.tar.gz](https://github.com/tsirysndr/tunein-cli/releases/download/v0.2.5/tunein_v0.2.5_x86_64-unknown-linux-gnu.tar.gz)
+- `Mac`: arm64: [tunein_v0.2.6_aarch64-apple-darwin.tar.gz](https://github.com/tsirysndr/tunein-cli/releases/download/v0.2.6/tunein_v0.2.6_aarch64-apple-darwin.tar.gz) intel: [tunein_v0.2.6_x86_64-apple-darwin.tar.gz](https://github.com/tsirysndr/tunein-cli/releases/download/v0.2.6/tunein_v0.2.6_x86_64-apple-darwin.tar.gz)
+- `Linux`: [tunein_v0.2.6_x86_64-unknown-linux-gnu.tar.gz](https://github.com/tsirysndr/tunein-cli/releases/download/v0.2.6/tunein_v0.2.6_x86_64-unknown-linux-gnu.tar.gz)
 ## 🚀 Usage
 ```
 USAGE:

flake.nix

···
           inherit src;
           
           pname = "tunein";
-          version = "0.2.3";
+          version = "0.2.6";
 
           buildInputs = [
             # Add additional build inputs here

src/app.rs

···
-use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
+use crossterm::event::{self, Event, KeyCode, KeyModifiers};
 use ratatui::{
     prelude::*,
     widgets::{block::*, *},
 };
-use std::{io, process, thread, time::Duration};
+use std::{
+    io,
+    ops::Range,
+    process,
+    sync::{mpsc::Receiver, Arc, Mutex},
+    thread,
+    time::{Duration, Instant},
+};
 use tokio::sync::mpsc::UnboundedReceiver;
 
-use crate::{extract::get_currently_playing, tui};
+use crate::{
+    extract::get_currently_playing,
+    input::stream_to_matrix,
+    tui,
+    visualization::{
+        oscilloscope::Oscilloscope, spectroscope::Spectroscope, vectorscope::Vectorscope,
+        Dimension, DisplayMode, GraphConfig,
+    },
+};
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct State {
     pub name: String,
     pub now_playing: String,
···
     pub br: String,
 }
 
-#[derive(Debug, Default)]
+pub enum CurrentDisplayMode {
+    Oscilloscope,
+    Vectorscope,
+    Spectroscope,
+}
+
 pub struct App {
-    name: String,
-    now_playing: String,
-    genre: String,
-    description: String,
-    br: String,
-    exit: bool,
+    #[allow(unused)]
+    channels: u8,
+    graph: GraphConfig,
+    oscilloscope: Oscilloscope,
+    vectorscope: Vectorscope,
+    spectroscope: Spectroscope,
+    mode: CurrentDisplayMode,
+    frame_rx: Receiver<minimp3::Frame>,
 }
 
 impl App {
-    pub fn new() -> Self {
+    pub fn new(
+        ui: &crate::cfg::UiOptions,
+        source: &crate::cfg::SourceOptions,
+        frame_rx: Receiver<minimp3::Frame>,
+    ) -> Self {
+        let graph = GraphConfig {
+            axis_color: Color::DarkGray,
+            labels_color: Color::Cyan,
+            palette: vec![Color::Red, Color::Yellow, Color::Green, Color::Magenta],
+            scale: ui.scale as f64,
+            width: source.buffer, // TODO also make bit depth customizable
+            samples: source.buffer,
+            sampling_rate: source.sample_rate,
+            references: !ui.no_reference,
+            show_ui: !ui.no_ui,
+            scatter: ui.scatter,
+            pause: false,
+            marker_type: if ui.no_braille {
+                Marker::Dot
+            } else {
+                Marker::Braille
+            },
+        };
+
+        let oscilloscope = Oscilloscope::from_args(source);
+        let vectorscope = Vectorscope::from_args(source);
+        let spectroscope = Spectroscope::from_args(source);
+
         Self {
-            name: "".to_string(),
-            now_playing: "".to_string(),
-            genre: "".to_string(),
-            description: "".to_string(),
-            br: "".to_string(),
-            exit: false,
+            graph,
+            oscilloscope,
+            vectorscope,
+            spectroscope,
+            mode: CurrentDisplayMode::Spectroscope,
+            channels: source.channels as u8,
+            frame_rx,
         }
     }
 }
 
+fn render_frame(state: Arc<Mutex<State>>, frame: &mut Frame) {
+    let state = state.lock().unwrap();
+    let size = frame.size();
+
+    frame.render_widget(
+        Block::new()
+            .borders(Borders::TOP)
+            .title(" TuneIn CLI ")
+            .title_alignment(Alignment::Center),
+        Rect {
+            x: size.x,
+            y: size.y,
+            width: size.width,
+            height: 1,
+        },
+    );
+
+    render_line(
+        "Station ",
+        &state.name,
+        Rect {
+            x: size.x,
+            y: size.y + 1,
+            width: size.width,
+            height: 1,
+        },
+        frame,
+    );
+    render_line(
+        "Now Playing ",
+        &state.now_playing,
+        Rect {
+            x: size.x,
+            y: size.y + 2,
+            width: size.width,
+            height: 1,
+        },
+        frame,
+    );
+    render_line(
+        "Genre ",
+        &state.genre,
+        Rect {
+            x: size.x,
+            y: size.y + 3,
+            width: size.width,
+            height: 1,
+        },
+        frame,
+    );
+    render_line(
+        "Description ",
+        &state.description,
+        Rect {
+            x: size.x,
+            y: size.y + 4,
+            width: size.width,
+            height: 1,
+        },
+        frame,
+    );
+    render_line(
+        "Bitrate ",
+        &format!("{} kbps", &state.br),
+        Rect {
+            x: size.x,
+            y: size.y + 5,
+            width: size.width,
+            height: 1,
+        },
+        frame,
+    );
+}
+
+fn render_line(label: &str, value: &str, area: Rect, frame: &mut Frame) {
+    let span1 = Span::styled(label, Style::new().fg(Color::LightBlue));
+    let span2 = Span::raw(value);
+
+    let line = Line::from(vec![span1, span2]);
+    let text: Text = Text::from(vec![line]);
+
+    frame.render_widget(Paragraph::new(text), area);
+}
+
 impl App {
     /// runs the application's main loop until the user quits
     pub async fn run(
···
         id: &str,
     ) {
         let new_state = cmd_rx.recv().await.unwrap();
-        self.name = new_state.name;
-        self.genre = new_state.genre;
-        self.description = new_state.description;
-        self.br = new_state.br;
+        let new_state = Arc::new(Mutex::new(new_state));
+
+        let id = id.to_string();
+        let new_state_clone = new_state.clone();
 
-        thread::spawn(|| loop {
-            match event::read().unwrap() {
-                // it's important to check that the event is a key press event as
-                // crossterm also emits key release and repeat events on Windows.
-                Event::Key(key_event) if key_event.kind == KeyEventKind::Press => {
-                    match key_event.code {
-                        KeyCode::Char('q') => {
-                            let _ = tui::restore();
-                            process::exit(0);
-                        },
-                        KeyCode::Char('d')
-                            if key_event.modifiers.contains(KeyModifiers::CONTROL) =>
-                        {
-                            let _ = tui::restore();
-                            process::exit(0);
-                        }
-                        KeyCode::Char('c')
-                            if key_event.modifiers.contains(KeyModifiers::CONTROL) =>
-                        {
-                            let _ = tui::restore();
-                            process::exit(0);
-                        }
-                        _ => {}
-                    }
-                }
-                _ => {}
-            };
+        thread::spawn(move || loop {
+            let rt = tokio::runtime::Runtime::new().unwrap();
+            rt.block_on(async {
+                let mut new_state = new_state_clone.lock().unwrap();
+                // Get current playing if available, otherwise use state's value
+                new_state.now_playing = get_currently_playing(&id).await.unwrap_or_default();
+                drop(new_state);
+                std::thread::sleep(Duration::from_millis(10000));
+            });
         });
 
+        let mut fps = 0;
+        let mut framerate = 0;
+        let mut last_poll = Instant::now();
+
         loop {
-            // Get current playing if available, otherwise use state's value
-            let now_playing = get_currently_playing(id).await.unwrap_or_default();
+            let audio_frame = self.frame_rx.recv().unwrap();
+            let channels =
+                stream_to_matrix(audio_frame.data.iter().cloned(), audio_frame.channels, 1.);
 
-            // Update state with current playing
-            self.now_playing = now_playing;
-            terminal.draw(|frame| self.render_frame(frame)).unwrap();
-            std::thread::sleep(Duration::from_millis(10000));
-        }
-    }
+            fps += 1;
 
-    fn render_frame(&self, frame: &mut Frame) {
-        let areas = Layout::new(
-            Direction::Vertical,
-            [
-                Constraint::Length(1),
-                Constraint::Length(1),
-                Constraint::Length(1),
-                Constraint::Length(1),
-                Constraint::Length(1),
-                Constraint::Min(0),
-            ],
-        )
-        .split(frame.size());
+            if last_poll.elapsed().as_secs() >= 1 {
+                framerate = fps;
+                fps = 0;
+                last_poll = Instant::now();
+            }
+
+            {
+                let mut datasets = Vec::new();
+                let graph = self.graph.clone(); // TODO cheap fix...
+                if self.graph.references {
+                    datasets.append(&mut self.current_display_mut().references(&graph));
+                }
+                datasets.append(&mut self.current_display_mut().process(&graph, &channels));
+                terminal
+                    .draw(|f| {
+                        let mut size = f.size();
+                        render_frame(new_state.clone(), f);
+                        if self.graph.show_ui {
+                            f.render_widget(
+                                make_header(
+                                    &self.graph,
+                                    &self.current_display().header(&self.graph),
+                                    self.current_display().mode_str(),
+                                    framerate,
+                                    self.graph.pause,
+                                ),
+                                Rect {
+                                    x: size.x,
+                                    y: size.y + 6,
+                                    width: size.width,
+                                    height: 1,
+                                },
+                            );
+                            size.height -= 7;
+                            size.y += 7;
+                        }
+                        let chart = Chart::new(datasets.iter().map(|x| x.into()).collect())
+                            .x_axis(self.current_display().axis(&self.graph, Dimension::X)) // TODO allow to have axis sometimes?
+                            .y_axis(self.current_display().axis(&self.graph, Dimension::Y));
+                        f.render_widget(chart, size)
+                    })
+                    .unwrap();
+            }
 
-        frame.render_widget(
-            Block::new()
-                .borders(Borders::TOP)
-                .title(" TuneIn CLI ")
-                .title_alignment(Alignment::Center),
-            areas[0],
-        );
+            while event::poll(Duration::from_millis(0)).unwrap() {
+                // process all enqueued events
+                let event = event::read().unwrap();
 
-        self.render_line("Station ", &self.name, areas[1], frame);
-        self.render_line("Now Playing ", &self.now_playing, areas[2], frame);
-        self.render_line("Genre ", &self.genre, areas[3], frame);
-        self.render_line("Description ", &self.description, areas[4], frame);
-        self.render_line("Bitrate ", &format!("{} kbps", &self.br), areas[5], frame);
+                if self.process_events(event.clone()).unwrap() {
+                    return;
+                }
+                self.current_display_mut().handle(event);
+            }
+        }
     }
 
-    fn render_line(&self, label: &str, value: &str, area: Rect, frame: &mut Frame) {
-        let span1 = Span::styled(label, Style::new().fg(Color::LightBlue));
-        let span2 = Span::raw(value);
-
-        let line = Line::from(vec![span1, span2]);
-        let text: Text = Text::from(vec![line]);
+    fn current_display_mut(&mut self) -> &mut dyn DisplayMode {
+        match self.mode {
+            CurrentDisplayMode::Oscilloscope => &mut self.oscilloscope as &mut dyn DisplayMode,
+            CurrentDisplayMode::Vectorscope => &mut self.vectorscope as &mut dyn DisplayMode,
+            CurrentDisplayMode::Spectroscope => &mut self.spectroscope as &mut dyn DisplayMode,
+        }
+    }
 
-        frame.render_widget(Paragraph::new(text), area);
+    fn current_display(&self) -> &dyn DisplayMode {
+        match self.mode {
+            CurrentDisplayMode::Oscilloscope => &self.oscilloscope as &dyn DisplayMode,
+            CurrentDisplayMode::Vectorscope => &self.vectorscope as &dyn DisplayMode,
+            CurrentDisplayMode::Spectroscope => &self.spectroscope as &dyn DisplayMode,
+        }
     }
 
-    /// updates the application's state based on user input
-    fn handle_events(&mut self) -> io::Result<()> {
-        match event::read()? {
-            // it's important to check that the event is a key press event as
-            // crossterm also emits key release and repeat events on Windows.
-            Event::Key(key_event) if key_event.kind == KeyEventKind::Press => {
-                self.handle_key_event(key_event)
+    fn process_events(&mut self, event: Event) -> Result<bool, io::Error> {
+        let mut quit = false;
+        if let Event::Key(key) = event {
+            if let KeyModifiers::CONTROL = key.modifiers {
+                match key.code {
+                    // mimic other programs shortcuts to quit, for user friendlyness
+                    KeyCode::Char('c') | KeyCode::Char('q') | KeyCode::Char('w') => quit = true,
+                    _ => {}
+                }
             }
-            _ => {}
+            let magnitude = match key.modifiers {
+                KeyModifiers::SHIFT => 10.0,
+                KeyModifiers::CONTROL => 5.0,
+                KeyModifiers::ALT => 0.2,
+                _ => 1.0,
+            };
+            match key.code {
+                KeyCode::Up => update_value_f(&mut self.graph.scale, 0.01, magnitude, 0.0..10.0), // inverted to act as zoom
+                KeyCode::Down => update_value_f(&mut self.graph.scale, -0.01, magnitude, 0.0..10.0), // inverted to act as zoom
+                KeyCode::Right => update_value_i(
+                    &mut self.graph.samples,
+                    true,
+                    25,
+                    magnitude,
+                    0..self.graph.width * 2,
+                ),
+                KeyCode::Left => update_value_i(
+                    &mut self.graph.samples,
+                    false,
+                    25,
+                    magnitude,
+                    0..self.graph.width * 2,
+                ),
+                KeyCode::Char('q') => quit = true,
+                KeyCode::Char(' ') => self.graph.pause = !self.graph.pause,
+                KeyCode::Char('s') => self.graph.scatter = !self.graph.scatter,
+                KeyCode::Char('h') => self.graph.show_ui = !self.graph.show_ui,
+                KeyCode::Char('r') => self.graph.references = !self.graph.references,
+                KeyCode::Esc => {
+                    self.graph.samples = self.graph.width;
+                    self.graph.scale = 1.;
+                }
+                KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                    let _ = tui::restore();
+                    process::exit(0);
+                }
+                KeyCode::Tab => {
+                    // switch modes
+                    match self.mode {
+                        CurrentDisplayMode::Oscilloscope => {
+                            self.mode = CurrentDisplayMode::Vectorscope
+                        }
+                        CurrentDisplayMode::Vectorscope => {
+                            self.mode = CurrentDisplayMode::Spectroscope
+                        }
+                        CurrentDisplayMode::Spectroscope => {
+                            self.mode = CurrentDisplayMode::Oscilloscope
+                        }
+                    }
+                }
+                _ => {}
+            }
         };
-        Ok(())
+
+        Ok(quit)
     }
+}
 
-    fn handle_key_event(&mut self, key_event: KeyEvent) {
-        match key_event.code {
-            KeyCode::Char('q') => self.exit(),
-            KeyCode::Char('d') if key_event.modifiers.contains(KeyModifiers::CONTROL) => {
-                self.exit()
-            }
-            KeyCode::Char('c') if key_event.modifiers.contains(KeyModifiers::CONTROL) => {
-                self.exit()
-            }
-            _ => {}
+pub fn update_value_f(val: &mut f64, base: f64, magnitude: f64, range: Range<f64>) {
+    let delta = base * magnitude;
+    if *val + delta > range.end {
+        *val = range.end
+    } else if *val + delta < range.start {
+        *val = range.start
+    } else {
+        *val += delta;
+    }
+}
+
+pub fn update_value_i(val: &mut u32, inc: bool, base: u32, magnitude: f64, range: Range<u32>) {
+    let delta = (base as f64 * magnitude) as u32;
+    if inc {
+        if range.end - delta < *val {
+            *val = range.end
+        } else {
+            *val += delta
         }
+    } else if range.start + delta > *val {
+        *val = range.start
+    } else {
+        *val -= delta
     }
+}
 
-    fn exit(&mut self) {
-        self.exit = true;
-    }
+fn make_header<'a>(
+    cfg: &GraphConfig,
+    module_header: &'a str,
+    kind_o_scope: &'static str,
+    fps: usize,
+    pause: bool,
+) -> Table<'a> {
+    Table::new(
+        vec![Row::new(vec![
+            Cell::from(format!("{}::scope-tui", kind_o_scope)).style(
+                Style::default()
+                    .fg(*cfg.palette.first().expect("empty palette?"))
+                    .add_modifier(Modifier::BOLD),
+            ),
+            Cell::from(module_header),
+            Cell::from(format!("-{:.2}x+", cfg.scale)),
+            Cell::from(format!("{}/{} spf", cfg.samples, cfg.width)),
+            Cell::from(format!("{}fps", fps)),
+            Cell::from(if cfg.scatter { "***" } else { "---" }),
+            Cell::from(if pause { "||" } else { "|>" }),
+        ])],
+        vec![
+            Constraint::Percentage(35),
+            Constraint::Percentage(25),
+            Constraint::Percentage(7),
+            Constraint::Percentage(13),
+            Constraint::Percentage(6),
+            Constraint::Percentage(6),
+            Constraint::Percentage(6),
+        ],
+    )
+    .style(Style::default().fg(cfg.labels_color))
 }

src/cfg.rs

···
+use crate::music::Note;
+
+/// a simple oscilloscope/vectorscope for your terminal
+#[derive(Debug)]
+pub struct ScopeArgs {
+    pub opts: SourceOptions,
+    pub ui: UiOptions,
+}
+
+#[derive(Debug, Clone)]
+pub struct UiOptions {
+    /// floating point vertical scale, from 0 to 1
+    pub scale: f32,
+
+    /// use vintage looking scatter mode instead of line mode
+    pub scatter: bool,
+
+    /// don't draw reference line
+    pub no_reference: bool,
+
+    /// hide UI and only draw waveforms
+    pub no_ui: bool,
+
+    /// don't use braille dots for drawing lines
+    pub no_braille: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct SourceOptions {
+    /// number of channels to open
+    pub channels: usize,
+
+    /// size of audio buffer, and width of scope
+    pub buffer: u32,
+
+    /// sample rate to use
+    pub sample_rate: u32,
+
+    /// tune buffer size to be in tune with given note (overrides buffer option)
+    pub tune: Option<String>,
+}
+
+// TODO its convenient to keep this here but it's not really the best place...
+impl SourceOptions {
+    pub fn tune(&mut self) {
+        if let Some(txt) = &self.tune {
+            // TODO make it less jank
+            if let Ok(note) = txt.parse::<Note>() {
+                self.buffer = note.tune_buffer_size(self.sample_rate);
+                while self.buffer % (self.channels as u32 * 2) != 0 {
+                    // TODO customizable bit depth
+                    self.buffer += 1; // TODO jank but otherwise it doesn't align
+                }
+            } else {
+                eprintln!("[!] Unrecognized note '{}', ignoring option", txt);
+            }
+        }
+    }
+}

src/decoder.rs

···
-use std::io::Read;
 use std::time::Duration;
+use std::{io::Read, sync::mpsc::Sender};
 
 use minimp3::{Decoder, Frame};
 use rodio::Source;
···
     decoder: Decoder<R>,
     current_frame: Frame,
     current_frame_offset: usize,
+    tx: Sender<Frame>,
 }
 
 impl<R> Mp3Decoder<R>
 where
     R: Read,
 {
-    pub fn new(mut data: R) -> Result<Self, R> {
+    pub fn new(mut data: R, tx: Sender<Frame>) -> Result<Self, R> {
         if !is_mp3(data.by_ref()) {
             return Err(data);
         }
···
             decoder,
             current_frame,
             current_frame_offset: 0,
+            tx,
         })
     }
 }
···
     fn next(&mut self) -> Option<i16> {
         if self.current_frame_offset == self.current_frame.data.len() {
             match self.decoder.next_frame() {
-                Ok(frame) => self.current_frame = frame,
+                Ok(frame) => {
+                    match self.tx.send(frame.clone()) {
+                        Ok(_) => {}
+                        Err(_) => return None,
+                    }
+                    self.current_frame = frame
+                }
                 _ => return None,
             }
             self.current_frame_offset = 0;

src/format.rs

···
+pub trait SampleParser<T> {
+    fn parse(data: &[u8]) -> T;
+}
+
+pub struct Signed16PCM;
+impl SampleParser<f64> for Signed16PCM {
+    fn parse(chunk: &[u8]) -> f64 {
+        (chunk[0] as i16 | (chunk[1] as i16) << 8) as f64
+    }
+}

src/input.rs

···
+pub type Matrix<T> = Vec<Vec<T>>;
+
+/// separate a stream of alternating channels into a matrix of channel streams:
+///   L R L R L R L R L R
+/// becomes
+///   L L L L L
+///   R R R R R
+pub fn stream_to_matrix<I, O>(
+    stream: impl Iterator<Item = I>,
+    channels: usize,
+    norm: O,
+) -> Matrix<O>
+where
+    I: Copy + Into<O>,
+    O: Copy + std::ops::Div<Output = O>,
+{
+    let mut out = vec![vec![]; channels];
+    let mut channel = 0;
+    for sample in stream {
+        out[channel].push(sample.into() / norm);
+        channel = (channel + 1) % channels;
+    }
+    out
+}

src/main.rs

···
 
 mod app;
 mod browse;
+mod cfg;
 mod decoder;
 mod extract;
+mod input;
+mod music;
 mod play;
 mod player;
 mod search;
 mod server;
 mod tui;
+mod visualization;
 
 fn cli() -> Command<'static> {
     const VESRION: &str = env!("CARGO_PKG_VERSION");

src/music.rs

···
+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
+            }
+        }
+    }
+}

src/play.rs

···
 
 use crate::{
     app::{App, State},
+    cfg::{SourceOptions, UiOptions},
     decoder::Mp3Decoder,
     extract::{extract_stream_url, get_currently_playing},
     tui,
···
     println!("{}", stream_url);
 
     let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel::<State>();
+    let (frame_tx, frame_rx) = std::sync::mpsc::channel::<minimp3::Frame>();
 
-    let mut app = App::new();
+    let ui = UiOptions {
+        scale: 1.0,
+        scatter: false,
+        no_reference: true,
+        no_ui: true,
+        no_braille: false,
+    };
+
+    let opts = SourceOptions {
+        channels: 2,
+        buffer: 1152,
+        sample_rate: 44100,
+        tune: None,
+    };
+
+    let mut app = App::new(&ui, &opts, frame_rx);
 
     thread::spawn(move || {
         let client = reqwest::blocking::Client::new();
···
 
         let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
         let sink = rodio::Sink::try_new(&handle).unwrap();
-        let decoder = Mp3Decoder::new(response).unwrap();
+        let decoder = Mp3Decoder::new(response, frame_tx).unwrap();
         sink.append(decoder);
 
         loop {

src/player.rs

···
     }
 
     fn handle_play(&mut self, url: String) -> Result<(), Error> {
+        let (frame_tx, frame_rx) = std::sync::mpsc::channel::<minimp3::Frame>();
         let client = reqwest::blocking::Client::new();
 
         let response = client.get(url).send().unwrap();
···
         self.stream = stream;
         self.sink = rodio::Sink::try_new(&handle).unwrap();
         self.handle = handle;
-        let decoder = Mp3Decoder::new(response).unwrap();
+        let decoder = Mp3Decoder::new(response, frame_tx).unwrap();
         self.sink.append(decoder);
         self.sink.play();
         Ok(())

src/visualization/mod.rs

···
+pub mod oscilloscope;
+pub mod spectroscope;
+pub mod vectorscope;
+
+use crossterm::event::Event;
+use ratatui::{
+    style::{Color, Style},
+    symbols::Marker,
+    widgets::{Axis, Dataset, GraphType},
+};
+
+use crate::input::Matrix;
+
+pub enum Dimension {
+    X,
+    Y,
+}
+
+#[derive(Debug, Clone)]
+pub struct GraphConfig {
+    pub pause: bool,
+    pub samples: u32,
+    pub sampling_rate: u32,
+    pub scale: f64,
+    pub width: u32,
+    pub scatter: bool,
+    pub references: bool,
+    pub show_ui: bool,
+    pub marker_type: Marker,
+    pub palette: Vec<Color>,
+    pub labels_color: Color,
+    pub axis_color: Color,
+}
+
+impl GraphConfig {
+    pub fn palette(&self, index: usize) -> Color {
+        *self
+            .palette
+            .get(index % self.palette.len())
+            .unwrap_or(&Color::White)
+    }
+}
+
+#[allow(clippy::ptr_arg)]
+pub trait DisplayMode {
+    // MUST define
+    fn from_args(args: &crate::cfg::SourceOptions) -> Self
+    where
+        Self: Sized;
+    fn axis(&self, cfg: &GraphConfig, dimension: Dimension) -> Axis; // TODO simplify this
+    fn process(&mut self, cfg: &GraphConfig, data: &Matrix<f64>) -> Vec<DataSet>;
+    fn mode_str(&self) -> &'static str;
+
+    // SHOULD override
+    fn channel_name(&self, index: usize) -> String {
+        format!("{}", index)
+    }
+    fn header(&self, _cfg: &GraphConfig) -> String {
+        "".into()
+    }
+    fn references(&self, _cfg: &GraphConfig) -> Vec<DataSet> {
+        vec![]
+    }
+    fn handle(&mut self, _event: Event) {}
+}
+
+pub struct DataSet {
+    name: Option<String>,
+    data: Vec<(f64, f64)>,
+    marker_type: Marker,
+    graph_type: GraphType,
+    color: Color,
+}
+
+impl<'a> From<&'a DataSet> for Dataset<'a> {
+    fn from(ds: &'a DataSet) -> Dataset<'a> {
+        let mut out = Dataset::default(); // TODO creating a binding is kinda ugly, is it avoidable?
+        if let Some(name) = &ds.name {
+            out = out.name(name.clone());
+        }
+        out.marker(ds.marker_type)
+            .graph_type(ds.graph_type)
+            .style(Style::default().fg(ds.color))
+            .data(&ds.data)
+    }
+}
+
+// TODO this is pretty ugly but I need datasets which own the data
+impl DataSet {
+    pub fn new(
+        name: Option<String>,
+        data: Vec<(f64, f64)>,
+        marker_type: Marker,
+        graph_type: GraphType,
+        color: Color,
+    ) -> Self {
+        DataSet {
+            name,
+            data,
+            marker_type,
+            graph_type,
+            color,
+        }
+    }
+}

src/visualization/oscilloscope.rs

···
+use crossterm::event::{Event, KeyCode, KeyModifiers};
+use ratatui::{
+    style::Style,
+    text::Span,
+    widgets::{Axis, GraphType},
+};
+
+use crate::{
+    app::{update_value_f, update_value_i},
+    input::Matrix,
+};
+
+use super::{DataSet, Dimension, DisplayMode, GraphConfig};
+
+#[derive(Default)]
+pub struct Oscilloscope {
+    pub triggering: bool,
+    pub falling_edge: bool,
+    pub threshold: f64,
+    pub depth: u32,
+    pub peaks: bool,
+}
+
+impl DisplayMode for Oscilloscope {
+    fn from_args(_opts: &crate::cfg::SourceOptions) -> Self {
+        Oscilloscope::default()
+    }
+
+    fn mode_str(&self) -> &'static str {
+        "oscillo"
+    }
+
+    fn channel_name(&self, index: usize) -> String {
+        match index {
+            0 => "L".into(),
+            1 => "R".into(),
+            _ => format!("{}", index),
+        }
+    }
+
+    fn header(&self, _: &GraphConfig) -> String {
+        if self.triggering {
+            format!(
+                "{} {:.0}{} trigger",
+                if self.falling_edge { "v" } else { "^" },
+                self.threshold,
+                if self.depth > 1 {
+                    format!(":{}", self.depth)
+                } else {
+                    "".into()
+                },
+            )
+        } else {
+            "live".into()
+        }
+    }
+
+    fn axis(&self, cfg: &GraphConfig, dimension: Dimension) -> Axis {
+        let (name, bounds) = match dimension {
+            Dimension::X => ("time -", [0.0, cfg.samples as f64]),
+            Dimension::Y => ("| amplitude", [-cfg.scale, cfg.scale]),
+        };
+        let mut a = Axis::default();
+        if cfg.show_ui {
+            // TODO don't make it necessary to check show_ui inside here
+            a = a.title(Span::styled(name, Style::default().fg(cfg.labels_color)));
+        }
+        a.style(Style::default().fg(cfg.axis_color)).bounds(bounds)
+    }
+
+    fn references(&self, cfg: &GraphConfig) -> Vec<DataSet> {
+        vec![DataSet::new(
+            None,
+            vec![(0.0, 0.0), (cfg.samples as f64, 0.0)],
+            cfg.marker_type,
+            GraphType::Line,
+            cfg.axis_color,
+        )]
+    }
+
+    fn process(&mut self, cfg: &GraphConfig, data: &Matrix<f64>) -> Vec<DataSet> {
+        let mut out = Vec::new();
+
+        let mut trigger_offset = 0;
+        if self.depth == 0 {
+            self.depth = 1
+        }
+        if self.triggering {
+            for i in 0..data[0].len() {
+                if triggered(&data[0], i, self.threshold, self.depth, self.falling_edge) {
+                    // triggered
+                    break;
+                }
+                trigger_offset += 1;
+            }
+        }
+
+        if self.triggering {
+            out.push(DataSet::new(
+                Some("T".into()),
+                vec![(0.0, self.threshold)],
+                cfg.marker_type,
+                GraphType::Scatter,
+                cfg.labels_color,
+            ));
+        }
+
+        for (n, channel) in data.iter().enumerate().rev() {
+            let (mut min, mut max) = (0.0, 0.0);
+            let mut tmp = Vec::new();
+            for (i, sample) in channel.iter().enumerate() {
+                if *sample < min {
+                    min = *sample
+                };
+                if *sample > max {
+                    max = *sample
+                };
+                if i >= trigger_offset {
+                    tmp.push(((i - trigger_offset) as f64, *sample));
+                }
+            }
+
+            if self.peaks {
+                out.push(DataSet::new(
+                    None,
+                    vec![(0.0, min), (0.0, max)],
+                    cfg.marker_type,
+                    GraphType::Scatter,
+                    cfg.palette(n),
+                ))
+            }
+
+            out.push(DataSet::new(
+                Some(self.channel_name(n)),
+                tmp,
+                cfg.marker_type,
+                if cfg.scatter {
+                    GraphType::Scatter
+                } else {
+                    GraphType::Line
+                },
+                cfg.palette(n),
+            ));
+        }
+
+        out
+    }
+
+    fn handle(&mut self, event: Event) {
+        if let Event::Key(key) = event {
+            let magnitude = match key.modifiers {
+                KeyModifiers::SHIFT => 10.0,
+                KeyModifiers::CONTROL => 5.0,
+                KeyModifiers::ALT => 0.2,
+                _ => 1.0,
+            };
+            match key.code {
+                KeyCode::PageUp => {
+                    update_value_f(&mut self.threshold, 250.0, magnitude, 0.0..32768.0)
+                }
+                KeyCode::PageDown => {
+                    update_value_f(&mut self.threshold, -250.0, magnitude, 0.0..32768.0)
+                }
+                KeyCode::Char('t') => self.triggering = !self.triggering,
+                KeyCode::Char('e') => self.falling_edge = !self.falling_edge,
+                KeyCode::Char('p') => self.peaks = !self.peaks,
+                KeyCode::Char('=') => update_value_i(&mut self.depth, true, 1, 1.0, 1..65535),
+                KeyCode::Char('-') => update_value_i(&mut self.depth, false, 1, 1.0, 1..65535),
+                KeyCode::Char('+') => update_value_i(&mut self.depth, true, 10, 1.0, 1..65535),
+                KeyCode::Char('_') => update_value_i(&mut self.depth, false, 10, 1.0, 1..65535),
+                KeyCode::Esc => {
+                    self.triggering = false;
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+#[allow(clippy::collapsible_else_if)] // TODO can this be made nicer?
+fn triggered(data: &[f64], index: usize, threshold: f64, depth: u32, falling_edge: bool) -> bool {
+    if data.len() < index + (1 + depth as usize) {
+        return false;
+    }
+    if falling_edge {
+        if data[index] >= threshold {
+            for i in 1..=depth as usize {
+                if data[index + i] >= threshold {
+                    return false;
+                }
+            }
+            true
+        } else {
+            false
+        }
+    } else {
+        if data[index] <= threshold {
+            for i in 1..=depth as usize {
+                if data[index + i] <= threshold {
+                    return false;
+                }
+            }
+            true
+        } else {
+            false
+        }
+    }
+}

src/visualization/spectroscope.rs

···
+use std::collections::VecDeque;
+
+use crossterm::event::{Event, KeyCode};
+use ratatui::{
+    style::Style,
+    text::Span,
+    widgets::{Axis, GraphType},
+};
+
+use crate::{app::update_value_i, input::Matrix};
+
+use super::{DataSet, Dimension, DisplayMode, GraphConfig};
+
+use rustfft::{num_complex::Complex, FftPlanner};
+
+#[derive(Default)]
+pub struct Spectroscope {
+    pub sampling_rate: u32,
+    pub buffer_size: u32,
+    pub average: u32,
+    pub buf: Vec<VecDeque<Vec<f64>>>,
+    pub window: bool,
+    pub log_y: bool,
+}
+
+fn magnitude(c: Complex<f64>) -> f64 {
+    let squared = (c.re * c.re) + (c.im * c.im);
+    squared.sqrt()
+}
+
+// got this from https://github.com/phip1611/spectrum-analyzer/blob/3c079ec2785b031d304bb381ff5f5fe04e6bcf71/src/windows.rs#L40
+pub fn hann_window(samples: &[f64]) -> Vec<f64> {
+    let mut windowed_samples = Vec::with_capacity(samples.len());
+    let samples_len = samples.len() as f64;
+    for (i, sample) in samples.iter().enumerate() {
+        let two_pi_i = 2.0 * std::f64::consts::PI * i as f64;
+        let idontknowthename = (two_pi_i / samples_len).cos();
+        let multiplier = 0.5 * (1.0 - idontknowthename);
+        windowed_samples.push(sample * multiplier)
+    }
+    windowed_samples
+}
+
+impl DisplayMode for Spectroscope {
+    fn from_args(opts: &crate::cfg::SourceOptions) -> Self {
+        Spectroscope {
+            sampling_rate: opts.sample_rate,
+            buffer_size: opts.buffer,
+            average: 1,
+            buf: Vec::new(),
+            window: false,
+            log_y: true,
+        }
+    }
+
+    fn mode_str(&self) -> &'static str {
+        "spectro"
+    }
+
+    fn channel_name(&self, index: usize) -> String {
+        match index {
+            0 => "L".into(),
+            1 => "R".into(),
+            _ => format!("{}", index),
+        }
+    }
+
+    fn header(&self, _: &GraphConfig) -> String {
+        let window_marker = if self.window { "-|-" } else { "---" };
+        if self.average <= 1 {
+            format!(
+                "live  {}  {:.3}Hz bins",
+                window_marker,
+                self.sampling_rate as f64 / self.buffer_size as f64
+            )
+        } else {
+            format!(
+                "{}x avg ({:.1}s)  {}  {:.3}Hz bins",
+                self.average,
+                (self.average * self.buffer_size) as f64 / self.sampling_rate as f64,
+                window_marker,
+                self.sampling_rate as f64 / (self.buffer_size * self.average) as f64,
+            )
+        }
+    }
+
+    fn axis(&self, cfg: &GraphConfig, dimension: Dimension) -> Axis {
+        let (name, bounds) = match dimension {
+            Dimension::X => (
+                "frequency -",
+                [
+                    20.0f64.ln(),
+                    ((cfg.samples as f64 / cfg.width as f64) * 20000.0).ln(),
+                ],
+            ),
+            Dimension::Y => (
+                if self.log_y { "| level" } else { "| amplitude" },
+                [if self.log_y { 0. } else { 0.0 }, cfg.scale * 7.5], // very arbitrary but good default
+            ),
+            // TODO super arbitraty! wtf! also ugly inline ifs, get this thing together!
+        };
+        let mut a = Axis::default();
+        if cfg.show_ui {
+            // TODO don't make it necessary to check show_ui inside here
+            a = a.title(Span::styled(name, Style::default().fg(cfg.labels_color)));
+        }
+        a.style(Style::default().fg(cfg.axis_color)).bounds(bounds)
+    }
+
+    fn process(&mut self, cfg: &GraphConfig, data: &Matrix<f64>) -> Vec<DataSet> {
+        if self.average == 0 {
+            self.average = 1
+        } // otherwise fft breaks
+        if !cfg.pause {
+            for (i, chan) in data.iter().enumerate() {
+                if self.buf.len() <= i {
+                    self.buf.push(VecDeque::new());
+                }
+                self.buf[i].push_back(chan.clone());
+                while self.buf[i].len() > self.average as usize {
+                    self.buf[i].pop_front();
+                }
+            }
+        }
+
+        let mut out = Vec::new();
+        let mut planner: FftPlanner<f64> = FftPlanner::new();
+        let sample_len = self.buffer_size * self.average;
+        let resolution = self.sampling_rate as f64 / sample_len as f64;
+        let fft = planner.plan_fft_forward(sample_len as usize);
+
+        for (n, chan_queue) in self.buf.iter().enumerate().rev() {
+            let mut chunk = chan_queue.iter().flatten().copied().collect::<Vec<f64>>();
+            if self.window {
+                chunk = hann_window(chunk.as_slice());
+            }
+            let mut max_val = *chunk
+                .iter()
+                .max_by(|a, b| a.total_cmp(b))
+                .expect("empty dataset?");
+            if max_val < 1. {
+                max_val = 1.;
+            }
+            let mut tmp: Vec<Complex<f64>> = chunk
+                .iter()
+                .map(|x| Complex {
+                    re: *x / max_val,
+                    im: 0.0,
+                })
+                .collect();
+            fft.process(tmp.as_mut_slice());
+            out.push(DataSet::new(
+                Some(self.channel_name(n)),
+                tmp[..=tmp.len() / 2]
+                    .iter()
+                    .enumerate()
+                    .map(|(i, x)| {
+                        (
+                            (i as f64 * resolution).ln(),
+                            if self.log_y {
+                                magnitude(*x).ln()
+                            } else {
+                                magnitude(*x)
+                            },
+                        )
+                    })
+                    .collect(),
+                cfg.marker_type,
+                if cfg.scatter {
+                    GraphType::Scatter
+                } else {
+                    GraphType::Line
+                },
+                cfg.palette(n),
+            ));
+        }
+
+        out
+    }
+
+    fn handle(&mut self, event: Event) {
+        if let Event::Key(key) = event {
+            match key.code {
+                KeyCode::PageUp => update_value_i(&mut self.average, true, 1, 1., 1..65535),
+                KeyCode::PageDown => update_value_i(&mut self.average, false, 1, 1., 1..65535),
+                KeyCode::Char('w') => self.window = !self.window,
+                KeyCode::Char('l') => self.log_y = !self.log_y,
+                _ => {}
+            }
+        }
+    }
+
+    fn references(&self, cfg: &GraphConfig) -> Vec<DataSet> {
+        let lower = 0.; // if self.log_y { -(cfg.scale * 5.) } else { 0. };
+        let upper = cfg.scale * 7.5;
+        vec![
+            DataSet::new(
+                None,
+                vec![(0.0, 0.0), ((cfg.samples as f64).ln(), 0.0)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            // TODO can we auto generate these? lol...
+            DataSet::new(
+                None,
+                vec![(20.0f64.ln(), lower), (20.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(30.0f64.ln(), lower), (30.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(40.0f64.ln(), lower), (40.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(50.0f64.ln(), lower), (50.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(60.0f64.ln(), lower), (60.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(70.0f64.ln(), lower), (70.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(80.0f64.ln(), lower), (80.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(90.0f64.ln(), lower), (90.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(100.0f64.ln(), lower), (100.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(200.0f64.ln(), lower), (200.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(300.0f64.ln(), lower), (300.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(400.0f64.ln(), lower), (400.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(500.0f64.ln(), lower), (500.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(600.0f64.ln(), lower), (600.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(700.0f64.ln(), lower), (700.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(800.0f64.ln(), lower), (800.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(900.0f64.ln(), lower), (900.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(1000.0f64.ln(), lower), (1000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(2000.0f64.ln(), lower), (2000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(3000.0f64.ln(), lower), (3000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(4000.0f64.ln(), lower), (4000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(5000.0f64.ln(), lower), (5000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(6000.0f64.ln(), lower), (6000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(7000.0f64.ln(), lower), (7000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(8000.0f64.ln(), lower), (8000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(9000.0f64.ln(), lower), (9000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(10000.0f64.ln(), lower), (10000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(20000.0f64.ln(), lower), (20000.0f64.ln(), upper)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+        ]
+    }
+}

src/visualization/vectorscope.rs

···
+use ratatui::{
+    style::Style,
+    text::Span,
+    widgets::{Axis, GraphType},
+};
+
+use crate::input::Matrix;
+
+use super::{DataSet, Dimension, DisplayMode, GraphConfig};
+
+#[derive(Default)]
+pub struct Vectorscope {}
+
+impl DisplayMode for Vectorscope {
+    fn from_args(_opts: &crate::cfg::SourceOptions) -> Self {
+        Vectorscope::default()
+    }
+
+    fn mode_str(&self) -> &'static str {
+        "vector"
+    }
+
+    fn channel_name(&self, index: usize) -> String {
+        format!("{}", index)
+    }
+
+    fn header(&self, _: &GraphConfig) -> String {
+        "live".into()
+    }
+
+    fn axis(&self, cfg: &GraphConfig, dimension: Dimension) -> Axis {
+        let (name, bounds) = match dimension {
+            Dimension::X => ("left -", [-cfg.scale, cfg.scale]),
+            Dimension::Y => ("| right", [-cfg.scale, cfg.scale]),
+        };
+        let mut a = Axis::default();
+        if cfg.show_ui {
+            // TODO don't make it necessary to check show_ui inside here
+            a = a.title(Span::styled(name, Style::default().fg(cfg.labels_color)));
+        }
+        a.style(Style::default().fg(cfg.axis_color)).bounds(bounds)
+    }
+
+    fn references(&self, cfg: &GraphConfig) -> Vec<DataSet> {
+        vec![
+            DataSet::new(
+                None,
+                vec![(-cfg.scale, 0.0), (cfg.scale, 0.0)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+            DataSet::new(
+                None,
+                vec![(0.0, -cfg.scale), (0.0, cfg.scale)],
+                cfg.marker_type,
+                GraphType::Line,
+                cfg.axis_color,
+            ),
+        ]
+    }
+
+    fn process(&mut self, cfg: &GraphConfig, data: &Matrix<f64>) -> Vec<DataSet> {
+        let mut out = Vec::new();
+
+        for (n, chunk) in data.chunks(2).enumerate() {
+            let mut tmp = vec![];
+            match chunk.len() {
+                2 => {
+                    for i in 0..std::cmp::min(chunk[0].len(), chunk[1].len()) {
+                        if i > cfg.samples as usize {
+                            break;
+                        }
+                        tmp.push((chunk[0][i], chunk[1][i]));
+                    }
+                }
+                1 => {
+                    for i in 0..chunk[0].len() {
+                        if i > cfg.samples as usize {
+                            break;
+                        }
+                        tmp.push((chunk[0][i], i as f64));
+                    }
+                }
+                _ => continue,
+            }
+            // split it in two for easier coloring
+            // TODO configure splitting in multiple parts?
+            let pivot = tmp.len() / 2;
+            out.push(DataSet::new(
+                Some(self.channel_name((n * 2) + 1)),
+                tmp[pivot..].to_vec(),
+                cfg.marker_type,
+                if cfg.scatter {
+                    GraphType::Scatter
+                } else {
+                    GraphType::Line
+                },
+                cfg.palette((n * 2) + 1),
+            ));
+            out.push(DataSet::new(
+                Some(self.channel_name(n * 2)),
+                tmp[..pivot].to_vec(),
+                cfg.marker_type,
+                if cfg.scatter {
+                    GraphType::Scatter
+                } else {
+                    GraphType::Line
+                },
+                cfg.palette(n * 2),
+            ));
+        }
+
+        out
+    }
+}