Skip to content

armgit / Handy

Public Imported from GitHub
0

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.md
index 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 Flow
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 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.toml
index 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.rs
index 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 the
diff --git a/src-tauri/src/actions.rs b/src-tauri/src/actions.rs
index 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.rs
index 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.rs
index 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.rs
index 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 components
mod 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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(&microphone);
+ *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));
+ }
+}