A free, open source, and extensible speech-to-text application that works completely offline.
move to handy-recorder (#2188)
CJ Paisa42131d24c59
diff --git a/AGENTS.md b/AGENTS.mdindex 60bd6cd8..eda5426b 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -62,7 +62,7 @@ Handy is a cross-platform desktop speech-to-text application built with Tauri 2.- `transcription.rs` - Speech-to-text processing pipeline- `history.rs` - Transcription history storage- `audio_toolkit/` - Low-level audio processing:- - `audio/` - Device enumeration, recording, resampling+ - `audio/` - Recording sink (VAD, levels, live streaming feed), output devices, WAV I/O- `vad/` - Voice Activity Detection (Silero VAD)- `commands/` - Tauri command handlers for frontend communication- `cli.rs` - CLI argument definitions (clap derive)@@ -104,10 +104,9 @@ Handy is a cross-platform desktop speech-to-text application built with Tauri 2.- `transcribe-cpp` - Local Whisper-family inference (GGML/GGUF) with GPU acceleration- `transcribe-rs` - ONNX speech recognition (Parakeet, Moonshine, SenseVoice, etc.)-- `cpal` - Cross-platform audio I/O+- `handy-recorder` - Microphone capture: device selection, resampling to 16 kHz, failure detection- `vad-rs` - Voice Activity Detection- `rdev` - Global keyboard shortcuts-- `rubato` - Audio resampling- `rodio` - Audio playback for feedback sounds### Application Flowdiff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lockindex 8a8568e8..a96062c6 100644--- a/src-tauri/Cargo.lock+++ b/src-tauri/Cargo.lock@@ -69,9 +69,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"[[package]]name = "alsa"-version = "0.9.1"+version = "0.11.0"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "ed7572b7ba83a31e20d1b48970ee402d2e3e0537dcfe0a3ff4d6eb7508617d43"+checksum = "812947049edcd670a82cd5c73c3661d2e58468577ba8489de58e1a73c04cbd5d"dependencies = ["alsa-sys","bitflags 2.11.0",@@ -81,9 +81,9 @@ dependencies = [[[package]]name = "alsa-sys"-version = "0.3.1"+version = "0.4.0"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527"+checksum = "ad7569085a265dd3f607ebecce7458eaab2132a84393534c95b18dcbc3f31e04"dependencies = ["libc","pkg-config",@@ -379,6 +379,39 @@ version = "1.1.2"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"+[[package]]+name = "audio-codec-algorithms"+version = "0.8.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1254ebf6529f3763c491acfb5ab6e960809e3c75a38584cc664f8c5667fb7107"++[[package]]+name = "audioadapter"+version = "5.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d1292ef9edf681b7426ed089004b021a42896492f58bd0c909ad44e5faec9ac4"++[[package]]+name = "audioadapter-buffers"+version = "5.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "46289a81a3bfa26d0f8b2415f8ca9decde9a66308a150568af5c102381b3c8ce"+dependencies = [+ "audioadapter",+ "audioadapter-sample",+ "num-traits",+]++[[package]]+name = "audioadapter-sample"+version = "5.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5258faecf4edbe35ec483bda9b1f7438e6b391891819269c6b5461aeaa0e8d7d"+dependencies = [+ "audio-codec-algorithms",+ "num-traits",+]+[[package]]name = "auto-launch"version = "0.5.0"@@ -1043,11 +1076,11 @@ dependencies = [[[package]]name = "coreaudio-rs"-version = "0.13.0"+version = "0.14.2"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "1aae284fbaf7d27aa0e292f7677dfbe26503b0d555026f702940805a630eac17"+checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58"dependencies = [- "bitflags 1.3.2",+ "bitflags 2.11.0","libc","objc2-audio-toolbox","objc2-core-audio",@@ -1057,14 +1090,15 @@ dependencies = [[[package]]name = "cpal"-version = "0.16.0"+version = "0.18.2"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "cbd307f43cc2a697e2d1f8bc7a1d824b5269e052209e28883e5bc04d095aaa3f"+checksum = "6f02e8d0327b42d3e2e4ab2119af397344eb9fc54a34bf0ddeaa1277af8681f1"dependencies = ["alsa",+ "block2","coreaudio-rs","dasp_sample",- "jni",+ "jni 0.22.4","js-sys","libc","mach2",@@ -1072,13 +1106,16 @@ dependencies = ["ndk-context","num-derive","num-traits",+ "objc2","objc2-audio-toolbox",+ "objc2-avf-audio","objc2-core-audio","objc2-core-audio-types",- "wasm-bindgen",- "wasm-bindgen-futures",+ "objc2-core-foundation",+ "objc2-foundation","web-sys",- "windows 0.54.0",+ "windows 0.62.2",+ "windows-core 0.62.2",][[package]]@@ -1641,6 +1678,17 @@ dependencies = ["syn 2.0.117",]+[[package]]+name = "enum-primitive-derive"+version = "0.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ba7795da175654fe16979af73f81f26a8ea27638d8d9823d317016888a63dc4c"+dependencies = [+ "num-traits",+ "quote",+ "syn 2.0.117",+]+[[package]]name = "enumflags2"version = "0.7.12"@@ -2506,7 +2554,6 @@ dependencies = ["anyhow","chrono","clap",- "cpal","earshot","enigo","env_filter",@@ -2516,6 +2563,7 @@ dependencies = ["gtk","gtk-layer-shell","handy-keys",+ "handy-recorder","hf-hub","hound","isolang",@@ -2531,8 +2579,6 @@ dependencies = ["regex","reqwest 0.12.28","rodio",- "rtrb",- "rubato","rusqlite","rusqlite_migration","rustfft",@@ -2572,6 +2618,39 @@ dependencies = ["winreg 0.55.0",]+[[package]]+name = "handy-cpal"+version = "0.18.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "07b0f0a55e498d0260eae6bc9a61a976b60d0c014c038771d6fbcc95907b79d4"+dependencies = [+ "alsa",+ "block2",+ "coreaudio-rs",+ "dasp_sample",+ "futures",+ "jni 0.22.4",+ "js-sys",+ "libc",+ "mach2",+ "ndk",+ "ndk-context",+ "num-derive",+ "num-traits",+ "objc2",+ "objc2-audio-toolbox",+ "objc2-avf-audio",+ "objc2-core-audio",+ "objc2-core-audio-types",+ "objc2-core-foundation",+ "objc2-foundation",+ "portable-atomic",+ "pulseaudio",+ "web-sys",+ "windows 0.62.2",+ "windows-core 0.62.2",+]+[[package]]name = "handy-keys"version = "0.3.4"@@ -2592,6 +2671,26 @@ dependencies = ["windows 0.58.0",]+[[package]]+name = "handy-recorder"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4a734d6d16eb8eb485548d75f383fa0c09d65b037a20e648c19730860f7a8a3f"+dependencies = [+ "dasp_sample",+ "futures",+ "handy-cpal",+ "libc",+ "log",+ "objc2-av-foundation",+ "objc2-core-audio",+ "objc2-core-foundation",+ "pulseaudio",+ "rtrb",+ "rubato",+ "windows 0.62.2",+]+[[package]]name = "hashbrown"version = "0.12.3"@@ -2859,7 +2958,7 @@ dependencies = ["js-sys","log","wasm-bindgen",- "windows-core 0.61.2",+ "windows-core 0.62.2",][[package]]@@ -3179,19 +3278,68 @@ dependencies = ["cesu8","cfg-if","combine",- "jni-sys",+ "jni-sys 0.3.0","log","thiserror 1.0.69","walkdir","windows-sys 0.45.0",]+[[package]]+name = "jni"+version = "0.22.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"+dependencies = [+ "cfg-if",+ "combine",+ "jni-macros",+ "jni-sys 0.4.1",+ "log",+ "simd_cesu8",+ "thiserror 2.0.18",+ "walkdir",+ "windows-link 0.2.1",+]++[[package]]+name = "jni-macros"+version = "0.22.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"+dependencies = [+ "proc-macro2",+ "quote",+ "rustc_version",+ "simd_cesu8",+ "syn 2.0.117",+]+[[package]]name = "jni-sys"version = "0.3.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"+[[package]]+name = "jni-sys"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"+dependencies = [+ "jni-sys-macros",+]++[[package]]+name = "jni-sys-macros"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"+dependencies = [+ "quote",+ "syn 2.0.117",+]+[[package]]name = "js-sys"version = "0.3.87"@@ -3386,12 +3534,9 @@ checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"[[package]]name = "mach2"-version = "0.4.3"+version = "0.6.0"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"-dependencies = [- "libc",-]+checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"[[package]]name = "macos-accessibility-client"@@ -3539,6 +3684,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"dependencies = ["libc",+ "log","wasi 0.11.1+wasi-snapshot-preview1","windows-sys 0.61.2",]@@ -3622,7 +3768,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"dependencies = ["bitflags 2.11.0",- "jni-sys",+ "jni-sys 0.3.0","log","ndk-sys","num_enum",@@ -3642,7 +3788,7 @@ version = "0.6.0+11769913"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"dependencies = [- "jni-sys",+ "jni-sys 0.3.0",][[package]]@@ -3861,6 +4007,28 @@ dependencies = ["objc2-foundation",]+[[package]]+name = "objc2-av-foundation"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "478ae33fcac9df0a18db8302387c666b8ef08a3e2d62b510ca4fc278a384b6c0"+dependencies = [+ "bitflags 2.11.0",+ "objc2",+ "objc2-foundation",+]++[[package]]+name = "objc2-avf-audio"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be"+dependencies = [+ "bitflags 2.11.0",+ "objc2",+ "objc2-foundation",+]+[[package]]name = "objc2-cloud-kit"version = "0.3.2"@@ -3882,6 +4050,7 @@ dependencies = ["objc2","objc2-core-audio-types","objc2-core-foundation",+ "objc2-foundation",][[package]]@@ -4781,6 +4950,22 @@ dependencies = ["syn 1.0.109",]+[[package]]+name = "pulseaudio"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d70623bd7967a9ca4c2ae0e807fc380b291f98480fc037042305ec643a4d3373"+dependencies = [+ "bitflags 2.11.0",+ "byteorder",+ "enum-primitive-derive",+ "futures",+ "log",+ "mio 1.1.1",+ "num-traits",+ "thiserror 1.0.69",+]+[[package]]name = "pxfm"version = "0.1.27"@@ -5236,13 +5421,15 @@ dependencies = [[[package]]name = "rodio"-version = "0.20.1"-source = "git+https://github.com/cjpais/rodio.git#fed30292db417cb95305c118c0e1d804fb74cbff"+version = "0.23.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "36e3ee0a5ca418bac59a15d5506e498ab138359edbb67257a6b8a3b93d411f39"dependencies = ["cpal","dasp_sample","num-rational","symphonia",+ "thiserror 2.0.18",][[package]]@@ -5253,14 +5440,18 @@ checksum = "9278fb35b3e730abe136e9b395b5b81b96d06b9f5478a50f0c8430a2237b22de"[[package]]name = "rubato"-version = "0.16.2"+version = "5.0.0"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "5258099699851cfd0082aeb645feb9c084d9a5e1f1b8d5372086b989fc5e56a1"+checksum = "a7cb1ffaf8738df50aab642a7f6465df81c6ba9e2818268053487165298114be"dependencies = [+ "audioadapter",+ "audioadapter-buffers","num-complex","num-integer","num-traits","realfft",+ "visibility",+ "windowfunctions",][[package]]@@ -5399,7 +5590,7 @@ checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"dependencies = ["core-foundation 0.10.1","core-foundation-sys",- "jni",+ "jni 0.21.1","log","once_cell","rustls",@@ -5814,6 +6005,16 @@ version = "0.3.8"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"+[[package]]+name = "simd_cesu8"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520"+dependencies = [+ "rustc_version",+ "simdutf8",+]+[[package]]name = "simdutf8"version = "0.1.5"@@ -6069,11 +6270,9 @@ dependencies = ["lazy_static","symphonia-bundle-flac","symphonia-bundle-mp3",- "symphonia-codec-aac","symphonia-codec-pcm","symphonia-codec-vorbis","symphonia-core",- "symphonia-format-isomp4","symphonia-format-ogg","symphonia-format-riff","symphonia-metadata",@@ -6103,17 +6302,6 @@ dependencies = ["symphonia-metadata",]-[[package]]-name = "symphonia-codec-aac"-version = "0.5.5"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "4c263845aa86881416849c1729a54c7f55164f8b96111dba59de46849e73a790"-dependencies = [- "lazy_static",- "log",- "symphonia-core",-]-[[package]]name = "symphonia-codec-pcm"version = "0.5.5"@@ -6148,19 +6336,6 @@ dependencies = ["log",]-[[package]]-name = "symphonia-format-isomp4"-version = "0.5.5"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "243739585d11f81daf8dac8d9f3d18cc7898f6c09a259675fc364b382c30e0a5"-dependencies = [- "encoding_rs",- "log",- "symphonia-core",- "symphonia-metadata",- "symphonia-utils-xiph",-]-[[package]]name = "symphonia-format-ogg"version = "0.5.5"@@ -6322,7 +6497,7 @@ dependencies = ["gdkwayland-sys","gdkx11-sys","gtk",- "jni",+ "jni 0.21.1","libc","log","ndk",@@ -6402,7 +6577,7 @@ dependencies = ["http","http-range","image",- "jni",+ "jni 0.21.1","libc","log","mime",@@ -6773,7 +6948,7 @@ dependencies = ["dpi","gtk","http",- "jni",+ "jni 0.21.1","objc2","objc2-ui-kit","objc2-web-kit",@@ -6796,7 +6971,7 @@ checksum = "4e6fac707727b7a2f48e4ded90976324267371073edbb415ffb73bb0458d203f"dependencies = ["gtk","http",- "jni",+ "jni 0.21.1","log","objc2","objc2-app-kit",@@ -7619,6 +7794,17 @@ version = "0.0.18"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"+[[package]]+name = "visibility"+version = "0.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d674d135b4a8c1d7e813e2f8d1c9a58308aee4a680323066025e53132218bd91"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.117",+]+[[package]]name = "vswhom"version = "0.1.0"@@ -8115,13 +8301,12 @@ dependencies = [][[package]]-name = "windows"-version = "0.54.0"+name = "windowfunctions"+version = "0.1.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "9252e5725dbed82865af151df558e754e4a3c2c30818359eb17465f1346a1b49"+checksum = "90628d739333b7c5d2ee0b70210b97b8cddc38440c682c96fd9e2c24c2db5f3a"dependencies = [- "windows-core 0.54.0",- "windows-targets 0.52.6",+ "num-traits",][[package]]@@ -8140,11 +8325,23 @@ version = "0.61.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"dependencies = [- "windows-collections",+ "windows-collections 0.2.0","windows-core 0.61.2",- "windows-future",+ "windows-future 0.2.1","windows-link 0.1.3",- "windows-numerics",+ "windows-numerics 0.2.0",+]++[[package]]+name = "windows"+version = "0.62.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"+dependencies = [+ "windows-collections 0.3.2",+ "windows-core 0.62.2",+ "windows-future 0.3.2",+ "windows-numerics 0.3.1",][[package]]@@ -8157,13 +8354,12 @@ dependencies = [][[package]]-name = "windows-core"-version = "0.54.0"+name = "windows-collections"+version = "0.3.2"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "12661b9c89351d684a50a8a643ce5f608e20243b9fb84687800163429f161d65"+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"dependencies = [- "windows-result 0.1.2",- "windows-targets 0.52.6",+ "windows-core 0.62.2",][[package]]@@ -8192,6 +8388,19 @@ dependencies = ["windows-strings 0.4.2",]+[[package]]+name = "windows-core"+version = "0.62.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"+dependencies = [+ "windows-implement 0.60.2",+ "windows-interface 0.59.3",+ "windows-link 0.2.1",+ "windows-result 0.4.1",+ "windows-strings 0.5.1",+]+[[package]]name = "windows-future"version = "0.2.1"@@ -8200,7 +8409,18 @@ checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"dependencies = ["windows-core 0.61.2","windows-link 0.1.3",- "windows-threading",+ "windows-threading 0.1.0",+]++[[package]]+name = "windows-future"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"+dependencies = [+ "windows-core 0.62.2",+ "windows-link 0.2.1",+ "windows-threading 0.2.1",][[package]]@@ -8270,23 +8490,24 @@ dependencies = [][[package]]-name = "windows-registry"-version = "0.6.1"+name = "windows-numerics"+version = "0.3.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"dependencies = [+ "windows-core 0.62.2","windows-link 0.2.1",- "windows-result 0.4.1",- "windows-strings 0.5.1",][[package]]-name = "windows-result"-version = "0.1.2"+name = "windows-registry"+version = "0.6.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"dependencies = [- "windows-targets 0.52.6",+ "windows-link 0.2.1",+ "windows-result 0.4.1",+ "windows-strings 0.5.1",][[package]]@@ -8470,6 +8691,15 @@ dependencies = ["windows-link 0.1.3",]+[[package]]+name = "windows-threading"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"+dependencies = [+ "windows-link 0.2.1",+]+[[package]]name = "windows-version"version = "0.1.7"@@ -8826,7 +9056,7 @@ dependencies = ["gtk","http","javascriptcore-rs",- "jni",+ "jni 0.21.1","libc","ndk","objc2",diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.tomlindex 00c9e4ce..9ec8e8f2 100644--- a/src-tauri/Cargo.toml+++ b/src-tauri/Cargo.toml@@ -19,10 +19,6 @@ incremental = true # Compile your binary in smaller steps.name = "handy_app_lib"crate-type = ["staticlib", "cdylib", "rlib"]-# [[bin]]-# name = "cli"-# path = "src/audio_toolkit/bin/cli.rs"-[build-dependencies]tauri-build = { version = "2", features = [] }serde_json = "1"@@ -48,10 +44,7 @@ tauri-plugin-fs = "2.4.4"serde = { version = "1", features = ["derive"] }serde_json = "1"rdev = { git = "https://github.com/rustdesk-org/rdev" }-cpal = "0.16.0"-rtrb = "0.4.0"anyhow = "1.0.95"-rubato = "0.16.2"hound = "3.5.1"log = "0.4.25"env_filter = "0.1.0"@@ -59,7 +52,9 @@ tokio = "1.43.0"vad-rs = { git = "https://github.com/cjpais/vad-rs", default-features = false }earshot = "1.2.2"enigo = "0.6.1"-rodio = { git = "https://github.com/cjpais/rodio.git" }+# Feedback sounds. No `recording`: microphone capture is handy-recorder's.+rodio = { version = "0.23.0", default-features = false, features = ["playback", "wav", "flac", "mp3", "vorbis"] }+handy-recorder = "0.1"reqwest = { version = "0.12", features = ["json", "stream", "gzip", "brotli", "deflate"] }futures-util = "0.3"rustfft = "6.4.0"diff --git a/src-tauri/build.rs b/src-tauri/build.rsindex 46d4e9d3..ed048a57 100644--- a/src-tauri/build.rs+++ b/src-tauri/build.rs@@ -19,6 +19,13 @@ fn main() {println!("cargo:rustc-link-arg=-Wl,-rpath,$ORIGIN/../lib/Handy:$ORIGIN/../lib");}+ // CPAL (handy-recorder's and rodio's) links two CoreAudio functions that+ // only exist on macOS 14.2+. Weak-link the framework so Handy still+ // launches on older macOS (minimumSystemVersion is 10.15).+ if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("macos") {+ println!("cargo:rustc-link-arg=-Wl,-weak_framework,CoreAudio");+ }+// Stage transcribe-cpp's shared runtime libraries (and the dlopen'd ggml// backend modules) for the installer. Self-gates on the shared /// dynamic-backends posture used by Linux and Windows; it's a no-op for thediff --git a/src-tauri/src/actions.rs b/src-tauri/src/actions.rsindex 04d88644..b2db42d3 100644--- a/src-tauri/src/actions.rs+++ b/src-tauri/src/actions.rs@@ -1,8 +1,8 @@#[cfg(all(target_os = "macos", target_arch = "aarch64"))]use crate::apple_intelligence;use crate::audio_feedback::{play_feedback_sound, play_feedback_sound_blocking, SoundType};-use crate::audio_toolkit::{is_microphone_access_denied, is_no_input_device_error, VadPolicy};-use crate::managers::audio::AudioRecordingManager;+use crate::audio_toolkit::VadPolicy;+use crate::managers::audio::{recording_error_type, AudioRecordingManager};use crate::managers::history::HistoryManager;use crate::managers::model::ModelManager;use crate::managers::transcription::StreamWorkKind;@@ -470,7 +470,7 @@ impl ShortcutAction for TranscribeAction {);debug!("Microphone mode - always_on: {}", is_always_on);- let mut recording_error: Option<String> = None;+ let mut recording_error: Option<anyhow::Error> = None;let recording_start_time = Instant::now();match rm.try_start_recording(&binding_id, vad_policy) {Ok(readiness) => {@@ -538,18 +538,11 @@ impl ShortcutAction for TranscribeAction {utils::hide_recording_overlay(app);set_tray_state(app, TrayIconState::Idle);if let Some(err) = recording_error {- let error_type = if is_microphone_access_denied(&err) {- "microphone_permission_denied"- } else if is_no_input_device_error(&err) {- "no_input_device"- } else {- "unknown"- };let _ = app.emit("recording-error",RecordingErrorEvent {- error_type: error_type.to_string(),- detail: Some(err),+ error_type: recording_error_type(&err).to_string(),+ detail: Some(format!("{err:#}")),},);}diff --git a/src-tauri/src/audio_feedback.rs b/src-tauri/src/audio_feedback.rsindex ef759a13..2940dada 100644--- a/src-tauri/src/audio_feedback.rs+++ b/src-tauri/src/audio_feedback.rs@@ -1,8 +1,9 @@+use crate::audio_toolkit::audio::output_device_name;use crate::settings::SoundTheme;use crate::settings::{self, AppSettings};-use cpal::traits::{DeviceTrait, HostTrait};use log::{debug, error, warn};-use rodio::OutputStreamBuilder;+use rodio::cpal::traits::HostTrait;+use rodio::DeviceSinkBuilder;use std::fs::File;use std::io::BufReader;use std::path::{Path, PathBuf};@@ -99,44 +100,38 @@ fn play_audio_file(selected_device: Option<String>,volume: f32,) -> Result<(), Box<dyn std::error::Error>> {- let stream_builder = if let Some(device_name) = selected_device {+ let sink_builder = if let Some(device_name) = selected_device {if device_name == "Default" {debug!("Using default device");- OutputStreamBuilder::from_default_device()?+ DeviceSinkBuilder::from_default_device()?} else {let host = crate::audio_toolkit::get_cpal_host();- let devices = host.output_devices()?;-- let mut found_device = None;- for device in devices {- if device.name()? == device_name {- found_device = Some(device);- break;- }- }+ let found_device = host+ .output_devices()?+ .find(|device| output_device_name(device).as_deref() == Some(&device_name));match found_device {- Some(device) => OutputStreamBuilder::from_device(device)?,+ Some(device) => DeviceSinkBuilder::from_device(device)?,None => {warn!("Device '{}' not found, using default device", device_name);- OutputStreamBuilder::from_default_device()?+ DeviceSinkBuilder::from_default_device()?}}}} else {debug!("Using default device");- OutputStreamBuilder::from_default_device()?+ DeviceSinkBuilder::from_default_device()?};- let stream_handle = stream_builder.open_stream()?;- let mixer = stream_handle.mixer();+ let device_sink = sink_builder.open_stream()?;+ let mixer = device_sink.mixer();let file = File::open(path)?;let buf_reader = BufReader::new(file);- let sink = rodio::play(mixer, buf_reader)?;- sink.set_volume(volume);- sink.sleep_until_end();+ let player = rodio::play(mixer, buf_reader)?;+ player.set_volume(volume);+ player.sleep_until_end();Ok(())}diff --git a/src-tauri/src/audio_toolkit/audio/device.rs b/src-tauri/src/audio_toolkit/audio/device.rsindex 61e8fcc2..f4caec60 100644--- a/src-tauri/src/audio_toolkit/audio/device.rs+++ b/src-tauri/src/audio_toolkit/audio/device.rs@@ -1,50 +1,38 @@-use cpal::traits::{DeviceTrait, HostTrait};--pub struct CpalDeviceInfo {+use rodio::cpal::{+ self,+ traits::{DeviceTrait, HostTrait},+};++/// An output device for feedback sounds. Microphones are listed by+/// `handy_recorder::list_input_devices`.+pub struct OutputDeviceInfo {pub index: String,pub name: String,pub is_default: bool,- pub device: cpal::Device,}-pub fn list_input_devices() -> Result<Vec<CpalDeviceInfo>, Box<dyn std::error::Error>> {- let host = crate::audio_toolkit::get_cpal_host();- let default_name = host.default_input_device().and_then(|d| d.name().ok());-- let mut out = Vec::<CpalDeviceInfo>::new();-- for (index, device) in host.input_devices()?.enumerate() {- let name = device.name().unwrap_or_else(|_| "Unknown".into());-- let is_default = Some(name.clone()) == default_name;-- out.push(CpalDeviceInfo {- index: index.to_string(),- name,- is_default,- device,- });- }-- Ok(out)+/// The name feedback sounds match `selected_output_device` against.+pub fn output_device_name(device: &cpal::Device) -> Option<String> {+ device.description().ok().map(|d| d.name().to_owned())}-pub fn list_output_devices() -> Result<Vec<CpalDeviceInfo>, Box<dyn std::error::Error>> {+pub fn list_output_devices() -> Result<Vec<OutputDeviceInfo>, Box<dyn std::error::Error>> {let host = crate::audio_toolkit::get_cpal_host();- let default_name = host.default_output_device().and_then(|d| d.name().ok());+ let default_name = host+ .default_output_device()+ .and_then(|d| output_device_name(&d));- let mut out = Vec::<CpalDeviceInfo>::new();+ let mut out = Vec::<OutputDeviceInfo>::new();for (index, device) in host.output_devices()?.enumerate() {- let name = device.name().unwrap_or_else(|_| "Unknown".into());+ let name = output_device_name(&device).unwrap_or_else(|| "Unknown".into());let is_default = Some(name.clone()) == default_name;- out.push(CpalDeviceInfo {+ out.push(OutputDeviceInfo {index: index.to_string(),name,is_default,- device,});}diff --git a/src-tauri/src/audio_toolkit/audio/mod.rs b/src-tauri/src/audio_toolkit/audio/mod.rsindex 40ef7f47..0a21c9cb 100644--- a/src-tauri/src/audio_toolkit/audio/mod.rs+++ b/src-tauri/src/audio_toolkit/audio/mod.rs@@ -1,14 +1,12 @@// Re-export all audio componentsmod device;-mod recorder;-mod resampler;+mod sink;mod utils;mod visualizer;-pub use device::{list_input_devices, list_output_devices, CpalDeviceInfo};-pub use recorder::{- is_microphone_access_denied, is_no_input_device_error, AudioRecorder, VadPolicy,+pub use device::{list_output_devices, output_device_name, OutputDeviceInfo};+pub use sink::{+ AudioFrameCallback, CaptureSink, CaptureVad, CapturedAudio, LevelCallback, VadPolicy,};-pub use resampler::FrameResampler;pub use utils::{read_wav_samples, save_wav_file, verify_wav_file};pub use visualizer::AudioVisualiser;diff --git a/src-tauri/src/audio_toolkit/audio/recorder.rs b/src-tauri/src/audio_toolkit/audio/recorder.rsdeleted file mode 100644index e7c848bc..00000000--- a/src-tauri/src/audio_toolkit/audio/recorder.rs+++ /dev/null@@ -1,1046 +0,0 @@-use std::{- io::Error,- sync::{- atomic::{AtomicBool, AtomicU64, Ordering},- mpsc, Arc, Mutex,- },- time::{Duration, Instant},-};--use cpal::{- traits::{DeviceTrait, HostTrait, StreamTrait},- Device, Sample, SizedSample,-};-use rtrb::{Consumer, Producer, RingBuffer};--use crate::audio_toolkit::{- audio::{AudioVisualiser, FrameResampler},- constants,- vad::{self, VadFrame},- VoiceActivityDetector,-};--enum Cmd {- /// Begin capturing. Carries the send timestamp so the consumer can log how- /// long the command sat in the channel, plus a one-shot first-sample acknowledgement.- Start(VadPolicy, Instant, mpsc::Sender<()>),- Stop(mpsc::Sender<Vec<f32>>),- Shutdown,-}--// Two seconds of ring capacity absorbs consumer stalls without adding latency-// during normal 10 ms drains.-const AUDIO_RING_SECONDS: usize = 2;-const CONSUMER_POLL_INTERVAL: Duration = Duration::from_millis(10);-const MAX_DRAIN_CHUNK: Duration = Duration::from_millis(50);-const PAUSE_ACK_TIMEOUT: Duration = Duration::from_secs(2);--/// Atomics shared by the callback and consumer; audio uses a wait-free SPSC ring.-/// The callback must remain allocation-, lock-, logging-, and blocking-free.-#[derive(Default)]-struct CaptureTransportState {- pause_requested: AtomicBool,- /// Set after forwarding a pause's boundary block; subsequent callbacks- /// remain silent until the consumer clears the request.- pause_acknowledged: AtomicBool,- overrun_samples: AtomicU64,-}--/// How 16 kHz mono frames should be filtered for one recording session.-#[derive(Clone, Copy, Debug, PartialEq, Eq)]-pub enum VadPolicy {- /// Bypass VAD and forward every frame.- Disabled,- /// Current offline-tuned VAD profile.- Offline,- /// VAD profile with a longer post-speech tail for streaming-capable models.- Streaming,-}--/// A single VAD engine plus the two hangover-tail lengths its smoothing wrapper-/// should use. The offline and streaming policies are never active-/// concurrently, so one detector is reconfigured per session (see `Cmd::Start`)-/// rather than kept as two resident engines.-#[derive(Clone)]-struct VadConfig {- detector: Arc<Mutex<Box<dyn vad::VoiceActivityDetector>>>,- frame_samples: usize,- offline_hangover_frames: usize,- streaming_hangover_frames: usize,-}--impl VadConfig {- /// Post-speech hangover tail (in backend-sized frames) for the given policy.- /// `Disabled` never reaches the detector, so it maps to the offline value.- fn hangover_for(&self, policy: VadPolicy) -> usize {- match policy {- VadPolicy::Streaming => self.streaming_hangover_frames,- VadPolicy::Offline | VadPolicy::Disabled => self.offline_hangover_frames,- }- }-}--/// Callback invoked with each 16 kHz mono frame that passes the active capture-/// policy while recording. Used to feed a live streaming transcription as audio arrives.-pub type AudioFrameCallback = Arc<dyn Fn(&[f32]) + Send + Sync + 'static>;-pub type LevelCallback = Arc<dyn Fn(Vec<f32>) + Send + Sync + 'static>;--pub struct AudioRecorder {- device: Option<Device>,- cmd_tx: Option<mpsc::Sender<Cmd>>,- worker_handle: Option<std::thread::JoinHandle<()>>,- vad: Option<VadConfig>,- level_cb: Option<LevelCallback>,- audio_cb: Option<AudioFrameCallback>,- /// Which input channel to use. None = average all (original behavior).- selected_channel: Option<usize>,- /// Preferred stream config cached per device name. The two HAL property- /// queries in `get_preferred_config` cost ~40-85ms per open (worse on- /// USB/Bluetooth), which lands on the keypress->capture path in on-demand- /// mode. Keyed by name so a system-default change misses naturally;- /// cleared whenever an open fails so a stale rate/format self-heals on the- /// caller's retry.- config_cache: Arc<Mutex<Option<(String, cpal::SupportedStreamConfig)>>>,- /// Set by cpal when the active input stream can no longer capture.- stream_error: Arc<AtomicBool>,-}--impl AudioRecorder {- pub fn new() -> Result<Self, Box<dyn std::error::Error>> {- Ok(AudioRecorder {- device: None,- cmd_tx: None,- worker_handle: None,- vad: None,- level_cb: None,- audio_cb: None,- selected_channel: None,- config_cache: Arc::new(Mutex::new(None)),- stream_error: Arc::new(AtomicBool::new(false)),- })- }-- /// Attach a single VAD engine, reconfigured per session for the offline vs- /// streaming hangover tail. The two policies are mutually exclusive within a- /// recording, so one engine covers both instead of two resident instances.- pub fn with_vad(- mut self,- detector: Box<dyn VoiceActivityDetector>,- offline_hangover_frames: usize,- streaming_hangover_frames: usize,- ) -> Self {- let frame_samples = detector.frame_samples();- assert!(frame_samples > 0, "VAD frame size must be non-zero");- self.vad = Some(VadConfig {- detector: Arc::new(Mutex::new(detector)),- frame_samples,- offline_hangover_frames,- streaming_hangover_frames,- });- self- }-- pub fn with_level_callback<F>(mut self, cb: F) -> Self- where- F: Fn(Vec<f32>) + Send + Sync + 'static,- {- self.level_cb = Some(Arc::new(cb));- self- }-- /// Register a callback that receives real-time 16 kHz frames after the active- /// VAD policy has been applied. Frames arrive in real time, in order, on the- /// recorder's consumer thread — keep the callback cheap (e.g. forward to a- /// channel) so it never stalls capture.- pub fn with_audio_callback<F>(mut self, cb: F) -> Self- where- F: Fn(&[f32]) + Send + Sync + 'static,- {- self.audio_cb = Some(Arc::new(cb));- self- }-- pub fn with_selected_channel(mut self, channel: Option<u16>) -> Self {- self.set_selected_channel(channel);- self- }-- pub fn set_selected_channel(&mut self, channel: Option<u16>) {- self.selected_channel = channel.map(usize::from);- }-- pub fn open(&mut self, device: Option<Device>) -> Result<(), Box<dyn std::error::Error>> {- if self.worker_handle.is_some() {- if !self.needs_reopen() {- return Ok(()); // already open- }- log::warn!("Capture stream failed; rebuilding microphone stream");- self.close()?;- }-- self.stream_error.store(false, Ordering::Relaxed);-- let (cmd_tx, cmd_rx) = mpsc::channel::<Cmd>();- let (init_tx, init_rx) = mpsc::sync_channel::<Result<(), String>>(1);-- let host = crate::audio_toolkit::get_cpal_host();- let device = match device {- Some(dev) => dev,- None => host- .default_input_device()- .ok_or_else(|| Error::new(std::io::ErrorKind::NotFound, "No input device found"))?,- };-- let thread_device = device.clone();- let vad = self.vad.clone();- // Move the optional level callback into the worker thread- let level_cb = self.level_cb.clone();- // Move the optional real-time audio frame callback into the worker thread- let audio_cb = self.audio_cb.clone();- let selected_channel = self.selected_channel;- let config_cache = Arc::clone(&self.config_cache);- let stream_error = Arc::clone(&self.stream_error);-- let worker = std::thread::spawn(move || {- let transport = Arc::new(CaptureTransportState::default());- let init_result = (|| -> Result<(cpal::Stream, u32, Consumer<f32>), String> {- let config_started = Instant::now();- let device_name = thread_device.name().unwrap_or_default();- let cached_config = config_cache- .lock()- .unwrap()- .as_ref()- .filter(|(name, _)| !device_name.is_empty() && *name == device_name)- .map(|(_, cfg)| cfg.clone());- let config_was_cached = cached_config.is_some();- let config = match cached_config {- Some(cfg) => cfg,- None => AudioRecorder::get_preferred_config(&thread_device)- .map_err(|e| format!("Failed to fetch preferred config: {e}"))?,- };- let config_elapsed = config_started.elapsed();-- let sample_rate = config.sample_rate().0;- let channels = config.channels() as usize;-- log::info!(- "Using device: {:?}\nSample rate: {}\nChannels: {}\nFormat: {:?}",- thread_device.name(),- sample_rate,- channels,- config.sample_format()- );-- if let Some(channel) = selected_channel {- if channel < channels {- log::info!("Using selected input channel: {}", channel + 1);- } else {- log::warn!(- "Selected input channel {} is out of range for a {}-channel device; averaging all channels instead",- channel + 1,- channels- );- }- } else {- log::info!("Averaging all {} input channels", channels);- }-- let build_started = Instant::now();- let (stream, sample_consumer) = match config.sample_format() {- cpal::SampleFormat::U8 => AudioRecorder::build_stream::<u8>(- &thread_device,- &config,- channels,- selected_channel,- Arc::clone(&transport),- Arc::clone(&stream_error),- ),- cpal::SampleFormat::I8 => AudioRecorder::build_stream::<i8>(- &thread_device,- &config,- channels,- selected_channel,- Arc::clone(&transport),- Arc::clone(&stream_error),- ),- cpal::SampleFormat::I16 => AudioRecorder::build_stream::<i16>(- &thread_device,- &config,- channels,- selected_channel,- Arc::clone(&transport),- Arc::clone(&stream_error),- ),- cpal::SampleFormat::I32 => AudioRecorder::build_stream::<i32>(- &thread_device,- &config,- channels,- selected_channel,- Arc::clone(&transport),- Arc::clone(&stream_error),- ),- cpal::SampleFormat::F32 => AudioRecorder::build_stream::<f32>(- &thread_device,- &config,- channels,- selected_channel,- Arc::clone(&transport),- Arc::clone(&stream_error),- ),- sample_format => {- return Err(format!("Unsupported sample format: {sample_format:?}"));- }- }- .map_err(|e| format!("Failed to build input stream: {e}"))?;- let build_elapsed = build_started.elapsed();-- let play_started = Instant::now();- stream- .play()- .map_err(|e| format!("Failed to start microphone stream: {e}"))?;- log::debug!(- "mic worker init: fetch_config={:?} (cached={}) build_stream={:?} play={:?}",- config_elapsed,- config_was_cached,- build_elapsed,- play_started.elapsed()- );-- // The device accepted this config; remember it so the next- // open skips the HAL property queries entirely.- if !config_was_cached && !device_name.is_empty() {- *config_cache.lock().unwrap() = Some((device_name, config));- }-- Ok((stream, sample_rate, sample_consumer))- })();-- match init_result {- Ok((stream, sample_rate, sample_consumer)) => {- let _ = init_tx.send(Ok(()));- // Timestamp for the play()-returned -> first-samples gap the- // init handshake can't see (hardware dependent).- let stream_running_at = Instant::now();- let processor = CaptureProcessor::new(- sample_rate,- vad,- level_cb,- audio_cb,- stream_running_at,- );- run_consumer(- processor,- sample_consumer,- cmd_rx,- transport,- Arc::clone(&stream_error),- );- drop(stream);- }- Err(error_message) => {- // A failed open may mean the cached config went stale- // (device re-plugged, rate/format changed in the OS).- // Drop it so the next attempt re-queries the device.- *config_cache.lock().unwrap() = None;- log::error!("{error_message}");- let _ = init_tx.send(Err(error_message));- }- }- });-- match init_rx.recv() {- Ok(Ok(())) => {- self.device = Some(device);- self.cmd_tx = Some(cmd_tx);- self.worker_handle = Some(worker);- Ok(())- }- Ok(Err(error_message)) => {- let _ = worker.join();- let kind = if is_microphone_access_denied(&error_message) {- std::io::ErrorKind::PermissionDenied- } else {- std::io::ErrorKind::Other- };- Err(Box::new(Error::new(kind, error_message)))- }- Err(recv_error) => {- let _ = worker.join();- Err(Box::new(Error::other(format!(- "Failed to initialize microphone worker: {recv_error}"- ))))- }- }- }-- /// Queue a recording start and return a one-shot receiver that resolves only- /// after the first real microphone sample chunk has entered the capture path.- /// `Stream::play()` returning is not sufficient: some Bluetooth and USB- /// devices take much longer to begin delivering callbacks.- pub fn start(- &self,- vad_policy: VadPolicy,- ) -> Result<mpsc::Receiver<()>, Box<dyn std::error::Error>> {- let tx = self- .cmd_tx- .as_ref()- .ok_or_else(|| Error::other("Recorder is not open"))?;- let (ready_tx, ready_rx) = mpsc::channel();- tx.send(Cmd::Start(vad_policy, Instant::now(), ready_tx))?;- Ok(ready_rx)- }-- pub fn stop(&self) -> Result<Vec<f32>, Box<dyn std::error::Error>> {- let tx = self- .cmd_tx- .as_ref()- .ok_or_else(|| Error::other("Recorder is not open"))?;- let (resp_tx, resp_rx) = mpsc::channel();- tx.send(Cmd::Stop(resp_tx))?;- Ok(resp_rx.recv()?)- }-- /// True when the active capture stream must be rebuilt.- ///- /// cpal may report a device disconnect asynchronously without closing its- /// callback channel, so also honor the error callback's explicit flag.- pub fn needs_reopen(&self) -> bool {- self.stream_error.load(Ordering::Relaxed)- || self- .worker_handle- .as_ref()- .is_some_and(|handle| handle.is_finished())- }-- pub fn close(&mut self) -> Result<(), Box<dyn std::error::Error>> {- if let Some(tx) = self.cmd_tx.take() {- let _ = tx.send(Cmd::Shutdown);- }- if let Some(handle) = self.worker_handle.take() {- let _ = handle.join();- }- self.device = None;- Ok(())- }-- fn build_stream<T>(- device: &cpal::Device,- config: &cpal::SupportedStreamConfig,- channels: usize,- selected_channel: Option<usize>,- transport: Arc<CaptureTransportState>,- stream_error: Arc<AtomicBool>,- ) -> Result<(cpal::Stream, Consumer<f32>), cpal::BuildStreamError>- where- T: Sample + SizedSample + Copy + Send + 'static,- f32: cpal::FromSample<T>,- {- let ring_capacity = config.sample_rate().0 as usize * AUDIO_RING_SECONDS;- let (mut sample_producer, mut sample_consumer) = RingBuffer::new(ring_capacity);-- // Touch rtrb's uninitialized pages before the stream starts to reduce- // callback page faults. This does not pin them.- {- let chunk = sample_producer- .write_chunk(ring_capacity)- .expect("new audio ring has its full capacity available");- chunk.commit_all();- }- {- let chunk = sample_consumer- .read_chunk(ring_capacity)- .expect("pre-filled audio ring is readable");- chunk.commit_all();- }-- // Resolve the effective channel to use. If the selected channel is- // out of range for this device, fall back to averaging all channels.- let use_channel = selected_channel.filter(|&channel| channel < channels);- let callback_transport = Arc::clone(&transport);- let stream_cb = move |data: &[T], _: &cpal::InputCallbackInfo| {- Self::write_input_to_ring(- data,- channels,- use_channel,- &mut sample_producer,- &callback_transport,- );- };-- let stream = device.build_input_stream(- &config.clone().into(),- stream_cb,- move |_err| {- // Error callbacks may share the platform audio thread. Defer- // logging and recovery to the consumer/manager path.- stream_error.store(true, Ordering::Release);- },- None,- )?;- Ok((stream, sample_consumer))- }-- /// Real-time callback body. Keep this allocation-free, wait-free, and free- /// of locks, logging, clocks, and system calls.- fn write_input_to_ring<T>(- data: &[T],- channels: usize,- use_channel: Option<usize>,- producer: &mut Producer<f32>,- transport: &CaptureTransportState,- ) where- T: Sample + SizedSample + Copy,- f32: cpal::FromSample<T>,- {- // Forward the first block that observes a pause; once acknowledged,- // remain silent until the consumer resumes capture.- if transport.pause_requested.load(Ordering::Acquire)- && transport.pause_acknowledged.load(Ordering::Acquire)- {- return;- }-- let frame_count = data.len() / channels;- let writable_frames = producer.slots().min(frame_count);- let written = if writable_frames == 0 {- 0- } else {- let chunk = producer- .write_chunk_uninit(writable_frames)- .expect("the producer just reported this many writable slots");- if channels == 1 {- chunk.fill_from_iter(- data.iter()- .take(writable_frames)- .map(|&sample| sample.to_sample::<f32>()),- )- } else if let Some(channel) = use_channel {- chunk.fill_from_iter(- data.chunks_exact(channels)- .take(writable_frames)- .map(|frame| frame[channel].to_sample::<f32>()),- )- } else {- chunk.fill_from_iter(data.chunks_exact(channels).take(writable_frames).map(- |frame| {- frame- .iter()- .map(|&sample| sample.to_sample::<f32>())- .sum::<f32>()- / channels as f32- },- ))- }- };- debug_assert_eq!(written, writable_frames);-- let dropped = frame_count - written;- if dropped > 0 {- transport- .overrun_samples- .fetch_add(dropped as u64, Ordering::Relaxed);- }-- // Publish the boundary write before acknowledging, including when the- // pause request arrives during the write.- acknowledge_pause_after_write(transport);- }-- pub fn preferred_input_channel_count(- device: &cpal::Device,- ) -> Result<u16, Box<dyn std::error::Error>> {- Ok(Self::get_preferred_config(device)?.channels())- }-- fn get_preferred_config(- device: &cpal::Device,- ) -> Result<cpal::SupportedStreamConfig, Box<dyn std::error::Error>> {- // Use the device's native/default sample rate and let the FrameResampler- // in run_consumer() downsample to 16kHz. This avoids forcing hardware into- // a non-native rate which can cause issues on some devices (Bluetooth- // codecs, certain ALSA drivers, etc.).- let default_config = device.default_input_config()?;- let target_rate = default_config.sample_rate();-- // Try to find the best sample format at the device's default rate- let supported_configs = match device.supported_input_configs() {- Ok(configs) => configs,- Err(e) => {- log::warn!("Could not enumerate input configs ({e}), using device default");- return Ok(default_config);- }- };- let mut best_config: Option<cpal::SupportedStreamConfigRange> = None;-- for config_range in supported_configs {- if config_range.min_sample_rate() <= target_rate- && config_range.max_sample_rate() >= target_rate- {- match best_config {- None => best_config = Some(config_range),- Some(ref current) => {- // Prioritize F32 > I16 > I32 > others- let score = |fmt: cpal::SampleFormat| match fmt {- cpal::SampleFormat::F32 => 4,- cpal::SampleFormat::I16 => 3,- cpal::SampleFormat::I32 => 2,- _ => 1,- };-- if score(config_range.sample_format()) > score(current.sample_format()) {- best_config = Some(config_range);- }- }- }- }- }-- if let Some(config) = best_config {- return Ok(config.with_sample_rate(target_rate));- }-- // Fall back to device default if no config matched (exotic/virtual devices)- log::warn!(- "No supported config matched device default rate {:?}, using default config",- target_rate- );- Ok(default_config)- }-}--fn acknowledge_pause_after_write(transport: &CaptureTransportState) {- if transport.pause_requested.load(Ordering::Acquire) {- transport.pause_acknowledged.store(true, Ordering::Release);- }-}--pub fn is_microphone_access_denied(error_message: &str) -> bool {- let normalized = error_message.to_lowercase();- normalized.contains("access is denied")- || normalized.contains("permission denied")- || normalized.contains("0x80070005")-}--pub fn is_no_input_device_error(error_message: &str) -> bool {- let normalized = error_message.to_lowercase();- normalized.contains("no input device found")- || (normalized.contains("failed to fetch preferred config")- && normalized.contains("coreaudio"))-}--/// Route one 16 kHz frame through VAD to recording and live outputs.-/// Kept free-standing to permit disjoint borrows around resampler callbacks.-fn handle_frame(- samples: &[f32],- vad_policy: VadPolicy,- vad: &Option<VadConfig>,- audio_cb: &Option<AudioFrameCallback>,- out_buf: &mut Vec<f32>,-) {- let mut emit = |buf: &[f32]| {- out_buf.extend_from_slice(buf);- if let Some(cb) = audio_cb {- cb(buf);- }- };-- if vad_policy == VadPolicy::Disabled {- emit(samples);- return;- }-- if let Some(cfg) = vad {- let mut detector = cfg.detector.lock().unwrap();- match detector- .push_frame(samples)- .unwrap_or(VadFrame::Speech(samples))- {- VadFrame::Speech(buf) => emit(buf),- VadFrame::Noise => {}- }- } else {- emit(samples);- }-}--fn drain_available_samples(- consumer: &mut Consumer<f32>,- max_samples: usize,- mut process: impl FnMut(&[f32]),-) -> usize {- let available = consumer.slots().min(max_samples);- if available == 0 {- return 0;- }-- let chunk = consumer- .read_chunk(available)- .expect("reported audio ring slots must be readable");- let (first, second) = chunk.as_slices();- if !first.is_empty() {- process(first);- }- if !second.is_empty() {- process(second);- }- chunk.commit_all();- available-}--/// What to do with a chunk drained from the ring.-#[derive(Clone, Copy, Debug, PartialEq, Eq)]-enum ChunkDisposition {- /// Process as active recording audio, including during the final stop drain.- Capture,- /// Consume idle audio without processing it.- Discard,-}--/// Converts raw ring samples into 16 kHz frames across recording sessions.-/// Ring transport stays outside to avoid conflicting borrows during drains.-struct CaptureProcessor {- // ---- stream-scoped: fixed for the life of the input stream ---------- //- in_sample_rate: u32,- vad: Option<VadConfig>,- level_cb: Option<LevelCallback>,- audio_cb: Option<AudioFrameCallback>,- stream_running_at: Instant,- visualizer: AudioVisualiser,- frame_resampler: FrameResampler,- max_drain_samples: usize,- first_chunk_logged: bool,-- // ---- recording-scoped: reset by `begin_recording` ------------------- //- vad_policy: VadPolicy,- processed_samples: Vec<f32>,- awaiting_first_captured_chunk: Option<Instant>,- capture_ready_tx: Option<mpsc::Sender<()>>,- total_dropped_samples: u64,- overrun_warning_logged: bool,-}--impl CaptureProcessor {- fn new(- in_sample_rate: u32,- vad: Option<VadConfig>,- level_cb: Option<LevelCallback>,- audio_cb: Option<AudioFrameCallback>,- stream_running_at: Instant,- ) -> Self {- // Resample into frames sized for the active VAD backend (30 ms when- // no detector is attached) so the detector never sees a partial frame.- let frame_samples = vad.as_ref().map_or(- (constants::WHISPER_SAMPLE_RATE * 30 / 1000) as usize,- |config| config.frame_samples,- );- let frame_duration =- Duration::from_secs_f64(frame_samples as f64 / constants::WHISPER_SAMPLE_RATE as f64);- let frame_resampler = FrameResampler::new(- in_sample_rate as usize,- constants::WHISPER_SAMPLE_RATE as usize,- frame_duration,- );-- const BUCKETS: usize = 16;- let target_window = (f64::from(in_sample_rate) / 30.0).round() as usize;- let window_size = [256usize, 512, 1024, 2048]- .into_iter()- .min_by_key(|w| w.abs_diff(target_window))- .unwrap();- let visualizer = AudioVisualiser::new(in_sample_rate, window_size, BUCKETS, 400.0, 4000.0);-- let max_drain_samples =- ((in_sample_rate as u128 * MAX_DRAIN_CHUNK.as_millis()) / 1_000).max(1) as usize;-- Self {- in_sample_rate,- vad,- level_cb,- audio_cb,- stream_running_at,- visualizer,- frame_resampler,- max_drain_samples,- first_chunk_logged: false,- vad_policy: VadPolicy::Offline,- processed_samples: Vec::new(),- awaiting_first_captured_chunk: None,- capture_ready_tx: None,- total_dropped_samples: 0,- overrun_warning_logged: false,- }- }-- /// Reset per-recording state and arm the first-sample acknowledgement.- fn begin_recording(&mut self, policy: VadPolicy, ready_tx: mpsc::Sender<()>) {- self.awaiting_first_captured_chunk = Some(Instant::now());- self.capture_ready_tx = Some(ready_tx);- self.total_dropped_samples = 0;- self.overrun_warning_logged = false;- self.vad_policy = policy;- self.processed_samples.clear();- self.visualizer.reset();- self.frame_resampler.reset();- if policy != VadPolicy::Disabled {- if let Some(cfg) = &self.vad {- let mut detector = cfg.detector.lock().unwrap();- detector.set_hangover_frames(cfg.hangover_for(policy));- detector.reset();- }- }- }-- /// Drop a pending first-sample acknowledgement. If Stop was queued before- /// the first chunk, this prevents a stale ready UI event or start chime.- fn cancel_ready_signal(&mut self) {- self.capture_ready_tx = None;- self.awaiting_first_captured_chunk = None;- }-- /// Drain up to one bounded chunk from the ring. Returns the number of- /// samples consumed so callers can tell an empty ring from a busy one.- fn drain(&mut self, consumer: &mut Consumer<f32>, disposition: ChunkDisposition) -> usize {- let max_samples = self.max_drain_samples;- drain_available_samples(consumer, max_samples, |raw| {- self.process_raw_chunk(raw, disposition)- })- }-- fn process_raw_chunk(&mut self, raw: &[f32], disposition: ChunkDisposition) {- let chunk_ms = raw.len() as f64 * 1000.0 / self.in_sample_rate as f64;- if !self.first_chunk_logged {- self.first_chunk_logged = true;- log::debug!(- "first audio samples arrived {:?} after stream start ({:.1}ms drained)",- self.stream_running_at.elapsed(),- chunk_ms- );- }-- if disposition == ChunkDisposition::Discard {- return;- }-- if let Some(buckets) = self.visualizer.feed(raw) {- if let Some(callback) = &self.level_cb {- callback(buckets);- }- }-- let vad_policy = self.vad_policy;- self.frame_resampler.push(raw, |frame: &[f32]| {- handle_frame(- frame,- vad_policy,- &self.vad,- &self.audio_cb,- &mut self.processed_samples,- )- });-- if let Some(started) = self.awaiting_first_captured_chunk.take() {- log::debug!(- "first captured samples ({:.1}ms) processed {:?} after Cmd::Start",- chunk_ms,- started.elapsed()- );- }- if let Some(ready_tx) = self.capture_ready_tx.take() {- // Silence still counts: readiness means the host is delivering samples,- // not that VAD has detected speech.- let _ = ready_tx.send(());- }- }-- /// Account for samples the callback could not fit into the ring during- /// the active recording. Warns once per recording.- fn observe_overrun(&mut self, samples: u64) {- if samples == 0 {- return;- }-- self.total_dropped_samples = self.total_dropped_samples.saturating_add(samples);- if !self.overrun_warning_logged {- self.overrun_warning_logged = true;- log::warn!(- "Microphone capture ring dropped {samples} samples; continuing the active recording"- );- }- }-- /// Flush the resampler tail and hand back the finished recording.- fn finish_recording(&mut self) -> Vec<f32> {- let vad_policy = self.vad_policy;- self.frame_resampler.finish(|frame: &[f32]| {- handle_frame(- frame,- vad_policy,- &self.vad,- &self.audio_cb,- &mut self.processed_samples,- )- });-- // Diagnostic for VAD audio still withheld when capture stopped; it is- // not conclusive in either direction.- if vad_policy != VadPolicy::Disabled {- if let Some(cfg) = &self.vad {- let report = cfg.detector.lock().unwrap().tail_report();- if let Some(report) = report {- log::debug!(- "VAD at stop: withheld tail {} frames (~{}ms, {} voiced), in_speech={}, onset_counter={}, hangover_counter={}",- report.withheld_frames,- report.withheld_frames * cfg.frame_samples * 1000- / constants::WHISPER_SAMPLE_RATE as usize,- report.withheld_voiced_frames,- report.in_speech,- report.onset_counter,- report.hangover_counter- );- }- }- }-- if self.total_dropped_samples > 0 {- log::warn!(- "Active recording completed after dropping {} microphone samples",- self.total_dropped_samples- );- }- std::mem::take(&mut self.processed_samples)- }-}--fn run_consumer(- mut processor: CaptureProcessor,- mut sample_consumer: Consumer<f32>,- cmd_rx: mpsc::Receiver<Cmd>,- transport: Arc<CaptureTransportState>,- stream_error: Arc<AtomicBool>,-) {- let mut recording = false;- let mut stream_error_logged = false;-- loop {- // Avoid sleeping with queued audio; check commands before each bounded- // drain so Stop cannot sit behind a multi-second backlog.- let mut command = if sample_consumer.slots() > 0 {- match cmd_rx.try_recv() {- Ok(command) => Some(command),- Err(mpsc::TryRecvError::Empty) => None,- Err(mpsc::TryRecvError::Disconnected) => return,- }- } else {- match cmd_rx.recv_timeout(CONSUMER_POLL_INTERVAL) {- Ok(command) => Some(command),- Err(mpsc::RecvTimeoutError::Timeout) => None,- Err(mpsc::RecvTimeoutError::Disconnected) => return,- }- };-- loop {- if let Some(cmd) = command.take() {- match cmd {- Cmd::Start(policy, sent_at, ready_tx) => {- log::debug!(- "Cmd::Start processed {:?} after send; capture begins with {} samples",- sent_at.elapsed(),- if sample_consumer.slots() > 0 {- "the in-flight"- } else {- "the next available"- }- );- // Ignore overruns accumulated while the always-on stream- // was idle; only active-capture loss is relevant.- transport.overrun_samples.store(0, Ordering::Release);- processor.begin_recording(policy, ready_tx);- recording = true;- }- Cmd::Stop(reply_tx) => {- processor- .observe_overrun(transport.overrun_samples.swap(0, Ordering::AcqRel));- recording = false;- processor.cancel_ready_signal();-- // Request a pause that forwards one boundary block, then drain- // all audio committed before the acknowledgement.- transport.pause_acknowledged.store(false, Ordering::Relaxed);- transport.pause_requested.store(true, Ordering::Release);- let pause_started = Instant::now();- while !transport.pause_acknowledged.load(Ordering::Acquire)- && pause_started.elapsed() < PAUSE_ACK_TIMEOUT- {- let drained =- processor.drain(&mut sample_consumer, ChunkDisposition::Capture);- if drained == 0 {- std::thread::sleep(Duration::from_millis(1));- }- }-- let pause_timed_out = !transport.pause_acknowledged.load(Ordering::Acquire);- if pause_timed_out {- log::warn!("Timed out waiting for the microphone callback to pause");- // Preserve the existing recovery model: finish this- // stop, then rebuild the stream on the next start.- stream_error.store(true, Ordering::Release);- }-- // Everything still in the ring, including the boundary- // block, belongs to this recording.- while processor.drain(&mut sample_consumer, ChunkDisposition::Capture) > 0 {- }-- // Include drops that raced with the pause request.- processor- .observe_overrun(transport.overrun_samples.swap(0, Ordering::AcqRel));- let samples = processor.finish_recording();- if !pause_timed_out {- // Resume before stop() returns so an immediate recording- // cannot lose its first callback to this pause request.- transport.pause_acknowledged.store(false, Ordering::Relaxed);- transport.pause_requested.store(false, Ordering::Release);- }- let _ = reply_tx.send(samples);-- if pause_timed_out {- return;- }- }- Cmd::Shutdown => {- transport.pause_requested.store(true, Ordering::Release);- return;- }- }- }-- command = match cmd_rx.try_recv() {- Ok(command) => Some(command),- Err(mpsc::TryRecvError::Empty) => break,- Err(mpsc::TryRecvError::Disconnected) => return,- };- }-- let disposition = if recording {- ChunkDisposition::Capture- } else {- ChunkDisposition::Discard- };- processor.drain(&mut sample_consumer, disposition);-- let overrun_samples = transport.overrun_samples.swap(0, Ordering::AcqRel);- if recording {- processor.observe_overrun(overrun_samples);- }-- // The CPAL error callback only sets an atomic; log here and rebuild the- // stream on the next start.- if stream_error.load(Ordering::Acquire) && !stream_error_logged {- log::error!("Microphone backend reported a stream error; it will be rebuilt");- stream_error_logged = true;- }- }-}--#[cfg(test)]-mod tests;diff --git a/src-tauri/src/audio_toolkit/audio/recorder/tests.rs b/src-tauri/src/audio_toolkit/audio/recorder/tests.rsdeleted file mode 100644index 271acde2..00000000--- a/src-tauri/src/audio_toolkit/audio/recorder/tests.rs+++ /dev/null@@ -1,418 +0,0 @@-use super::{- is_microphone_access_denied, is_no_input_device_error, run_consumer, AudioRecorder,- CaptureProcessor, CaptureTransportState, ChunkDisposition, Cmd, VadConfig, VadPolicy,-};-use crate::audio_toolkit::vad::{VadFrame, VoiceActivityDetector};-use rtrb::RingBuffer;-use std::{- sync::{- atomic::{AtomicBool, Ordering},- mpsc, Arc, Mutex,- },- thread,- time::{Duration, Instant},-};--#[test]-fn unopened_recorder_does_not_need_reopen() {- let recorder = AudioRecorder::new().expect("recorder");- assert!(!recorder.needs_reopen());-}--#[test]-fn stream_error_requires_reopen() {- let recorder = AudioRecorder::new().expect("recorder");- recorder.stream_error.store(true, Ordering::Relaxed);- assert!(recorder.needs_reopen());-}--/// Pass-through detector with a configurable frame size, standing in for a-/// backend such as Earshot whose frames are not 30 ms.-struct FixedFrameVad(usize);--impl VoiceActivityDetector for FixedFrameVad {- fn push_frame<'a>(&'a mut self, frame: &'a [f32]) -> anyhow::Result<VadFrame<'a>> {- Ok(VadFrame::Speech(frame))- }-- fn frame_samples(&self) -> usize {- self.0- }-}--#[test]-fn resampler_frame_size_follows_the_vad_backend() {- let frame_samples = 256;- let vad = VadConfig {- detector: Arc::new(Mutex::new(Box::new(FixedFrameVad(frame_samples)))),- frame_samples,- offline_hangover_frames: 0,- streaming_hangover_frames: 0,- };- let frame_lengths = Arc::new(Mutex::new(Vec::new()));- let observed = Arc::clone(&frame_lengths);- let mut processor = CaptureProcessor::new(- 16_000,- Some(vad),- None,- Some(Arc::new(move |frame: &[f32]| {- observed.lock().unwrap().push(frame.len())- })),- Instant::now(),- );-- let (ready_tx, _ready_rx) = mpsc::channel();- processor.begin_recording(VadPolicy::Offline, ready_tx);- processor.process_raw_chunk(&[0.0; 1024], ChunkDisposition::Capture);- let samples = processor.finish_recording();-- assert_eq!(samples.len(), 1024);- assert_eq!(*frame_lengths.lock().unwrap(), vec![frame_samples; 4]);-}--#[test]-fn idle_chunks_are_discarded_without_reaching_the_recording() {- let mut processor = CaptureProcessor::new(16_000, None, None, None, Instant::now());- processor.process_raw_chunk(&[1.0; 480], ChunkDisposition::Discard);- assert!(processor.finish_recording().is_empty());-}--#[test]-fn shutdown_is_processed_without_audio_samples() {- let (_producer, consumer) = RingBuffer::<f32>::new(48_000);- let (cmd_tx, cmd_rx) = mpsc::channel();- let (done_tx, done_rx) = mpsc::channel();- let worker = thread::spawn(move || {- run_consumer(- CaptureProcessor::new(48_000, None, None, None, Instant::now()),- consumer,- cmd_rx,- Arc::new(CaptureTransportState::default()),- Arc::new(AtomicBool::new(false)),- );- let _ = done_tx.send(());- });-- cmd_tx.send(Cmd::Shutdown).expect("send shutdown");- assert!(done_rx.recv_timeout(Duration::from_secs(1)).is_ok());- worker.join().expect("join consumer");-}--#[test]-fn callback_writes_mono_samples() {- let (mut producer, mut consumer) = RingBuffer::<f32>::new(8);- let transport = CaptureTransportState::default();-- AudioRecorder::write_input_to_ring(&[0.25f32, -0.5, 1.0], 1, None, &mut producer, &transport);-- let mut output = [0.0; 3];- consumer.pop_entire_slice(&mut output).expect("samples");- assert_eq!(output, [0.25, -0.5, 1.0]);-}--#[test]-fn callback_downmixes_or_selects_multichannel_input() {- let transport = CaptureTransportState::default();- let (mut average_tx, mut average_rx) = RingBuffer::<f32>::new(4);- AudioRecorder::write_input_to_ring(- &[1.0f32, 3.0, -1.0, 1.0],- 2,- None,- &mut average_tx,- &transport,- );- let mut averaged = [0.0; 2];- average_rx- .pop_entire_slice(&mut averaged)- .expect("averaged samples");- assert_eq!(averaged, [2.0, 0.0]);-- let (mut selected_tx, mut selected_rx) = RingBuffer::<f32>::new(4);- AudioRecorder::write_input_to_ring(- &[1.0f32, 3.0, -1.0, 1.0],- 2,- Some(1),- &mut selected_tx,- &transport,- );- let mut selected = [0.0; 2];- selected_rx- .pop_entire_slice(&mut selected)- .expect("selected samples");- assert_eq!(selected, [3.0, 1.0]);-}--#[test]-fn callback_forwards_boundary_block_then_stays_silent_until_resumed() {- let (mut producer, mut consumer) = RingBuffer::<f32>::new(8);- let transport = CaptureTransportState::default();-- // The block in hand when a pause is first observed was captured before- // the stop, so it is forwarded and only then acknowledged.- transport.pause_requested.store(true, Ordering::Release);- AudioRecorder::write_input_to_ring(&[1.0f32, 2.0], 1, None, &mut producer, &transport);- assert!(transport.pause_acknowledged.load(Ordering::Acquire));- assert_eq!(consumer.slots(), 2);-- // Later blocks while paused are dropped and are not counted as overruns.- AudioRecorder::write_input_to_ring(&[3.0f32], 1, None, &mut producer, &transport);- assert_eq!(consumer.slots(), 2);- assert_eq!(transport.overrun_samples.load(Ordering::Relaxed), 0);-- // Clearing the pause, as the consumer does before stop() returns, resumes capture.- transport.pause_acknowledged.store(false, Ordering::Relaxed);- transport.pause_requested.store(false, Ordering::Release);- AudioRecorder::write_input_to_ring(&[4.0f32], 1, None, &mut producer, &transport);- let mut output = [0.0; 3];- consumer.pop_entire_slice(&mut output).expect("samples");- assert_eq!(output, [1.0, 2.0, 4.0]);- assert!(!transport.pause_acknowledged.load(Ordering::Acquire));-}--#[test]-fn callback_partially_fills_ring_and_counts_dropped_audio() {- let (mut producer, mut consumer) = RingBuffer::<f32>::new(2);- let transport = CaptureTransportState::default();-- AudioRecorder::write_input_to_ring(&[1.0f32, 2.0, 3.0], 1, None, &mut producer, &transport);-- let mut captured = [0.0; 2];- consumer- .pop_entire_slice(&mut captured)- .expect("partial callback audio");- assert_eq!(captured, [1.0, 2.0]);- assert_eq!(transport.overrun_samples.load(Ordering::Relaxed), 1);-}--#[test]-fn bounded_drain_leaves_remaining_samples_for_the_next_command_cycle() {- let (mut producer, mut consumer) = RingBuffer::<f32>::new(8);- producer- .push_entire_slice(&[1.0, 2.0, 3.0, 4.0, 5.0])- .expect("samples");- let mut drained = Vec::new();-- let count =- super::drain_available_samples(&mut consumer, 3, |part| drained.extend_from_slice(part));-- assert_eq!(count, 3);- assert_eq!(drained, [1.0, 2.0, 3.0]);- assert_eq!(consumer.slots(), 2);-}--#[test]-fn ring_wraparound_preserves_both_read_slices_in_order() {- let (mut producer, mut consumer) = RingBuffer::<f32>::new(5);- let transport = CaptureTransportState::default();- producer- .push_entire_slice(&[1.0, 2.0, 3.0, 4.0])- .expect("initial samples");- let mut discarded = [0.0; 3];- consumer- .pop_entire_slice(&mut discarded)- .expect("advance ring head");-- AudioRecorder::write_input_to_ring(- &[5.0f32, 6.0, 7.0, 8.0],- 1,- None,- &mut producer,- &transport,- );-- let chunk = consumer.read_chunk(5).expect("wrapped samples");- let (first, second) = chunk.as_slices();- assert!(!first.is_empty());- assert!(!second.is_empty());- let ordered = first- .iter()- .chain(second.iter())- .copied()- .collect::<Vec<_>>();- assert_eq!(ordered, [4.0, 5.0, 6.0, 7.0, 8.0]);-}--#[test]-fn repeated_start_stop_cycles_resume_capture_without_leaking_samples() {- let (mut producer, consumer) = RingBuffer::<f32>::new(16_000);- let transport = Arc::new(CaptureTransportState::default());- let (cmd_tx, cmd_rx) = mpsc::channel();- let streamed = Arc::new(Mutex::new(Vec::new()));- let streamed_cb = Arc::clone(&streamed);- let consumer_transport = Arc::clone(&transport);- let worker = thread::spawn(move || {- let processor = CaptureProcessor::new(- 16_000,- None,- None,- Some(Arc::new(move |frame: &[f32]| {- streamed_cb.lock().unwrap().extend_from_slice(frame)- })),- Instant::now(),- );- run_consumer(- processor,- consumer,- cmd_rx,- consumer_transport,- Arc::new(AtomicBool::new(false)),- );- });-- let wait_for_pause_request = || {- let deadline = Instant::now() + Duration::from_secs(1);- while !transport.pause_requested.load(Ordering::Acquire) {- assert!(Instant::now() < deadline, "pause was not requested");- thread::sleep(Duration::from_millis(1));- }- };-- let first_input = [0.25f32, -0.5, 1.0];- let (ready_tx, ready_rx) = mpsc::channel();- cmd_tx- .send(Cmd::Start(VadPolicy::Disabled, Instant::now(), ready_tx))- .expect("first start");- AudioRecorder::write_input_to_ring(&first_input, 1, None, &mut producer, &transport);- ready_rx- .recv_timeout(Duration::from_secs(1))- .expect("first capture ready");-- let (reply_tx, reply_rx) = mpsc::channel();- cmd_tx.send(Cmd::Stop(reply_tx)).expect("first stop");- wait_for_pause_request();- // The first callback after Stop carries audio captured before the stop,- // so it belongs to the recording.- AudioRecorder::write_input_to_ring(&[99.0f32], 1, None, &mut producer, &transport);-- let first_samples = reply_rx- .recv_timeout(Duration::from_secs(1))- .expect("first stop reply");- let first_expected = [0.25f32, -0.5, 1.0, 99.0];- assert_eq!(&first_samples[..first_expected.len()], &first_expected);- assert!(first_samples[first_expected.len()..]- .iter()- .all(|&sample| sample == 0.0));- assert!(!transport.pause_requested.load(Ordering::Acquire));-- let first_streamed_len = {- let streamed = streamed.lock().unwrap();- assert_eq!(&streamed[..first_expected.len()], &first_expected);- streamed.len()- };-- // Start again immediately after stop() would have returned. The producer- // must already be re-enabled, and no first-cycle samples may leak through.- let second_input = [0.75f32, -0.25, 0.5];- let (ready_tx, ready_rx) = mpsc::channel();- cmd_tx- .send(Cmd::Start(VadPolicy::Disabled, Instant::now(), ready_tx))- .expect("second start");- AudioRecorder::write_input_to_ring(&second_input, 1, None, &mut producer, &transport);- ready_rx- .recv_timeout(Duration::from_secs(1))- .expect("second capture ready");-- let (reply_tx, reply_rx) = mpsc::channel();- cmd_tx.send(Cmd::Stop(reply_tx)).expect("second stop");- wait_for_pause_request();- AudioRecorder::write_input_to_ring(&[199.0f32], 1, None, &mut producer, &transport);-- let second_samples = reply_rx- .recv_timeout(Duration::from_secs(1))- .expect("second stop reply");- let second_expected = [0.75f32, -0.25, 0.5, 199.0];- assert_eq!(&second_samples[..second_expected.len()], &second_expected);- assert!(second_samples[second_expected.len()..]- .iter()- .all(|&sample| sample == 0.0));- assert!(!first_samples- .iter()- .any(|sample| second_expected.contains(sample)));- assert!(!second_samples- .iter()- .any(|sample| first_expected.contains(sample)));- assert!(!transport.pause_requested.load(Ordering::Acquire));-- {- let streamed = streamed.lock().unwrap();- assert_eq!(streamed.len(), first_streamed_len + second_samples.len());- assert_eq!(- &streamed[first_streamed_len..first_streamed_len + second_expected.len()],- &second_expected- );- }-- cmd_tx.send(Cmd::Shutdown).expect("shutdown");- worker.join().expect("consumer worker");-}--#[test]-fn missing_callback_at_stop_marks_stream_for_rebuild_and_returns_samples() {- let (_producer, consumer) = RingBuffer::<f32>::new(16_000);- let transport = Arc::new(CaptureTransportState::default());- let stream_error = Arc::new(AtomicBool::new(false));- let observed_error = Arc::clone(&stream_error);- let (cmd_tx, cmd_rx) = mpsc::channel();- let worker_transport = Arc::clone(&transport);- let worker = thread::spawn(move || {- run_consumer(- CaptureProcessor::new(16_000, None, None, None, Instant::now()),- consumer,- cmd_rx,- worker_transport,- stream_error,- );- });-- let (ready_tx, _ready_rx) = mpsc::channel();- cmd_tx- .send(Cmd::Start(VadPolicy::Disabled, Instant::now(), ready_tx))- .expect("start");- let (reply_tx, reply_rx) = mpsc::channel();- cmd_tx.send(Cmd::Stop(reply_tx)).expect("stop");-- let samples = reply_rx- .recv_timeout(Duration::from_secs(3))- .expect("pause timeout still returns captured samples");- assert!(samples.is_empty());- worker.join().expect("consumer exits after pause timeout");- assert!(observed_error.load(Ordering::Acquire));-}--#[test]-fn detects_access_is_denied() {- assert!(is_microphone_access_denied("Access is denied"));-}--#[test]-fn detects_permission_denied() {- assert!(is_microphone_access_denied("permission denied"));-}--#[test]-fn detects_windows_error_code() {- assert!(is_microphone_access_denied("WASAPI error: 0x80070005"));-}--#[test]-fn does_not_match_unrelated_errors() {- assert!(!is_microphone_access_denied("device not found"));-}--#[test]-fn detects_no_input_device() {- assert!(is_no_input_device_error("No input device found"));-}--#[test]-fn detects_coreaudio_config_error() {- assert!(is_no_input_device_error(- "Failed to fetch preferred config: A backend-specific error has occurred: An unknown error unknown to the coreaudio-rs API occurred"- ));-}--#[test]-fn does_not_match_other_errors_for_no_device() {- assert!(!is_no_input_device_error("permission denied"));- assert!(!is_no_input_device_error("device not found"));-}diff --git a/src-tauri/src/audio_toolkit/audio/resampler.rs b/src-tauri/src/audio_toolkit/audio/resampler.rsdeleted file mode 100644index 13fd5e40..00000000--- a/src-tauri/src/audio_toolkit/audio/resampler.rs+++ /dev/null@@ -1,351 +0,0 @@-use rubato::{FftFixedIn, Resampler};-use std::time::Duration;--// Make this a constant you can tweak-const RESAMPLER_CHUNK_SIZE: usize = 1024;--pub struct FrameResampler {- resampler: Option<FftFixedIn<f32>>,- chunk_in: usize,- in_buf: Vec<f32>,- frame_samples: usize,- pending: Vec<f32>,- in_hz: usize,- out_hz: usize,- /// Samples in/out of the inner resampler; `finish()` uses the pair to- /// know how much real audio (~10-30ms) its delay line still holds.- in_count: usize,- out_count: usize,-}--impl FrameResampler {- pub fn new(in_hz: usize, out_hz: usize, frame_dur: Duration) -> Self {- let frame_samples = ((out_hz as f64 * frame_dur.as_secs_f64()).round()) as usize;- assert!(frame_samples > 0, "frame duration too short");-- // Use fixed chunk size instead of GCD-based- let chunk_in = RESAMPLER_CHUNK_SIZE;-- let resampler = (in_hz != out_hz).then(|| {- FftFixedIn::<f32>::new(in_hz, out_hz, chunk_in, 1, 1)- .expect("Failed to create resampler")- });-- Self {- resampler,- chunk_in,- in_buf: Vec::with_capacity(chunk_in),- frame_samples,- pending: Vec::with_capacity(frame_samples),- in_hz,- out_hz,- in_count: 0,- out_count: 0,- }- }-- pub fn push(&mut self, mut src: &[f32], mut emit: impl FnMut(&[f32])) {- if self.resampler.is_none() {- self.emit_frames(src, &mut emit);- return;- }- self.in_count += src.len();-- while !src.is_empty() {- let space = self.chunk_in - self.in_buf.len();- let take = space.min(src.len());- self.in_buf.extend_from_slice(&src[..take]);- src = &src[take..];-- if self.in_buf.len() == self.chunk_in {- // let start = std::time::Instant::now();- if let Ok(out) = self- .resampler- .as_mut()- .unwrap()- .process(&[&self.in_buf[..]], None)- {- // let duration = start.elapsed();- // log::debug!("Resampler took: {:?}", duration);- self.out_count += out[0].len();- self.emit_frames(&out[0], &mut emit);- }- self.in_buf.clear();- }- }- }-- pub fn finish(&mut self, mut emit: impl FnMut(&[f32])) {- if self.resampler.is_some() {- // Process any remaining input samples (padded internally).- if !self.in_buf.is_empty() {- let result = self- .resampler- .as_mut()- .unwrap()- .process_partial(Some(&[&self.in_buf[..]]), None);- if let Ok(out) = result {- self.out_count += out[0].len();- self.emit_frames(&out[0], &mut emit);- }- // Drop the consumed input: a full in_buf would satisfy the- // next push()'s chunk check immediately, re-processing this- // padded tail into the following recording.- self.in_buf.clear();- }-- // Output lags input by output_delay() samples, so all real audio- // has emerged only once in*ratio + delay samples are out. Feed- // zero chunks until then, trimming the synthetic remainder.- if self.in_count > 0 {- let delay = self.resampler.as_ref().unwrap().output_delay();- let expected = self.in_count * self.out_hz / self.in_hz + delay;- let mut rounds = 0;- while self.out_count < expected && rounds < 8 {- rounds += 1;- let result = self- .resampler- .as_mut()- .unwrap()- .process_partial::<&[f32]>(None, None);- match result {- Ok(out) => {- let take = (expected - self.out_count).min(out[0].len());- self.out_count += take;- self.emit_frames(&out[0][..take], &mut emit);- }- Err(_) => break,- }- }- }- }-- // Emit any remaining pending frame (padded with zeros)- if !self.pending.is_empty() {- self.pending.resize(self.frame_samples, 0.0);- emit(&self.pending);- self.pending.clear();- }- }-- /// Clear all internal buffers so the next `push()` starts from a clean state.- ///- /// Call this between recordings to prevent stale audio from the previous- /// session leaking into the start of the next one via the FFT overlap buffers.- pub fn reset(&mut self) {- self.in_buf.clear();- self.pending.clear();- self.in_count = 0;- self.out_count = 0;- if let Some(ref mut resampler) = self.resampler {- resampler.reset();- }- }-- fn emit_frames(&mut self, mut data: &[f32], emit: &mut impl FnMut(&[f32])) {- while !data.is_empty() {- let space = self.frame_samples - self.pending.len();- let take = space.min(data.len());- self.pending.extend_from_slice(&data[..take]);- data = &data[take..];-- if self.pending.len() == self.frame_samples {- emit(&self.pending);- self.pending.clear();- }- }- }-}--#[cfg(test)]-mod tests {- use super::*;-- /// Generate a 1kHz sine wave at the given sample rate and duration.- fn sine_wave(sample_rate: usize, freq: f64, duration_secs: f64) -> Vec<f32> {- let n = (sample_rate as f64 * duration_secs) as usize;- (0..n)- .map(|i| {- (2.0 * std::f64::consts::PI * freq * i as f64 / sample_rate as f64).sin() as f32- })- .collect()- }-- fn collect_output(resampler: &mut FrameResampler, input: &[f32]) -> Vec<f32> {- let mut out = Vec::new();- resampler.push(input, |frame| out.extend_from_slice(frame));- out- }-- #[test]- fn reset_clears_in_buf_and_pending() {- let mut r = FrameResampler::new(48000, 16000, Duration::from_millis(30));-- // Push less than one chunk (1024 samples) to leave data in in_buf- let partial = vec![0.5f32; 500];- let _ = collect_output(&mut r, &partial);-- r.reset();-- // Now push silence — should get only silence out, no remnants of 0.5- let silence = vec![0.0f32; 4096];- let out = collect_output(&mut r, &silence);-- let max_abs = out.iter().map(|s| s.abs()).fold(0.0f32, f32::max);- assert!(- max_abs < 0.01,- "After reset, silence input should produce near-silence output, got max_abs={}",- max_abs- );- }-- #[test]- fn reset_clears_fft_overlap_buffers() {- let mut r = FrameResampler::new(48000, 16000, Duration::from_millis(30));-- // Push a loud 1kHz sine wave through the resampler (simulates recording 1)- let sine = sine_wave(48000, 1000.0, 0.5); // 500ms of audio- let _ = collect_output(&mut r, &sine);- r.finish(|_| {});-- // Reset (simulates new recording starting)- r.reset();-- // Push silence (simulates recording 2 starting with no speech)- let silence = vec![0.0f32; 4096];- let out = collect_output(&mut r, &silence);-- // The output should be near-zero. If the FFT overlap buffers weren't- // cleared, the sine wave's tail would leak into this output.- let max_abs = out.iter().map(|s| s.abs()).fold(0.0f32, f32::max);- assert!(- max_abs < 0.01,- "FFT overlap should not leak after reset; got max_abs={} (expected near-zero)",- max_abs- );- }-- #[test]- fn reset_between_recordings_no_crosstalk() {- let mut r = FrameResampler::new(48000, 16000, Duration::from_millis(30));-- // Recording 1: ascending ramp (distinctive pattern)- let ramp: Vec<f32> = (0..48000).map(|i| i as f32 / 48000.0).collect(); // 1 second- let out1 = collect_output(&mut r, &ramp);- r.finish(|_| {});- assert!(!out1.is_empty(), "Recording 1 should produce output");-- // Reset between recordings- r.reset();-- // Recording 2: constant DC signal of -0.5- let dc = vec![-0.5f32; 48000]; // 1 second- let out2 = collect_output(&mut r, &dc);-- // After the resampler settles (skip first frame which may have transient),- // all samples should be near -0.5, not contaminated by the ascending ramp.- if out2.len() > 480 {- // Skip first frame (480 samples at 16kHz/30ms), check the rest- let tail = &out2[480..];- for (i, &s) in tail.iter().enumerate() {- assert!(- (s - (-0.5)).abs() < 0.05,- "Recording 2 sample {} = {} (expected ~-0.5); ramp leaked through",- i + 480,- s- );- }- }- }-- #[test]- fn reset_passthrough_mode_clears_pending() {- // When in_hz == out_hz, no rubato resampler is created (passthrough mode).- // Reset should still clear the pending frame buffer.- let mut r = FrameResampler::new(16000, 16000, Duration::from_millis(30));-- // Push partial frame (less than 480 samples) to leave data in pending- let partial = vec![1.0f32; 200];- let _ = collect_output(&mut r, &partial);-- r.reset();-- // Push silence- let silence = vec![0.0f32; 960];- let out = collect_output(&mut r, &silence);-- // First complete frame should be all zeros, not contain the 1.0 values- if !out.is_empty() {- let max_abs = out.iter().take(480).map(|s| s.abs()).fold(0.0f32, f32::max);- assert!(- max_abs < 0.001,- "Passthrough mode: pending buffer should be cleared after reset, got max_abs={}",- max_abs- );- }- }-- /// Push silence ending in a 200-sample 0.5 burst, then assert finish()- /// recovers the burst and emits floor(input*ratio) + output_delay samples,- /// padded to whole 480-sample frames.- fn assert_tail_burst_flushed(in_hz: usize, input_len: usize, expected_out: usize) {- let mut rs = FrameResampler::new(in_hz, 16000, Duration::from_millis(30));- let mut input = vec![0.0f32; input_len];- input[input_len - 200..].fill(0.5);-- let mut out = Vec::new();- rs.push(&input, |frame| out.extend_from_slice(frame));- rs.finish(|frame| out.extend_from_slice(frame));-- let max_abs = out.iter().map(|s| s.abs()).fold(0.0f32, f32::max);- assert!(- max_abs > 0.3,- "tail burst was lost in the resampler, max_abs={max_abs}"- );- assert_eq!(out.len(), expected_out);- }-- #[test]- fn finish_flushes_resampler_delay() {- // Exact chunks keep in_buf empty, so the burst survives only via the- // delay-line drain. 4096 in -> 1365 real out + 171 delay -> 1920 framed.- assert_tail_burst_flushed(48000, 4 * RESAMPLER_CHUNK_SIZE, 1920);- }-- #[test]- fn finish_flushes_resampler_delay_44100() {- // fft_size_in (1323) exceeds the 1024 chunk, so the drain must survive- // a zero-output round. 4096 in -> 1486 real out + 240 delay -> 1920.- assert_tail_burst_flushed(44100, 4 * RESAMPLER_CHUNK_SIZE, 1920);- }-- #[test]- fn finish_flushes_unaligned_tail() {- // Ends mid-chunk: partial-chunk path plus delay drain together.- // 4396 in -> 1465 real out + 171 delay -> 1920 framed.- assert_tail_burst_flushed(48000, 4 * RESAMPLER_CHUNK_SIZE + 300, 1920);- }-- #[test]- fn finish_does_not_leak_tail_into_next_session() {- // 48kHz -> 16kHz, 30ms frames (480 output samples per frame).- let mut rs = FrameResampler::new(48000, 16000, Duration::from_millis(30));-- // Leave a partial chunk buffered, then end the session.- rs.push(&[0.5f32; 100], |_| {});- rs.finish(|_| {});-- // One fresh chunk yields ~341 output samples — below one frame, so- // nothing should be emitted yet. If finish() left its padded tail in- // in_buf, that tail is re-processed first, the output crosses the- // 480-sample frame boundary, and a stale frame is emitted here.- let mut emitted = 0usize;- rs.push(&[0.25f32; RESAMPLER_CHUNK_SIZE], |frame| {- emitted += frame.len()- });- assert_eq!(- emitted, 0,- "stale resampler tail from finish() leaked into the next session"- );- }-}diff --git a/src-tauri/src/audio_toolkit/audio/sink.rs b/src-tauri/src/audio_toolkit/audio/sink.rsnew file mode 100644index 00000000..eefa619e--- /dev/null+++ b/src-tauri/src/audio_toolkit/audio/sink.rs@@ -0,0 +1,197 @@+use std::sync::{mpsc, Arc};++use handy_recorder::{AudioChunk, Sink};++use crate::audio_toolkit::{+ audio::AudioVisualiser,+ constants,+ vad::{VadFrame, VoiceActivityDetector},+};++/// How 16 kHz mono frames should be filtered for one recording session.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum VadPolicy {+ /// Bypass VAD and forward every frame.+ Disabled,+ /// Current offline-tuned VAD profile.+ Offline,+ /// VAD profile with a longer post-speech tail for streaming-capable models.+ Streaming,+}++/// A single VAD engine plus the two hangover-tail lengths its smoothing wrapper+/// should use. The offline and streaming policies are never active+/// concurrently, so one detector is reconfigured per recording rather than+/// kept as two resident engines.+pub struct CaptureVad {+ detector: Box<dyn VoiceActivityDetector>,+ offline_hangover_frames: usize,+ streaming_hangover_frames: usize,+}++impl CaptureVad {+ pub fn new(+ detector: Box<dyn VoiceActivityDetector>,+ offline_hangover_frames: usize,+ streaming_hangover_frames: usize,+ ) -> Self {+ assert!(+ detector.frame_samples() > 0,+ "VAD frame size must be non-zero"+ );+ Self {+ detector,+ offline_hangover_frames,+ streaming_hangover_frames,+ }+ }++ /// Samples per detector frame; the recorder delivers chunks of this size.+ pub fn frame_samples(&self) -> usize {+ self.detector.frame_samples()+ }++ /// Post-speech hangover tail (in detector frames) for the given policy.+ /// `Disabled` never reaches the detector, so it maps to the offline value.+ fn hangover_for(&self, policy: VadPolicy) -> usize {+ match policy {+ VadPolicy::Streaming => self.streaming_hangover_frames,+ VadPolicy::Offline | VadPolicy::Disabled => self.offline_hangover_frames,+ }+ }+}++/// Receives spectrum levels for the recording overlay.+pub type LevelCallback = Arc<dyn Fn(Vec<f32>) + Send + Sync + 'static>;+/// Receives each 16 kHz mono frame that passes the recording's VAD policy, in+/// order. Used to feed live streaming transcription as audio arrives.+pub type AudioFrameCallback = Arc<dyn Fn(&[f32]) + Send + Sync + 'static>;++/// What a finished recording hands back.+pub struct CapturedAudio {+ /// 16 kHz mono samples that passed the VAD policy.+ pub samples: Vec<f32>,+ /// The detector the recording borrowed, for the next one.+ pub vad: CaptureVad,+}++/// One recording's consumer of 16 kHz mono audio from handy-recorder. Runs on+/// the recorder's delivery thread, never the real-time audio thread, so it+/// can run VAD inline. Chunks are exactly one VAD frame long.+pub struct CaptureSink {+ vad: CaptureVad,+ policy: VadPolicy,+ visualizer: AudioVisualiser,+ on_levels: LevelCallback,+ on_audio: AudioFrameCallback,+ /// Signalled on the first chunk: the device is delivering audio. Silence+ /// counts; readiness is not speech.+ ready: Option<mpsc::Sender<()>>,+ samples: Vec<f32>,+}++/// Spectrum window at 16 kHz: 32 ms, near the overlay's ~30 Hz refresh.+const VISUALIZER_WINDOW: usize = 512;+const VISUALIZER_BUCKETS: usize = 16;++impl CaptureSink {+ /// A sink for one recording. Resets the detector and applies the policy's+ /// hangover tail, so no state carries over from the previous recording.+ pub fn new(+ mut vad: CaptureVad,+ policy: VadPolicy,+ on_levels: LevelCallback,+ on_audio: AudioFrameCallback,+ ready: mpsc::Sender<()>,+ ) -> Self {+ if policy != VadPolicy::Disabled {+ let hangover = vad.hangover_for(policy);+ vad.detector.set_hangover_frames(hangover);+ vad.detector.reset();+ }+ Self {+ vad,+ policy,+ visualizer: AudioVisualiser::new(+ constants::WHISPER_SAMPLE_RATE,+ VISUALIZER_WINDOW,+ VISUALIZER_BUCKETS,+ 400.0,+ 4000.0,+ ),+ on_levels,+ on_audio,+ ready: Some(ready),+ samples: Vec::new(),+ }+ }++ /// The detector, from a sink that never recorded (its start failed).+ pub fn into_vad(self) -> CaptureVad {+ self.vad+ }++ /// Hands back the recording and the detector. Logs what VAD still held+ /// back when the recording stopped.+ pub fn finish(self) -> CapturedAudio {+ // Diagnostic for audio still withheld when capture stopped; it is not+ // conclusive in either direction.+ if self.policy != VadPolicy::Disabled {+ if let Some(report) = self.vad.detector.tail_report() {+ log::debug!(+ "VAD at stop: withheld tail {} frames (~{}ms, {} voiced), in_speech={}, onset_counter={}, hangover_counter={}",+ report.withheld_frames,+ report.withheld_frames * self.vad.frame_samples() * 1000+ / constants::WHISPER_SAMPLE_RATE as usize,+ report.withheld_voiced_frames,+ report.in_speech,+ report.onset_counter,+ report.hangover_counter+ );+ }+ }+ CapturedAudio {+ samples: self.samples,+ vad: self.vad,+ }+ }++ fn emit(samples: &mut Vec<f32>, on_audio: &AudioFrameCallback, frame: &[f32]) {+ samples.extend_from_slice(frame);+ on_audio(frame);+ }+}++impl Sink for CaptureSink {+ fn process_chunk(&mut self, chunk: AudioChunk<'_>) {+ if let Some(ready) = self.ready.take() {+ let _ = ready.send(());+ }++ // Mono by construction: the recorder mixes down or picks one channel.+ let real = &chunk.samples[..chunk.valid_frames];+ if let Some(levels) = self.visualizer.feed(real) {+ (self.on_levels)(levels);+ }++ if self.policy == VadPolicy::Disabled {+ Self::emit(&mut self.samples, &self.on_audio, real);+ return;+ }++ // The detector needs whole frames, so the final chunk goes in with its+ // zero padding; at most one frame of silence reaches the recording.+ match self+ .vad+ .detector+ .push_frame(chunk.samples)+ .unwrap_or(VadFrame::Speech(chunk.samples))+ {+ VadFrame::Speech(frame) => Self::emit(&mut self.samples, &self.on_audio, frame),+ VadFrame::Noise => {}+ }+ }+}++#[cfg(test)]+mod tests;diff --git a/src-tauri/src/audio_toolkit/audio/sink/tests.rs b/src-tauri/src/audio_toolkit/audio/sink/tests.rsnew file mode 100644index 00000000..49afb502--- /dev/null+++ b/src-tauri/src/audio_toolkit/audio/sink/tests.rs@@ -0,0 +1,152 @@+use super::{AudioFrameCallback, CaptureSink, CaptureVad, LevelCallback, VadPolicy};+use crate::audio_toolkit::vad::{VadFrame, VoiceActivityDetector};+use handy_recorder::{AudioChunk, Sink};+use std::sync::{mpsc, Arc, Mutex};++/// Keeps frames whose first sample is non-zero, and records how the sink+/// configured it.+#[derive(Default)]+struct ScriptedVad {+ frame_samples: usize,+ hangover: Arc<Mutex<Option<usize>>>,+ resets: Arc<Mutex<usize>>,+}++impl VoiceActivityDetector for ScriptedVad {+ fn push_frame<'a>(&'a mut self, frame: &'a [f32]) -> anyhow::Result<VadFrame<'a>> {+ Ok(if frame[0] != 0.0 {+ VadFrame::Speech(frame)+ } else {+ VadFrame::Noise+ })+ }++ fn frame_samples(&self) -> usize {+ self.frame_samples+ }++ fn set_hangover_frames(&mut self, frames: usize) {+ *self.hangover.lock().unwrap() = Some(frames);+ }++ fn reset(&mut self) {+ *self.resets.lock().unwrap() += 1;+ }+}++const FRAME: usize = 4;++struct Harness {+ sink: CaptureSink,+ ready: mpsc::Receiver<()>,+ fed: Arc<Mutex<Vec<f32>>>,+ hangover: Arc<Mutex<Option<usize>>>,+ resets: Arc<Mutex<usize>>,+}++fn harness(policy: VadPolicy) -> Harness {+ let vad = ScriptedVad {+ frame_samples: FRAME,+ ..Default::default()+ };+ let hangover = Arc::clone(&vad.hangover);+ let resets = Arc::clone(&vad.resets);+ let fed = Arc::new(Mutex::new(Vec::new()));+ let on_audio: AudioFrameCallback = {+ let fed = Arc::clone(&fed);+ Arc::new(move |frame: &[f32]| fed.lock().unwrap().extend_from_slice(frame))+ };+ let on_levels: LevelCallback = Arc::new(|_| {});+ let (ready_tx, ready) = mpsc::channel();+ let sink = CaptureSink::new(+ CaptureVad::new(Box::new(vad), 10, 20),+ policy,+ on_levels,+ on_audio,+ ready_tx,+ );+ Harness {+ sink,+ ready,+ fed,+ hangover,+ resets,+ }+}++fn chunk(samples: &[f32], valid_frames: usize) -> AudioChunk<'_> {+ AudioChunk {+ samples,+ sample_rate: 16_000,+ channels: 1,+ valid_frames,+ }+}++#[test]+fn readiness_fires_once_on_the_first_chunk() {+ let mut h = harness(VadPolicy::Disabled);+ assert!(h.ready.try_recv().is_err());++ h.sink.process_chunk(chunk(&[0.0; FRAME], FRAME));+ h.sink.process_chunk(chunk(&[0.0; FRAME], FRAME));++ assert!(h.ready.try_recv().is_ok());+ // The sender is gone after the first chunk, so a second signal can't come.+ assert_eq!(h.ready.try_recv(), Err(mpsc::TryRecvError::Disconnected));+}++#[test]+fn readiness_waiter_wakes_when_a_recording_ends_without_audio() {+ let h = harness(VadPolicy::Offline);+ let _ = h.sink.finish();+ assert!(h.ready.recv().is_err());+}++#[test]+fn disabled_vad_keeps_every_real_sample_and_drops_padding() {+ let mut h = harness(VadPolicy::Disabled);+ h.sink.process_chunk(chunk(&[1.0, 0.0, 2.0, 0.0], FRAME));+ // Final chunk: one real frame, three of zero padding.+ h.sink.process_chunk(chunk(&[3.0, 0.0, 0.0, 0.0], 1));++ let expected = vec![1.0, 0.0, 2.0, 0.0, 3.0];+ assert_eq!(*h.fed.lock().unwrap(), expected);+ assert_eq!(h.sink.finish().samples, expected);+ assert_eq!(+ *h.resets.lock().unwrap(),+ 0,+ "a disabled policy leaves VAD alone"+ );+}++#[test]+fn vad_keeps_speech_frames_only() {+ let mut h = harness(VadPolicy::Offline);+ h.sink.process_chunk(chunk(&[1.0; FRAME], FRAME));+ h.sink.process_chunk(chunk(&[0.0; FRAME], FRAME));+ h.sink.process_chunk(chunk(&[2.0; FRAME], FRAME));++ let expected = [[1.0; FRAME], [2.0; FRAME]].concat();+ assert_eq!(*h.fed.lock().unwrap(), expected);+ assert_eq!(h.sink.finish().samples, expected);+}++#[test]+fn each_recording_resets_the_detector_with_its_policys_hangover() {+ let offline = harness(VadPolicy::Offline);+ assert_eq!(*offline.hangover.lock().unwrap(), Some(10));+ assert_eq!(*offline.resets.lock().unwrap(), 1);++ let streaming = harness(VadPolicy::Streaming);+ assert_eq!(*streaming.hangover.lock().unwrap(), Some(20));+ assert_eq!(*streaming.resets.lock().unwrap(), 1);+}++#[test]+fn finish_returns_the_detector_for_the_next_recording() {+ let h = harness(VadPolicy::Offline);+ let captured = h.sink.finish();+ assert_eq!(captured.vad.frame_samples(), FRAME);+ assert_eq!(captured.vad.hangover_for(VadPolicy::Streaming), 20);+}diff --git a/src-tauri/src/audio_toolkit/bin/cli.rs b/src-tauri/src/audio_toolkit/bin/cli.rsdeleted file mode 100644index 0b9b4da4..00000000--- a/src-tauri/src/audio_toolkit/bin/cli.rs+++ /dev/null@@ -1,371 +0,0 @@-use hound::WavWriter;-use std::io::{self, Write};--use handy_app_lib::audio_toolkit::{- audio::{list_input_devices, CpalDeviceInfo},- vad::{- frames_for_duration_ms, SmoothedVad, VAD_OFFLINE_HANGOVER_MS, VAD_ONSET_MS,- VAD_PREFILL_MS, VAD_STREAMING_HANGOVER_MS,- },- AudioRecorder, SileroVad, VadPolicy, VoiceActivityDetector,-};--#[derive(Debug, Clone, PartialEq)]-enum RecorderMode {- AlwaysOn,- OnDemand,-}--impl std::fmt::Display for RecorderMode {- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- match self {- RecorderMode::AlwaysOn => write!(f, "Always-On"),- RecorderMode::OnDemand => write!(f, "On-Demand"),- }- }-}--struct RecorderState {- recorder: AudioRecorder,- mode: RecorderMode,- is_recording: bool,- is_open: bool,- current_device_index: Option<usize>,- recording_index: u32,-}--impl RecorderState {- fn new(recorder: AudioRecorder) -> Self {- Self {- recorder,- mode: RecorderMode::AlwaysOn,- is_recording: false,- is_open: false,- current_device_index: None,- recording_index: 1,- }- }-- fn switch_mode(&mut self, new_mode: RecorderMode) -> Result<(), Box<dyn std::error::Error>> {- if self.mode == new_mode {- return Ok(());- }-- // If we're currently recording, stop first- if self.is_recording {- println!("Stopping current recording to switch modes...");- self.stop_recording()?;- }-- // Close if open and switching to on-demand, or if switching from on-demand to always-on- if self.is_open {- match (&self.mode, &new_mode) {- (RecorderMode::AlwaysOn, RecorderMode::OnDemand) => {- self.recorder.close()?;- self.is_open = false;- println!("Closed recorder for On-Demand mode");- }- (RecorderMode::OnDemand, RecorderMode::AlwaysOn) => {- // For switching from on-demand to always-on, we need to reopen- // This will be handled when the user starts recording- }- _ => {}- }- }-- self.mode = new_mode;- println!("Switched to {} mode", self.mode);- Ok(())- }-- fn start_recording(- &mut self,- device_index: Option<usize>,- devices: &[CpalDeviceInfo],- ) -> Result<(), Box<dyn std::error::Error>> {- if self.is_recording {- return Err("Already recording! Stop the current recording first.".into());- }-- let device = if let Some(idx) = device_index {- if idx >= devices.len() {- return Err(format!(- "Invalid device index: {}. Available devices: 0-{}",- idx,- devices.len() - 1- )- .into());- }- Some(devices[idx].device.clone())- } else {- None- };-- match self.mode {- RecorderMode::AlwaysOn => {- // In always-on mode, open once and keep open- if !self.is_open || self.current_device_index != device_index {- if self.is_open {- self.recorder.close()?;- }- self.recorder.open(device)?;- self.is_open = true;- self.current_device_index = device_index;- println!("Opened recorder in Always-On mode");- }- self.recorder.start(VadPolicy::Offline)?;- }- RecorderMode::OnDemand => {- // In on-demand mode, open for each recording- if self.is_open {- self.recorder.close()?;- }- self.recorder.open(device)?;- self.is_open = true;- self.current_device_index = device_index;- self.recorder.start(VadPolicy::Offline)?;- println!("Opened and started recorder in On-Demand mode");- }- }-- self.is_recording = true;- println!(- "Recording started with device: {}",- device_index.map_or("default".to_string(), |i| i.to_string())- );- Ok(())- }-- fn stop_recording(&mut self) -> Result<Vec<f32>, Box<dyn std::error::Error>> {- if !self.is_recording {- return Err("No recording in progress.".into());- }-- let samples = self.recorder.stop()?;- self.is_recording = false;-- match self.mode {- RecorderMode::AlwaysOn => {- // Keep the recorder open for next recording- println!("Recording stopped. Recorder remains open for next recording.");- }- RecorderMode::OnDemand => {- // Close the recorder after each recording- self.recorder.close()?;- self.is_open = false;- self.current_device_index = None;- println!("Recording stopped and recorder closed.");- }- }-- Ok(samples)- }-- fn close(&mut self) -> Result<(), Box<dyn std::error::Error>> {- if self.is_recording {- self.stop_recording()?;- }- if self.is_open {- self.recorder.close()?;- self.is_open = false;- }- Ok(())- }-}--fn main() -> Result<(), Box<dyn std::error::Error>> {- println!("Advanced Audio Recorder CLI");- println!("=========================");- print_help();-- let silero = SileroVad::new("./resources/models/silero_vad_v4.onnx", 0.5)?;- let frame_samples = silero.frame_samples();- let offline_hangover_frames = frames_for_duration_ms(VAD_OFFLINE_HANGOVER_MS, frame_samples);- let smoothed_vad = SmoothedVad::new(- Box::new(silero),- frames_for_duration_ms(VAD_PREFILL_MS, frame_samples),- offline_hangover_frames,- frames_for_duration_ms(VAD_ONSET_MS, frame_samples),- );- let recorder = AudioRecorder::new()?.with_vad(- Box::new(smoothed_vad),- offline_hangover_frames,- frames_for_duration_ms(VAD_STREAMING_HANGOVER_MS, frame_samples),- );- let mut state = RecorderState::new(recorder);-- let mut devices = list_input_devices()?;- print_devices(&devices);-- loop {- print!("[{}] > ", state.mode);- io::stdout().flush()?;-- let mut input = String::new();- io::stdin().read_line(&mut input)?;- let parts: Vec<&str> = input.trim().split_whitespace().collect();-- if parts.is_empty() {- continue;- }-- let command = parts[0].to_lowercase();-- match command.as_str() {- "start" | "s" => {- let device_index = if parts.len() > 1 {- match parts[1].parse::<usize>() {- Ok(idx) => Some(idx),- Err(_) => {- println!("Invalid device index format. Usage: start [device_index]");- continue;- }- }- } else {- None- };-- match state.start_recording(device_index, &devices) {- Ok(_) => println!("Recording started successfully!"),- Err(e) => println!("Error starting recording: {}", e),- }- }- "stop" => match state.stop_recording() {- Ok(samples) => {- if !samples.is_empty() {- let filename = format!("recording_{}.wav", state.recording_index);- match save_audio(&samples, &filename) {- Ok(_) => {- println!("Recording saved as: {}", filename);- state.recording_index += 1;- }- Err(e) => println!("Error saving recording: {}", e),- }- } else {- println!("No audio data captured.");- }- }- Err(e) => println!("Error stopping recording: {}", e),- },- "mode" => {- if parts.len() > 1 {- let new_mode = match parts[1].to_lowercase().as_str() {- "always" | "alwayson" | "always-on" | "a" => RecorderMode::AlwaysOn,- "demand" | "ondemand" | "on-demand" | "d" => RecorderMode::OnDemand,- _ => {- println!("Invalid mode. Use 'always' or 'demand'");- continue;- }- };- match state.switch_mode(new_mode) {- Ok(_) => {}- Err(e) => println!("Error switching modes: {}", e),- }- } else {- println!("Current mode: {}", state.mode);- println!("Usage: mode [always|demand]");- }- }- "devices" | "dev" => {- devices = list_input_devices()?;- print_devices(&devices);- }- "status" => {- println!("Status:");- println!(" Mode: {}", state.mode);- println!(- " Recording: {}",- if state.is_recording { "Yes" } else { "No" }- );- println!(- " Recorder Open: {}",- if state.is_open { "Yes" } else { "No" }- );- println!(- " Current Device: {}",- state- .current_device_index- .map_or("None".to_string(), |i| i.to_string())- );- println!(" Next Recording: recording_{}.wav", state.recording_index);- }- "help" | "h" => {- print_help();- }- "quit" | "exit" | "q" => {- println!("Shutting down...");- match state.close() {- Ok(_) => {- if state.is_recording {- println!(- "Final recording saved as: recording_{}.wav",- state.recording_index- );- }- }- Err(e) => println!("Error during shutdown: {}", e),- }- println!("Goodbye!");- break;- }- "" => {- // Empty input, continue- }- _ => {- println!(- "Unknown command: '{}'. Type 'help' for available commands.",- command- );- }- }- }-- Ok(())-}--fn print_help() {- println!("Commands:");- println!(- " start [device_index] | s [device_index] - Start recording (optionally with device)"- );- println!(" stop - Stop recording and save");- println!(- " mode [always|demand] - Switch recording mode or show current mode"- );- println!(" devices | dev - List available audio devices");- println!(" status - Show current recorder status");- println!(" help | h - Show this help message");- println!(" quit | exit | q - Exit the program");- println!();- println!("Modes:");- println!(" Always-On: Keeps recorder open for quick start/stop cycles");- println!(" On-Demand: Opens/closes recorder for each recording session");- println!();-}--fn print_devices(devices: &[CpalDeviceInfo]) {- println!("Available audio devices:");- for (index, device) in devices.iter().enumerate() {- println!(" {}: {}", index, device.name);- }- println!();-}--fn save_audio(samples: &[f32], filename: &str) -> Result<(), Box<dyn std::error::Error>> {- let spec = hound::WavSpec {- channels: 1,- sample_rate: 16000,- bits_per_sample: 16,- sample_format: hound::SampleFormat::Int,- };-- let mut writer = WavWriter::create(filename, spec)?;-- for &sample in samples {- let sample_i16 = (sample * i16::MAX as f32) as i16;- writer.write_sample(sample_i16)?;- }-- writer.finalize()?;- Ok(())-}diff --git a/src-tauri/src/audio_toolkit/mod.rs b/src-tauri/src/audio_toolkit/mod.rsindex 60e0c9ed..e35f0a71f 100644--- a/src-tauri/src/audio_toolkit/mod.rs+++ b/src-tauri/src/audio_toolkit/mod.rs@@ -6,8 +6,8 @@ pub mod utils;pub mod vad;pub use audio::{- is_microphone_access_denied, is_no_input_device_error, list_input_devices, list_output_devices,- read_wav_samples, save_wav_file, verify_wav_file, AudioRecorder, CpalDeviceInfo, VadPolicy,+ list_output_devices, read_wav_samples, save_wav_file, verify_wav_file, CaptureSink, CaptureVad,+ VadPolicy,};pub use lang_id::detect_output_language;pub use text::{diff --git a/src-tauri/src/audio_toolkit/utils.rs b/src-tauri/src/audio_toolkit/utils.rsindex 1fc8ce66..eff9ee72 100644--- a/src-tauri/src/audio_toolkit/utils.rs+++ b/src-tauri/src/audio_toolkit/utils.rs@@ -1,5 +1,8 @@-/// Returns the appropriate CPAL host for the current platform.-/// On Linux, uses ALSA host. On other platforms, uses the default host.+use rodio::cpal;++/// The CPAL host feedback sounds play through. On Linux, uses ALSA host. On+/// other platforms, uses the default host. Microphone capture picks its own+/// host inside handy-recorder.pub fn get_cpal_host() -> cpal::Host {#[cfg(target_os = "linux")]{diff --git a/src-tauri/src/commands/audio.rs b/src-tauri/src/commands/audio.rsindex 07920e25..de48cb52 100644--- a/src-tauri/src/commands/audio.rs+++ b/src-tauri/src/commands/audio.rs@@ -1,5 +1,5 @@use crate::audio_feedback;-use crate::audio_toolkit::audio::{list_input_devices, list_output_devices, AudioRecorder};+use crate::audio_toolkit::audio::list_output_devices;use crate::managers::audio::{AudioRecordingManager, MicrophoneMode};use crate::settings::{get_settings, write_settings};use log::warn;@@ -191,8 +191,8 @@ pub fn get_microphone_mode(app: AppHandle) -> Result<bool, String> {pub async fn get_available_microphones() -> Result<Vec<AudioDevice>, String> {// cpal device enumeration can stall — run it off the webview/main run loop.tokio::task::spawn_blocking(|| {- let devices =- list_input_devices().map_err(|e| format!("Failed to list audio devices: {}", e))?;+ let devices = handy_recorder::list_input_devices()+ .map_err(|e| format!("Failed to list audio devices: {}", e))?;let mut result = vec![AudioDevice {index: "default".to_string(),@@ -200,11 +200,17 @@ pub async fn get_available_microphones() -> Result<Vec<AudioDevice>, String> {is_default: true,}];- result.extend(devices.into_iter().map(|d| AudioDevice {- index: d.index,- name: d.name,- is_default: false, // The explicit default is handled separately- }));+ // PulseAudio monitor sources record a speaker's output, not a microphone.+ result.extend(+ devices+ .into_iter()+ .filter(|d| !d.is_monitor)+ .map(|d| AudioDevice {+ index: d.id,+ name: d.name,+ is_default: false, // The explicit default is handled separately+ }),+ );Ok::<_, String>(result)})@@ -336,26 +342,19 @@ pub fn is_recording(app: AppHandle) -> bool {#[tauri::command]#[specta::specta]pub async fn get_microphone_channels(device_name: String) -> Result<u16, String> {- // cpal device enumeration and config queries can stall, so keep them off- // the webview/main run loop.+ // Device enumeration can stall, so keep it off the webview/main run loop.tokio::task::spawn_blocking(move || {- use cpal::traits::HostTrait;-+ let devices = handy_recorder::list_input_devices()+ .map_err(|e| format!("Failed to list audio devices: {e}"))?;let device = if device_name.eq_ignore_ascii_case("default") {- crate::audio_toolkit::get_cpal_host().default_input_device()+ devices.into_iter().find(|device| device.is_default)} else {- list_input_devices()- .map_err(|e| format!("Failed to list audio devices: {e}"))?+ devices.into_iter().find(|device| device.name == device_name)- .map(|device| device.device)};-- match device {- Some(device) => AudioRecorder::preferred_input_channel_count(&device)- .map_err(|e| format!("Failed to get microphone config: {e}")),- None => Ok(1),- }+ // `channels` is unknown only on ALSA, where reading it opens the device.+ Ok(device.and_then(|device| device.channels).unwrap_or(1))}).await.map_err(|e| format!("audio task join failed: {e}"))?diff --git a/src-tauri/src/managers/audio.rs b/src-tauri/src/managers/audio.rsindex 1dadda34..6e811b9e 100644--- a/src-tauri/src/managers/audio.rs+++ b/src-tauri/src/managers/audio.rs@@ -1,15 +1,16 @@use crate::audio_toolkit::{- list_input_devices,+ audio::{AudioFrameCallback, LevelCallback},vad::{frames_for_duration_ms, EarshotVad, SmoothedVad, VAD_OFFLINE_HANGOVER_MS, VAD_ONSET_MS,VAD_PREFILL_MS, VAD_STREAMING_HANGOVER_MS,},- AudioRecorder, SileroVad, VadPolicy, VoiceActivityDetector,+ CaptureSink, CaptureVad, SileroVad, VadPolicy, VoiceActivityDetector,};use crate::helpers::clamshell;use crate::managers::transcription::StreamRouter;use crate::settings::{get_settings, write_settings, AppSettings, VadBackend};use crate::utils;+use handy_recorder::{Channels, EndReason, ErrorKind, Recorder, RecorderConfig, StartError};use log::{debug, error, info, trace, warn};use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};use std::sync::{mpsc, Arc, Mutex};@@ -266,23 +267,64 @@ enum DesiredMicrophone {Clamshell(String),}-/// Result of resolving the persisted preference to a live cpal device.-/// `device: None` means cpal should open the system default. The unavailable-/// name is populated only when enumeration succeeded and confirmed that the-/// user's regular selected microphone is missing.+/// Result of resolving the persisted preference to a recorder device ID.+/// `device: None` opens the system default. The unavailable name is populated+/// only when enumeration succeeded and confirmed that the user's regular+/// selected microphone is missing.struct MicrophoneResolution {- device: Option<cpal::Device>,+ device: Option<String>,+ /// The ID came from `cached_device`, so it may be stale.+ from_cache: bool,unavailable_selected_microphone: Option<String>,}+/// The VAD detector. A recording borrows it for its sink and `stop` hands it+/// back; a recording whose sink is lost loses it, and the next one reloads it.+enum VadSlot {+ Unloaded,+ Idle(CaptureVad),+ /// Lent to the active recording. Keeps the frame size, so a microphone+ /// opened meanwhile still gets VAD-sized chunks.+ Lent {+ frame_samples: usize,+ },+}++/// An open microphone: the stream is running whether or not it is recording.+struct OpenMicrophone {+ recorder: Recorder<CaptureSink>,+ /// Set when this recorder fails. Its own flag, so a failure handler that+ /// runs late can't mark a replacement recorder failed.+ failed: Arc<AtomicBool>,+}++impl OpenMicrophone {+ fn needs_reopen(&self) -> bool {+ self.failed.load(Ordering::Acquire)+ }+}++/// The `recording-error` event's `error_type` for a recording that couldn't+/// start.+pub fn recording_error_type(error: &anyhow::Error) -> &'static str {+ match error+ .downcast_ref::<handy_recorder::Error>()+ .map(handy_recorder::Error::kind)+ {+ Some(ErrorKind::PermissionDenied) => "microphone_permission_denied",+ // A missing selected microphone falls back to the default, so this+ // means there is no input device at all.+ Some(ErrorKind::DeviceUnavailable) => "no_input_device",+ _ => "unknown",+ }+}+/* ──────────────────────────────────────────────────────────────── */-fn create_audio_recorder(+fn create_capture_vad(backend: VadBackend,app_handle: &tauri::AppHandle,- selected_channel: Option<u16>,- stream_router: Arc<StreamRouter>,-) -> Result<AudioRecorder, anyhow::Error> {+) -> Result<CaptureVad, anyhow::Error> {let detector: Box<dyn VoiceActivityDetector> = match backend {VadBackend::Silero => {let vad_path = app_handle@@ -324,31 +366,54 @@ fn create_audio_recorder(backend, frame_samples);- // Recorder with VAD, a spectrum-level callback that forwards level updates to- // the frontend, and an audio-frame callback that feeds live streaming via a- // shared `StreamRouter` (captured directly, not via Tauri state — see its docs).- let recorder = AudioRecorder::new()- .map_err(|e| anyhow::anyhow!("Failed to create AudioRecorder: {}", e))?- .with_vad(- Box::new(smoothed_vad),- offline_hangover_frames,- streaming_hangover_frames,- )- .with_selected_channel(selected_channel)- .with_level_callback({- let app_handle = app_handle.clone();- move |levels| {- utils::emit_levels(&app_handle, &levels);- }- })- .with_audio_callback({- let router = stream_router;- move |frame| {- router.feed(frame);- }- });+ Ok(CaptureVad::new(+ Box::new(smoothed_vad),+ offline_hangover_frames,+ streaming_hangover_frames,+ ))+}- Ok(recorder)+/// 16 kHz mono in VAD-frame chunks, from `device` (`None`: the system+/// default). `channel` picks one zero-based input channel; `None` averages+/// them all.+fn microphone_config(+ device: Option<String>,+ channel: Option<u16>,+ frames_per_chunk: usize,+) -> RecorderConfig {+ RecorderConfig {+ device,+ channels: channel.map_or(Channels::MixToMono, Channels::Only),+ frames_per_chunk: Some(frames_per_chunk),+ ..RecorderConfig::speech()+ }+}++fn open_microphone(config: RecorderConfig) -> Result<OpenMicrophone, handy_recorder::Error> {+ let failed = Arc::new(AtomicBool::new(false));+ let recorder = Recorder::open_with_failure_handler(config, {+ let failed = Arc::clone(&failed);+ // handy-recorder logs the failure. The stream is rebuilt on the next+ // start; a recording in progress keeps the audio captured before it.+ move |_| failed.store(true, Ordering::Release)+ })?;+ Ok(OpenMicrophone { recorder, failed })+}++/// Opens with the selected channel, or averages all channels if the device+/// doesn't have it (a different microphone than the one it was chosen on).+fn open_microphone_on_channel(+ device: Option<String>,+ channel: Option<u16>,+ frames_per_chunk: usize,+) -> Result<OpenMicrophone, handy_recorder::Error> {+ match open_microphone(microphone_config(device.clone(), channel, frames_per_chunk)) {+ Err(error) if error.kind() == ErrorKind::InvalidChannel => {+ warn!("{error}; averaging all input channels instead");+ open_microphone(microphone_config(device, None, frames_per_chunk))+ }+ result => result,+ }}/* ──────────────────────────────────────────────────────────────── */@@ -378,13 +443,22 @@ pub struct AudioRecordingManager {mode: Arc<Mutex<MicrophoneMode>>,app_handle: tauri::AppHandle,- recorder: Arc<Mutex<Option<AudioRecorder>>>,+ recorder: Arc<Mutex<Option<OpenMicrophone>>>,+ vad: Arc<Mutex<VadSlot>>,+ /// Zero-based input channel to record, or `None` to average them all.+ /// Held here rather than read from settings, which are persisted only+ /// after a channel change reopens successfully.+ selected_channel: Arc<Mutex<Option<u16>>>,+ /// Spectrum levels for the overlay.+ on_levels: LevelCallback,+ /// VAD-passed frames for live streaming, via a shared `StreamRouter`+ /// (captured directly, not via Tauri state — see its docs).+ on_audio: AudioFrameCallback,is_open: Arc<Mutex<bool>>,is_recording: Arc<Mutex<bool>>,mute_state: Arc<Mutex<MuteState>>,close_generation: Arc<AtomicU64>,cancel_generation: Arc<AtomicU64>,- stream_router: Arc<StreamRouter>,/// Lock-free mirror of "is the state in {Recording, Stopping}",/// maintained by `set_state()`. The hot-path `is_recording()` reads THIS/// instead of the std `state` mutex, so a UI poll can no longer deadlock@@ -395,13 +469,13 @@ pub struct AudioRecordingManager {/// stopped or cancelled. This prevents a slow device from producing a late/// "ready" indication for a session the user already ended.capture_generation: Arc<AtomicU64>,- /// Resolution of a *named* microphone (selected or clamshell) to its cpal- /// device, cached so on-demand recording starts skip the full device- /// enumeration (~40-110ms). Keyed by the resolved name, so a settings- /// change misses naturally; cleared when an open fails (device unplugged)- /// so the retry re-enumerates. The system-default case is never cached —- /// the recorder resolves the current default itself, cheaply.- cached_device: Arc<Mutex<Option<(String, cpal::Device)>>>,+ /// Resolution of a *named* microphone (selected or clamshell) to its+ /// recorder device ID, cached so on-demand recording starts skip an extra+ /// device enumeration. Keyed by the resolved name, so a settings change+ /// misses naturally; cleared when an open fails (device unplugged) so the+ /// retry re-enumerates. The system-default case is never cached — the+ /// recorder resolves the current default itself.+ cached_device: Arc<Mutex<Option<(String, String)>>>,}impl AudioRecordingManager {@@ -418,18 +492,27 @@ impl AudioRecordingManager {MicrophoneMode::OnDemand};+ let on_levels: LevelCallback = {+ let app_handle = app.clone();+ Arc::new(move |levels| utils::emit_levels(&app_handle, &levels))+ };+ let on_audio: AudioFrameCallback = Arc::new(move |frame| stream_router.feed(frame));+let manager = Self {state: Arc::new(Mutex::new(RecordingState::Idle)),mode: Arc::new(Mutex::new(mode.clone())),app_handle: app.clone(),recorder: Arc::new(Mutex::new(None)),+ vad: Arc::new(Mutex::new(VadSlot::Unloaded)),+ selected_channel: Arc::new(Mutex::new(settings.selected_channel)),+ on_levels,+ on_audio,is_open: Arc::new(Mutex::new(false)),is_recording: Arc::new(Mutex::new(false)),mute_state: Arc::new(Mutex::new(MuteState::default())),close_generation: Arc::new(AtomicU64::new(0)),cancel_generation: Arc::new(AtomicU64::new(0)),- stream_router,recording_active: Arc::new(AtomicBool::new(false)),capture_generation: Arc::new(AtomicU64::new(0)),cached_device: Arc::new(Mutex::new(None)),@@ -478,6 +561,7 @@ impl AudioRecordingManager {debug!("device resolve: no mic configured -> system default");return MicrophoneResolution {device: None,+ from_cache: false,unavailable_selected_microphone: None,};}@@ -485,13 +569,14 @@ impl AudioRecordingManager {DesiredMicrophone::Clamshell(name) => (name, None),};- // Cache hit: skip the full enumeration. A stale device (unplugged)+ // Cache hit: skip the enumeration. A stale ID (device unplugged)// fails at open, where the caller invalidates and retries fresh.- if let Some((cached_name, device)) = self.cached_device.lock().unwrap().as_ref() {+ if let Some((cached_name, id)) = self.cached_device.lock().unwrap().as_ref() {if *cached_name == device_name {debug!("device resolve: cache hit for '{}'", device_name);return MicrophoneResolution {- device: Some(device.clone()),+ device: Some(id.clone()),+ from_cache: true,unavailable_selected_microphone: None,};}@@ -501,12 +586,12 @@ impl AudioRecordingManager {// itself succeeded. A backend enumeration error may be transient and// must not erase the user's persisted preference.let enumerate_started = Instant::now();- let (device, enumeration_succeeded) = match list_input_devices() {+ let (device, enumeration_succeeded) = match handy_recorder::list_input_devices() {Ok(devices) => (devices.into_iter().find(|d| d.name == device_name)- .map(|d| d.device),+ .map(|d| d.id),true,),Err(e) => {@@ -519,8 +604,8 @@ impl AudioRecordingManager {enumerate_started.elapsed(),device.is_some());- if let Some(d) = &device {- *self.cached_device.lock().unwrap() = Some((device_name, d.clone()));+ if let Some(id) = &device {+ *self.cached_device.lock().unwrap() = Some((device_name, id.clone()));}let unavailable_selected_microphone = if enumeration_succeeded && device.is_none() {@@ -530,6 +615,7 @@ impl AudioRecordingManager {};MicrophoneResolution {device,+ from_cache: false,unavailable_selected_microphone,}}@@ -578,6 +664,58 @@ impl AudioRecordingManager {});}+ /* ---------- VAD --------------------------------------------------------- */++ pub fn preload_vad(&self) -> Result<(), anyhow::Error> {+ let mut vad = self.vad.lock().unwrap();+ if matches!(*vad, VadSlot::Unloaded) {+ let settings = get_settings(&self.app_handle);+ *vad = VadSlot::Idle(create_capture_vad(settings.vad_backend, &self.app_handle)?);+ }+ Ok(())+ }++ /// Samples per VAD frame: the chunk size the microphone is opened with.+ fn vad_frame_samples(&self) -> Result<usize, anyhow::Error> {+ self.preload_vad()?;+ match &*self.vad.lock().unwrap() {+ VadSlot::Idle(vad) => Ok(vad.frame_samples()),+ VadSlot::Lent { frame_samples } => Ok(*frame_samples),+ VadSlot::Unloaded => unreachable!("preload_vad just loaded it"),+ }+ }++ /// Lends the detector to a recording.+ /// Lends the detector to a new recording. Called only while idle.+ fn lend_vad(&self) -> Result<CaptureVad, anyhow::Error> {+ {+ let mut slot = self.vad.lock().unwrap();+ // No recording is active, so a lent detector went with a lost sink.+ if matches!(*slot, VadSlot::Lent { .. }) {+ warn!("The last recording did not return its VAD detector; reloading it");+ *slot = VadSlot::Unloaded;+ }+ }+ self.preload_vad()?;+ let mut slot = self.vad.lock().unwrap();+ match std::mem::replace(&mut *slot, VadSlot::Unloaded) {+ VadSlot::Idle(vad) => {+ *slot = VadSlot::Lent {+ frame_samples: vad.frame_samples(),+ };+ Ok(vad)+ }+ other => {+ *slot = other;+ Err(anyhow::anyhow!("VAD is not available"))+ }+ }+ }++ fn return_vad(&self, vad: CaptureVad) {+ *self.vad.lock().unwrap() = VadSlot::Idle(vad);+ }+/* ---------- microphone life-cycle -------------------------------------- *//// Applies mute if mute_while_recording is enabled and stream is open.@@ -620,33 +758,19 @@ impl AudioRecordingManager {}}- pub fn preload_vad(&self) -> Result<(), anyhow::Error> {- let mut recorder_opt = self.recorder.lock().unwrap();- if recorder_opt.is_none() {- let settings = get_settings(&self.app_handle);- *recorder_opt = Some(create_audio_recorder(- settings.vad_backend,- &self.app_handle,- settings.selected_channel,- Arc::clone(&self.stream_router),- )?);- }- Ok(())- }-pub fn start_microphone_stream(&self) -> Result<(), anyhow::Error> {let mut open_flag = self.is_open.lock().unwrap();if *open_flag {- // `is_open` only records that we opened a stream at some point, not- // that one is still running. If capture has since failed (mic- // unplugged mid-session, USB dropout), rebuild it before the next- // recording instead of handing the caller a stalled recorder.+ // `is_open` only records that we opened a stream, not that it is+ // still running. If the recorder has since failed (mic unplugged,+ // stalled, permission revoked), rebuild it before the next+ // recording instead of handing the caller a failed recorder.let needs_reopen = self.recorder.lock().unwrap().as_ref()- .is_some_and(|rec| rec.needs_reopen());+ .is_none_or(OpenMicrophone::needs_reopen);if !needs_reopen {// trace, not debug: with the aliveness check in@@ -656,7 +780,7 @@ impl AudioRecordingManager {return Ok(());}- warn!("Microphone stream is no longer running (device disconnected?); reopening");+ warn!("Microphone stream failed; reopening");// Torn down inline rather than via stop_microphone_stream(), which// takes the `is_open` lock we are already holding.@@ -667,10 +791,10 @@ impl AudioRecordingManager {mute_guard.did_mute = false;}}- if let Some(rec) = self.recorder.lock().unwrap().as_mut() {- let _ = rec.close();+ let failed = self.recorder.lock().unwrap().take();+ if let Some(microphone) = failed {+ self.close_microphone(microphone);}- *self.is_recording.lock().unwrap() = false;*open_flag = false;self.invalidate_device_cache();// Fall through to the same fresh resolution and fallback path used@@ -694,39 +818,43 @@ impl AudioRecordingManager {// Get the selected device from settings, considering clamshell mode.// No pre-flight enumeration here: when nothing is configured the// recorder resolves the system default itself, and a machine with no- // input devices at all fails inside open() with the same- // "No input device found" error this used to check for.+ // input devices at all fails inside open() with `DeviceUnavailable`.let settings = get_settings(&self.app_handle);let resolve_started = Instant::now();let mut resolution = self.resolve_microphone_device(&settings);let resolve_elapsed = resolve_started.elapsed();- // Ensure VAD is loaded if it wasn't for whatever reason+ // Ensure VAD is loaded if it wasn't for whatever reason; its frame+ // size is the chunk size.let vad_started = Instant::now();- self.preload_vad()?;+ let frames_per_chunk = self.vad_frame_samples()?;let vad_elapsed = vad_started.elapsed();+ let channel = *self.selected_channel.lock().unwrap();let open_started = Instant::now();- let mut recorder_opt = self.recorder.lock().unwrap();- if let Some(rec) = recorder_opt.as_mut() {- if let Err(first_err) = rec.open(resolution.device.clone()) {- // A cached device or config may have gone stale (unplugged,- // rate/format changed). Re-resolve from a fresh enumeration and- // retry once before surfacing the error.+ let microphone = match open_microphone_on_channel(+ resolution.device.clone(),+ channel,+ frames_per_chunk,+ ) {+ Err(first_err) if resolution.from_cache => {+ // The cached device ID may have gone stale (unplugged).+ // Re-resolve from a fresh enumeration and retry once before+ // surfacing the error.warn!("Recorder open failed ({first_err}); re-resolving device and retrying once");self.invalidate_device_cache();resolution = self.resolve_microphone_device(&settings);- rec.open(resolution.device.clone())- .map_err(|e| anyhow::anyhow!("Failed to open recorder: {}", e))?;+ open_microphone_on_channel(resolution.device.clone(), channel, frames_per_chunk)}- }+ result => result,+ }?;debug!("mic stream breakdown: device_resolve={:?} vad_ensure={:?} open={:?}",resolve_elapsed,vad_elapsed,open_started.elapsed());- drop(recorder_opt);+ *self.recorder.lock().unwrap() = Some(microphone);*open_flag = true;if let Some(unavailable_name) = resolution.unavailable_selected_microphone {@@ -734,11 +862,9 @@ impl AudioRecordingManager {// failed fallback must not erase the user's microphone preference.self.persist_default_microphone_after_fallback(&unavailable_name);}- // This timing covers through cpal's stream.play() returning — i.e. the- // point cpal surfaces as "stream running." It does NOT guarantee the- // host audio device is producing samples yet; the first input callback- // fires asynchronously one buffer period later (hardware dependent,- // typically ~10–200ms on macOS, longer on Bluetooth/USB).+ // The stream is running, but the device may not be delivering audio+ // yet (Bluetooth can take seconds); a recording's readiness waits for+ // its first chunk.info!("Microphone stream initialized in {:?}",start_time.elapsed()@@ -760,19 +886,65 @@ impl AudioRecordingManager {mute_guard.did_mute = false;}- if let Some(rec) = self.recorder.lock().unwrap().as_mut() {- // If still recording, stop first.- if *self.is_recording.lock().unwrap() {- let _ = rec.stop();- *self.is_recording.lock().unwrap() = false;- }- let _ = rec.close();+ let microphone = self.recorder.lock().unwrap().take();+ if let Some(microphone) = microphone {+ self.close_microphone(microphone);}*open_flag = false;debug!("Microphone stream stopped");}+ /// Closes a microphone, first discarding any recording on it (its+ /// detector comes back).+ fn close_microphone(&self, microphone: OpenMicrophone) {+ let mut is_recording = self.is_recording.lock().unwrap();+ if *is_recording {+ let _ = self.collect_recording(µphone);+ *is_recording = false;+ }+ if let Err(e) = microphone.recorder.close() {+ warn!("Closing the microphone failed: {e}");+ }+ }++ /// Stops the recording on `microphone`, returning its audio and taking+ /// back the detector it borrowed.+ fn collect_recording(&self, microphone: &OpenMicrophone) -> Vec<f32> {+ match microphone.recorder.stop() {+ Ok(stopped) => {+ match &stopped.end_reason {+ EndReason::StopCalled => {}+ EndReason::RecorderFailed(error) => {+ microphone.failed.store(true, Ordering::Release);+ warn!("Recording cut short by a microphone failure; keeping the audio before it: {error}");+ }+ EndReason::SinkPanicked(message) => {+ error!("Recording cut short; audio processing panicked: {message}");+ }+ }+ if stopped.dropped_frames > 0 {+ warn!(+ "Recording completed after dropping {} microphone frames",+ stopped.dropped_frames+ );+ }+ let captured = stopped.sink.finish();+ self.return_vad(captured.vad);+ captured.samples+ }+ Err(e) => {+ // The recording and its detector are lost with the sink.+ error!("Failed to stop recording: {e}");+ if e.kind() != ErrorKind::NotRecording {+ microphone.failed.store(true, Ordering::Release);+ }+ *self.vad.lock().unwrap() = VadSlot::Unloaded;+ Vec::new()+ }+ }+ }+/* ---------- mode switching --------------------------------------------- */pub fn update_mode(&self, new_mode: MicrophoneMode) -> Result<(), anyhow::Error> {@@ -817,54 +989,76 @@ impl AudioRecordingManager {&self,binding_id: &str,vad_policy: VadPolicy,- ) -> Result<RecordingReadiness, String> {+ ) -> Result<RecordingReadiness, anyhow::Error> {let mut state = self.state.lock().unwrap();+ if !matches!(*state, RecordingState::Idle) {+ return Err(anyhow::anyhow!("Already recording"));+ }- if let RecordingState::Idle = *state {- // Cancel any pending lazy close (no-op in always-on mode, where- // closes are never scheduled).- self.close_generation.fetch_add(1, Ordering::SeqCst);+ // Cancel any pending lazy close (no-op in always-on mode, where+ // closes are never scheduled).+ self.close_generation.fetch_add(1, Ordering::SeqCst);++ // A recorder can fail just before this start, ahead of its failure+ // handler; the start then reports it. Reopen and try once more.+ let mut reopened = false;+ loop {// Opens the stream in on-demand mode. In always-on mode the stream// is normally already open and this is a cheap aliveness check —- // but if the capture worker died (device disconnect), it rebuilds- // the stream instead of leaving every subsequent start wedged on- // "Recorder not available".+ // but if the recorder failed (device disconnect), it rebuilds the+ // stream instead of leaving every subsequent start wedged.if let Err(e) = self.start_microphone_stream() {- let msg = format!("{e}");- error!("Failed to open microphone stream: {msg}");- return Err(msg);+ error!("Failed to open microphone stream: {e}");+ return Err(e);}- if let Some(rec) = self.recorder.lock().unwrap().as_ref() {- match rec.start(vad_policy) {- Ok(receiver) => {- let generation = self.capture_generation.fetch_add(1, Ordering::AcqRel) + 1;- *self.is_recording.lock().unwrap() = true;- self.set_state(- &mut state,- RecordingState::Recording {- binding_id: binding_id.to_string(),- },- );- debug!("Recording requested for binding {binding_id}");- return Ok(RecordingReadiness {- receiver,- generation,- });+ let (ready_tx, receiver) = mpsc::channel();+ let sink = CaptureSink::new(+ self.lend_vad()?,+ vad_policy,+ Arc::clone(&self.on_levels),+ Arc::clone(&self.on_audio),+ ready_tx,+ );++ let recorder = self.recorder.lock().unwrap();+ let Some(microphone) = recorder.as_ref() else {+ self.return_vad(sink.into_vad());+ return Err(anyhow::anyhow!("Recorder not available"));+ };+ match microphone.recorder.start(sink) {+ Ok(()) => {+ let generation = self.capture_generation.fetch_add(1, Ordering::AcqRel) + 1;+ *self.is_recording.lock().unwrap() = true;+ self.set_state(+ &mut state,+ RecordingState::Recording {+ binding_id: binding_id.to_string(),+ },+ );+ debug!("Recording requested for binding {binding_id}");+ return Ok(RecordingReadiness {+ receiver,+ generation,+ });+ }+ Err(StartError { error, sink }) => {+ self.return_vad(sink.into_vad());+ if reopened || error.kind() == ErrorKind::AlreadyRecording {+ return Err(anyhow::Error::new(error).context("Failed to start recorder"));}- Err(error) => return Err(format!("Failed to start recorder: {error}")),+ warn!("Microphone failed before this recording ({error}); reopening");+ microphone.failed.store(true, Ordering::Release);+ reopened = true;}}- Err("Recorder not available".to_string())- } else {- Err("Already recording".to_string())}}/// Replace the VAD implementation while idle. If the microphone stream is/// currently warm (always-on or lazy-close mode), reopen it with the new- /// detector before reporting success. A failed reopen restores the previous- /// recorder so the persisted setting can remain unchanged.+ /// detector's chunk size before reporting success. A failed reopen restores+ /// the previous detector so the persisted setting can remain unchanged.pub fn update_vad_backend(&self, backend: VadBackend) -> Result<(), anyhow::Error> {let state = self.state.lock().unwrap();if !matches!(*state, RecordingState::Idle) {@@ -873,30 +1067,20 @@ impl AudioRecordingManager {));}- let settings = get_settings(&self.app_handle);- let replacement = create_audio_recorder(- backend,- &self.app_handle,- settings.selected_channel,- Arc::clone(&self.stream_router),- )?;+ let replacement = create_capture_vad(backend, &self.app_handle)?;let was_open = *self.is_open.lock().unwrap();- // Invalidate any delayed close before swapping the recorder it targets.+ // Invalidate any delayed close before swapping the detector.self.close_generation.fetch_add(1, Ordering::SeqCst);if was_open {self.stop_microphone_stream();}- let previous_recorder = self.recorder.lock().unwrap().replace(replacement);+ let previous =+ std::mem::replace(&mut *self.vad.lock().unwrap(), VadSlot::Idle(replacement));if was_open {if let Err(change_error) = self.start_microphone_stream() {- // Ensure a partially opened replacement cannot retain capture- // resources before restoring the known-good detector.- if let Some(recorder) = self.recorder.lock().unwrap().as_mut() {- let _ = recorder.close();- }- *self.recorder.lock().unwrap() = previous_recorder;+ *self.vad.lock().unwrap() = previous;if let Err(rollback_error) = self.start_microphone_stream() {error!(@@ -941,20 +1125,18 @@ impl AudioRecordingManager {));}- let previous_channel = get_settings(&self.app_handle).selected_channel;let was_open = *self.is_open.lock().unwrap();if was_open {self.close_generation.fetch_add(1, Ordering::SeqCst);self.stop_microphone_stream();}- if let Some(recorder) = self.recorder.lock().unwrap().as_mut() {- recorder.set_selected_channel(selected_channel);- }+ let previous_channel = std::mem::replace(+ &mut *self.selected_channel.lock().unwrap(),+ selected_channel,+ );if was_open {if let Err(error) = self.start_microphone_stream() {- if let Some(recorder) = self.recorder.lock().unwrap().as_mut() {- recorder.set_selected_channel(previous_channel);- }+ *self.selected_channel.lock().unwrap() = previous_channel;return Err(error);}}@@ -1013,17 +1195,12 @@ impl AudioRecordingManager {}}- let samples = if let Some(rec) = self.recorder.lock().unwrap().as_ref() {- match rec.stop() {- Ok(buf) => buf,- Err(e) => {- error!("stop() failed: {e}");- Vec::new()- }+ let samples = match self.recorder.lock().unwrap().as_ref() {+ Some(microphone) => self.collect_recording(microphone),+ None => {+ error!("Recorder not available");+ Vec::new()}- } else {- error!("Recorder not available");- Vec::new()};*self.is_recording.lock().unwrap() = false;@@ -1077,8 +1254,8 @@ impl AudioRecordingManager {self.set_state(&mut state, RecordingState::Idle);drop(state);- if let Some(rec) = self.recorder.lock().unwrap().as_ref() {- let _ = rec.stop(); // Discard the result+ if let Some(microphone) = self.recorder.lock().unwrap().as_ref() {+ let _ = self.collect_recording(microphone); // Discard the result}*self.is_recording.lock().unwrap() = false;@@ -1099,3 +1276,57 @@ impl AudioRecordingManager {}}}++#[cfg(test)]+mod tests {+ use super::*;++ /// A recorder error, without touching a device: the request is rejected+ /// before one is opened.+ fn recorder_error() -> handy_recorder::Error {+ let config = RecorderConfig {+ sample_rate: Some(0),+ ..RecorderConfig::speech()+ };+ match Recorder::<CaptureSink>::open(config) {+ Err(error) => error,+ Ok(_) => panic!("a 0 Hz output rate should be rejected"),+ }+ }++ #[test]+ fn recorder_errors_are_classified_through_added_context() {+ let error = recorder_error();+ assert_eq!(error.kind(), ErrorKind::UnsupportedFormat);++ let wrapped = anyhow::Error::new(error).context("Failed to start recorder");+ assert_eq!(+ wrapped+ .downcast_ref::<handy_recorder::Error>()+ .map(handy_recorder::Error::kind),+ Some(ErrorKind::UnsupportedFormat)+ );+ assert_eq!(recording_error_type(&wrapped), "unknown");+ }++ #[test]+ fn errors_from_outside_the_recorder_are_unknown() {+ assert_eq!(+ recording_error_type(&anyhow::anyhow!("Already recording")),+ "unknown"+ );+ }++ #[test]+ fn microphone_config_maps_the_selected_channel() {+ let all = microphone_config(None, None, 480);+ assert_eq!(all.channels, Channels::MixToMono);+ assert_eq!(all.sample_rate, Some(16_000));+ assert_eq!(all.frames_per_chunk, Some(480));++ let second = microphone_config(Some("id".into()), Some(1), 256);+ assert_eq!(second.channels, Channels::Only(1));+ assert_eq!(second.device.as_deref(), Some("id"));+ assert_eq!(second.frames_per_chunk, Some(256));+ }+}