feat: info panel and simple waveform

Cargo.lock

···
 ]
 
 [[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
 name = "allocator-api2"
 version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
 name = "lebe"
 version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "matchers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
 name = "memchr"
 version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "cfg_aliases 0.2.1",
  "libc",
  "memoffset",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
 name = "renderdoc-sys"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
 name = "shlex"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "dirs 6.0.0",
  "iced",
  "rfd",
+ "streamtools-core",
+ "tracing",
+ "tracing-subscriber",
 ]
 
 [[package]]
 name = "streamtools-core"
 version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "cpal",
+]
 
 [[package]]
 name = "strict-num"
···
 ]
 
 [[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
 name = "tiff"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
 dependencies = [
  "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex-automata",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
 ]
 
 [[package]]
···
  "serde_core",
  "wasm-bindgen",
 ]
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
 [[package]]
 name = "version_check"

README.md

···
-# Stream Tools
+# StreamTools
+
+A (planned) collection of lightweight tools for streaming, built with Rust.
+
+## Mic Activity
+
+A simple microphone activity indicator.
+
+### What it does
+
+StreamTools displays a customizable image that shows when your microphone is active with an emerald green border,
+similar to an app like Discord's mic indicator.
+
+I made this to show user's I'm talking even with my camera.
+
+### Quick Start
+
+![Using the cover of a fun F# book](./assets/screenshot.png)
+
+```bash
+cargo run
+```
+
+Drag an image onto the window, speak into your mic, and watch the green border appear!

app/Cargo.toml

···
 anyhow = "1"
 dirs = "6.0.0"
 rfd = "0.16.0"
+streamtools-core = { path = "../core" }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }

app/src/main.rs

···
-fn main() {}
+use iced::mouse;
+use iced::widget::{self, Canvas, button, canvas, column, container, image, mouse_area, text};
+use iced::{Color, Font, Length, Point, Rectangle, Size};
+use iced::{Subscription, Task, Theme, time};
+use std::collections::VecDeque;
+use std::path::PathBuf;
+use std::sync::Mutex;
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+};
+use std::time::{Duration, Instant};
+use streamtools_core::{MicInfo, SharedLevels, spawn_mic_listener};
+
+#[derive(Debug)]
+struct Model {
+    is_active: bool,
+    flag: Arc<AtomicBool>,
+    /// current image (if any)
+    current_image: Option<image::Handle>,
+    /// path to last used image
+    last_image_path: Option<PathBuf>,
+    show_panel: bool,
+    /// copy of the recent mic RMS values for drawing
+    levels: SharedLevels,
+    /// device metadata
+    info: MicInfo,
+    /// track last click for double-click detection
+    last_click: Option<Instant>,
+    /// current audio level for border intensity (0.0 - 1.0)
+    current_level: f32,
+}
+
+#[derive(Debug, Clone)]
+enum Message {
+    Tick,
+    WindowEvent(iced::window::Event),
+    ReplaceImagePressed,
+    ImageChosen(Option<PathBuf>),
+    ImageClicked,
+    ClosePanel,
+}
+
+const JETBRAINS_MONO: Font = Font::with_name("JetBrains Mono");
+
+/// Waveform visualizer for audio levels
+#[derive(Debug)]
+struct Waveform {
+    levels: SharedLevels,
+}
+
+impl<Message> canvas::Program<Message> for Waveform {
+    type State = ();
+
+    /// Some Notes:
+    ///
+    /// We amplify the visual representation significantly for better visibility (bright cyan/green)
+    /// Using 50x amplification -> typical mic levels are 0.01-0.1 RMS
+    fn draw(
+        &self, _: &Self::State, renderer: &iced::Renderer, _: &Theme, bounds: Rectangle, _: mouse::Cursor,
+    ) -> Vec<canvas::Geometry> {
+        let mut frame = canvas::Frame::new(renderer, bounds.size());
+
+        frame.fill_rectangle(Point::new(0.0, 0.0), bounds.size(), Color::from_rgb(0.1, 0.1, 0.12));
+
+        if let Ok(levels) = self.levels.lock() {
+            if !levels.is_empty() {
+                let width = bounds.width;
+                let height = bounds.height;
+                let count = levels.len();
+                let bar_width = width / count as f32;
+
+                for (i, &level) in levels.iter().enumerate() {
+                    let x = i as f32 * bar_width;
+
+                    let amplified = (level * 50.0).min(1.0);
+                    let bar_height = (amplified * height).min(height);
+                    let y = height - bar_height;
+
+                    frame.fill_rectangle(
+                        Point::new(x, y),
+                        Size::new(bar_width * 0.9, bar_height),
+                        Color::from_rgb(0.2, 1.0, 0.8),
+                    );
+                }
+            }
+        }
+
+        vec![frame.into_geometry()]
+    }
+}
+
+impl Model {
+    fn update(&mut self, message: Message) -> iced::Task<Message> {
+        match message {
+            Message::Tick => {
+                let was_active = self.is_active;
+                self.is_active = self.flag.load(Ordering::Relaxed);
+
+                if let Ok(levels) = self.levels.lock() {
+                    self.current_level = levels.back().copied().unwrap_or(0.0);
+                }
+
+                if was_active != self.is_active {
+                    tracing::info!("Mic activity changed: is_active={}", self.is_active);
+                }
+
+                Task::none()
+            }
+            Message::ImageClicked => {
+                let now = Instant::now();
+                if let Some(last) = self.last_click {
+                    let elapsed = now.duration_since(last);
+                    if elapsed < Duration::from_millis(500) {
+                        self.show_panel = !self.show_panel;
+                        self.last_click = None;
+                    } else {
+                        self.last_click = Some(now);
+                    }
+                } else {
+                    self.last_click = Some(now);
+                }
+
+                Task::none()
+            }
+            Message::WindowEvent(iced::window::Event::FileDropped(path)) => {
+                if let Some(ext) = path.extension().and_then(|s| s.to_str()) {
+                    let ext_lower = ext.to_ascii_lowercase();
+                    if !["png", "jpg", "jpeg", "gif", "webp"].contains(&ext_lower.as_str()) {
+                        eprintln!("Unsupported image type: {ext_lower}");
+                        return Task::none();
+                    }
+                }
+
+                let handle = image::Handle::from_path(&path);
+                self.current_image = Some(handle);
+                self.last_image_path = Some(path.clone());
+
+                if let Some(config_file) = Self::get_config_file() {
+                    if let Err(e) = std::fs::write(config_file, path.to_string_lossy().as_ref()) {
+                        eprintln!("failed to write config file: {e}");
+                    }
+                }
+
+                Task::none()
+            }
+            Message::ReplaceImagePressed => {
+                let path = rfd::FileDialog::new()
+                    .add_filter("Images", &["png", "jpg", "jpeg", "gif", "webp"])
+                    .set_title("Choose mic indicator image")
+                    .pick_file();
+
+                Task::done(Message::ImageChosen(path))
+            }
+            Message::ImageChosen(Some(path)) => {
+                let handle = image::Handle::from_path(&path);
+                self.current_image = Some(handle);
+                self.last_image_path = Some(path.clone());
+                if let Some(config_file) = Self::get_config_file() {
+                    let _ = std::fs::write(config_file, path.to_string_lossy().as_ref());
+                }
+                Task::none()
+            }
+            Message::ImageChosen(None) | Message::WindowEvent(_) => Task::none(),
+            Message::ClosePanel => {
+                self.show_panel = false;
+                Task::none()
+            }
+        }
+    }
+
+    fn get_config_file() -> Option<PathBuf> {
+        dirs::config_dir().map(|mut config| {
+            config.push("streamtools");
+            std::fs::create_dir_all(&config).ok()?;
+            config.push("last_image.txt");
+            Some(config)
+        })?
+    }
+
+    fn load_last_image() -> (Option<PathBuf>, Option<image::Handle>) {
+        if let Some(config_file) = Self::get_config_file() {
+            if let Ok(path) = std::fs::read_to_string(config_file) {
+                let path = PathBuf::from(path.trim());
+                if path.exists() {
+                    let handle = image::Handle::from_path(&path);
+                    return (Some(path), Some(handle));
+                }
+            }
+        }
+        (None, None)
+    }
+
+    fn new(flag: Arc<AtomicBool>, levels: SharedLevels, info: MicInfo) -> Self {
+        let (last_image_path, current_image) = Self::load_last_image();
+
+        Self {
+            show_panel: false,
+            is_active: false,
+            flag,
+            current_image,
+            last_image_path,
+            levels,
+            info,
+            last_click: None,
+            current_level: 0.0,
+        }
+    }
+    fn build_panel(&self) -> iced::Element<'_, Message> {
+        let close_button = button(text("Close").font(JETBRAINS_MONO))
+            .on_press(Message::ClosePanel)
+            .padding(12);
+
+        let info_text = column![
+            text("Microphone Information").size(18).font(JETBRAINS_MONO),
+            text(format!("Device: {}", self.info.name))
+                .size(14)
+                .font(JETBRAINS_MONO),
+            text(format!("Sample Rate: {} Hz", self.info.sample_rate))
+                .size(14)
+                .font(JETBRAINS_MONO),
+            text(format!("Channels: {}", self.info.channels))
+                .size(14)
+                .font(JETBRAINS_MONO),
+        ]
+        .spacing(8);
+
+        let waveform = Canvas::new(Waveform { levels: self.levels.clone() })
+            .width(Length::Fill)
+            .height(Length::Fixed(150.0));
+
+        let replace_button = button(text("Replace Image"))
+            .on_press(Message::ReplaceImagePressed)
+            .padding(10);
+
+        let panel_content = column![close_button, info_text, waveform, replace_button]
+            .spacing(16)
+            .padding(20);
+
+        container(panel_content)
+            .width(Length::Fill)
+            .height(Length::Fill)
+            .padding(10)
+            .style(|_: &Theme| container::Style {
+                background: Some(Color::from_rgb(0.3, 0.3, 0.35).into()),
+                border: iced::Border { color: Color::from_rgb(0.4, 0.4, 0.45), width: 1.0, radius: 0.0.into() },
+                ..Default::default()
+            })
+            .into()
+    }
+
+    fn view(&self) -> iced::Element<'_, Message> {
+        let image_content: iced::Element<'_, Message> = if let Some(img) = &self.current_image {
+            container(
+                mouse_area(widget::image(img.clone()).width(Length::Shrink).height(Length::Shrink))
+                    .on_press(Message::ImageClicked),
+            )
+            .padding(8)
+            .style(move |_: &Theme| Self::mic_style(self.current_level))
+            .into()
+        } else {
+            widget::text("Drag an image onto this window to use it as the mic indicator.")
+                .size(20)
+                .into()
+        };
+
+        let image_with_border = container(image_content).padding(20);
+
+        if self.show_panel {
+            column![
+                container(image_with_border)
+                    .center_x(Length::Fill)
+                    .width(Length::Fill)
+                    .height(Length::FillPortion(3)),
+                container(self.build_panel())
+                    .width(Length::Fill)
+                    .height(Length::FillPortion(2))
+            ]
+            .width(Length::Fill)
+            .height(Length::Fill)
+            .into()
+        } else {
+            container(image_with_border)
+                .center_x(Length::Fill)
+                .center_y(Length::Fill)
+                .width(Length::Fill)
+                .height(Length::Fill)
+                .into()
+        }
+    }
+
+    fn mic_style(level: f32) -> container::Style {
+        let amplified = (level * 10.0).min(1.0);
+        let emerald_green = Color::from_rgb(0.0, 0.84, 0.47);
+
+        container::Style {
+            background: None,
+            border: iced::Border {
+                color: if amplified > 0.01 { emerald_green } else { Color::from_rgba(0.0, 0.0, 0.0, 0.0) },
+                width: if amplified > 0.01 { 5.0 } else { 0.0 },
+                radius: 4.0.into(),
+            },
+            ..Default::default()
+        }
+    }
+
+    fn subscription(&self) -> Subscription<Message> {
+        Subscription::batch([
+            time::every(std::time::Duration::from_millis(100)).map(|_| Message::Tick),
+            iced::window::events().map(|(_, ev)| Message::WindowEvent(ev)),
+        ])
+    }
+}
+
+pub fn main() -> iced::Result {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::from_default_env().add_directive("streamtools=info".parse().unwrap()),
+        )
+        .init();
+
+    tracing::info!("Starting StreamTools");
+    tracing::info!("Note: On macOS, you may be prompted to grant microphone permissions");
+
+    let flag = Arc::new(AtomicBool::new(false));
+    let shared_levels: SharedLevels = Arc::new(Mutex::new(VecDeque::new()));
+
+    let mic_info = MicInfo::new();
+    tracing::info!("Microphone device: {}", mic_info.name);
+
+    spawn_mic_listener(flag.clone(), shared_levels.clone()).expect("failed to start mic listener");
+    tracing::info!("Microphone listener started successfully");
+
+    iced::application("Mic Activity", Model::update, Model::view)
+        .subscription(Model::subscription)
+        .font(include_bytes!("../../fonts/JetBrainsMono-VariableFont_wght.ttf").as_slice())
+        .centered()
+        .run_with(move || {
+            (
+                Model::new(flag.clone(), shared_levels.clone(), mic_info.clone()),
+                iced::Task::none(),
+            )
+        })
+}

core/src/lib.rs

···
 };
 use std::{
     collections::VecDeque,
-    sync::{Arc, Mutex, atomic::AtomicBool},
-    time,
+    sync::{
+        Arc, Mutex,
+        atomic::{self, AtomicBool, AtomicU64},
+    },
+    time::{self, SystemTime, UNIX_EPOCH},
 };
 
 #[derive(Debug, Clone)]
···
 }
 
 pub type SharedLevels = Arc<Mutex<VecDeque<f32>>>;
+type LastActiveTime = Arc<AtomicU64>;
 
-fn process_input_f32(data: &[f32], active: &AtomicBool, levels: &SharedLevels) {
+const HOLD_TIME_MS: u64 = 300;
+
+fn get_current_time_ms() -> u64 {
+    SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64
+}
+
+fn process_input_f32(data: &[f32], active: &AtomicBool, levels: &SharedLevels, last_active: &LastActiveTime) {
     if data.is_empty() {
         return;
     }
···
     }
     let rms = (sum / data.len() as f32).sqrt();
 
-    let threshold = 0.02;
-    active.store(rms > threshold, std::sync::atomic::Ordering::Relaxed);
+    let threshold = 0.01;
+    let now = get_current_time_ms();
+
+    if rms > threshold {
+        last_active.store(now, atomic::Ordering::Relaxed);
+        active.store(true, atomic::Ordering::Relaxed);
+    } else {
+        let last_time = last_active.load(atomic::Ordering::Relaxed);
+        let is_active = (now - last_time) < HOLD_TIME_MS;
+        active.store(is_active, atomic::Ordering::Relaxed);
+    }
+
     push_level(levels, rms);
 }
 
-fn process_input_i16(data: &[i16], active: &AtomicBool, levels: &SharedLevels) {
+fn process_input_i16(data: &[i16], active: &AtomicBool, levels: &SharedLevels, last_active: &LastActiveTime) {
     if data.is_empty() {
         return;
     }
···
         sum += v * v;
     }
     let rms = (sum / data.len() as f32).sqrt();
-    let threshold = 0.02;
-    active.store(rms > threshold, std::sync::atomic::Ordering::Relaxed);
+
+    let threshold = 0.01;
+    let now = get_current_time_ms();
+
+    if rms > threshold {
+        last_active.store(now, atomic::Ordering::Relaxed);
+        active.store(true, atomic::Ordering::Relaxed);
+    } else {
+        let last_time = last_active.load(atomic::Ordering::Relaxed);
+        let is_active = (now - last_time) < HOLD_TIME_MS;
+        active.store(is_active, atomic::Ordering::Relaxed);
+    }
+
     push_level(levels, rms);
 }
 
-fn process_input_u16(data: &[u16], active: &AtomicBool, levels: &SharedLevels) {
+fn process_input_u16(data: &[u16], active: &AtomicBool, levels: &SharedLevels, last_active: &LastActiveTime) {
     if data.is_empty() {
         return;
     }
···
         sum += v * v;
     }
     let rms = (sum / data.len() as f32).sqrt();
-    let threshold = 0.02;
-    active.store(rms > threshold, std::sync::atomic::Ordering::Relaxed);
+
+    let threshold = 0.01;
+    let now = get_current_time_ms();
+
+    if rms > threshold {
+        last_active.store(now, atomic::Ordering::Relaxed);
+        active.store(true, atomic::Ordering::Relaxed);
+    } else {
+        let last_time = last_active.load(atomic::Ordering::Relaxed);
+        let is_active = (now - last_time) < HOLD_TIME_MS;
+        active.store(is_active, atomic::Ordering::Relaxed);
+    }
+
     push_level(levels, rms);
 }
 
···
         .map_err(|e| anyhow::anyhow!("failed to get default input config: {e}"))?;
     let sample_format = supported_config.sample_format();
     let config: StreamConfig = supported_config.into();
+
+    let last_active: LastActiveTime = Arc::new(AtomicU64::new(0));
 
     let stream = match sample_format {
         SampleFormat::F32 => {
             let active = active.clone();
             let levels = levels.clone();
+            let last_active = last_active.clone();
             let err_fn = |err| eprintln!("cpal input stream error: {err}");
             device.build_input_stream(
                 &config,
-                move |data: &[f32], _| process_input_f32(data, &active, &levels),
+                move |data: &[f32], _| process_input_f32(data, &active, &levels, &last_active),
                 err_fn,
                 None,
             )?
···
         SampleFormat::I16 => {
             let active = active.clone();
             let levels = levels.clone();
+            let last_active = last_active.clone();
             let err_fn = |err| eprintln!("cpal input stream error: {err}");
             device.build_input_stream(
                 &config,
-                move |data: &[i16], _| process_input_i16(data, &active, &levels),
+                move |data: &[i16], _| process_input_i16(data, &active, &levels, &last_active),
                 err_fn,
                 None,
             )?
···
         SampleFormat::U16 => {
             let active = active.clone();
             let levels = levels.clone();
+            let last_active = last_active.clone();
             let err_fn = |err| eprintln!("cpal input stream error: {err}");
             device.build_input_stream(
                 &config,
-                move |data: &[u16], _| process_input_u16(data, &active, &levels),
+                move |data: &[u16], _| process_input_u16(data, &active, &levels, &last_active),
                 err_fn,
                 None,
             )?