feat(desktop): add pitch-preserving TTS playback speed

.cargo/config.toml

@@ -9,3 +9,10 @@ debug = "line-tables-only"
 # cmake_minimum_required < 3.5; audiopus_sys's vendored opus declares 3.1.
 # Same workaround CI uses. A value already set in the environment wins.
 CMAKE_POLICY_VERSION_MINIMUM = "3.5"
+
+# MSVC otherwise reports the legacy C++98 value for `__cplusplus`, even when
+# cc-rs selects C++14. sstretch uses that macro to gate its C++11
+# `std::make_unique` polyfill, which collides with the MSVC standard library.
+# Match sherpa-onnx's static MSVC runtime so both native audio libraries can
+# link into the same Tauri binary without LNK2038 RuntimeLibrary mismatches.
+CXXFLAGS_x86_64_pc_windows_msvc = "/Zc:__cplusplus /MT"

desktop/src-tauri/Cargo.toml

@@ -130,6 +130,7 @@ regex = "1"
 rusqlite = { version = "0.37", features = ["bundled"] }
 axum = "0.8"
 rodio = "0.22"
+ssstretch = "0.1.0"
 earshot = "1.0"
 rubato = "3.0"
 audioadapter-buffers = "3.0"

desktop/src-tauri/examples/tts_speed_probe.rs

@@ -0,0 +1,32 @@
+use std::time::Instant;
+
+#[path = "../src/huddle/playback_speed_dsp.rs"]
+mod playback_speed_dsp;
+
+const SAMPLE_RATE: u32 = 24_000;
+const TONE_SECONDS: f64 = 10.0;
+
+fn main() {
+    let tone: Vec<f32> = (0..SAMPLE_RATE * TONE_SECONDS as u32)
+        .map(|index| {
+            (2.0 * std::f32::consts::PI * 220.0 * index as f32 / SAMPLE_RATE as f32).sin() * 0.25
+        })
+        .collect();
+
+    let compensated_lookahead = playback_speed_dsp::compensated_output_latency_samples(SAMPLE_RATE);
+    let compensated_lookahead_ms = compensated_lookahead as f64 * 1_000.0 / SAMPLE_RATE as f64;
+
+    for speed in [0.75_f32, 1.25, 1.5] {
+        let started = Instant::now();
+        let output = playback_speed_dsp::process_complete_chunk(&tone, speed, SAMPLE_RATE)
+            .expect("process synthesized model audio");
+        let elapsed = started.elapsed();
+        println!(
+            "{speed:.2}x: processing={:.2}ms, {:.3}% realtime, output={} samples, compensated \
+             DSP lookahead={compensated_lookahead_ms:.1}ms",
+            elapsed.as_secs_f64() * 1_000.0,
+            elapsed.as_secs_f64() / TONE_SECONDS * 100.0,
+            output.len(),
+        );
+    }
+}

desktop/src-tauri/src/app_state.rs

@@ -54,12 +54,11 @@ pub struct AppState {
     pub managed_agent_processes: Mutex<HashMap<ManagedAgentRuntimeKey, ManagedAgentPairRuntime>>,
     pub huddle_state: Mutex<HuddleState>,
     pub huddle_audio: crate::huddle::tts_settings::HuddleAudioSettingsState,
-    /// Tauri app handle — stored after setup so huddle commands can emit
-    /// `huddle-state-changed` events without needing the handle threaded
-    /// through every call site.
-    ///
+    /// Tauri app handle, stored after setup so huddle commands can emit
+    /// `huddle-state-changed` without threading it through every call site.
     /// Set once during `setup()` in `lib.rs`; never cleared.
     pub app_handle: Mutex<Option<AppHandle>>,
+    pub tts_playback_speed: crate::huddle::playback_speed::PlaybackSpeedControl,
     /// Port of the localhost media streaming proxy (set during setup).
     pub media_proxy_port: AtomicU16,
     /// Set when identity resolution detected a "keyring-locked" state: the
@@ -219,6 +218,7 @@ pub fn build_app_state() -> AppState {
         huddle_state: Mutex::new(HuddleState::default()),
         huddle_audio: Default::default(),
         app_handle: Mutex::new(None),
+        tts_playback_speed: crate::huddle::playback_speed::PlaybackSpeedControl::default(),
         media_proxy_port: AtomicU16::new(0),
         prevent_sleep: Arc::new(Mutex::new(
             crate::prevent_sleep::PreventSleepState::default(),

desktop/src-tauri/src/huddle/mod.rs

@@ -29,6 +29,7 @@ pub mod audio_output;
 pub mod jitter;
 pub mod models;
 pub mod pipeline;
+pub mod playback_speed;
 pub mod playout;
 pub mod pocket;
 pub mod preprocessing;

desktop/src-tauri/src/huddle/pipeline.rs

@@ -451,13 +451,15 @@ pub(crate) async fn maybe_start_tts_pipeline(state: &AppState) -> Result<bool, S
     // Construct outside the lock — this spawns the TTS worker thread and
     // loads ONNX sessions (~200ms). If this fails, clear the sentinel.
     let constructed_voice = initial_voice.clone();
+    let playback_speed = state.tts_playback_speed.clone();
     let constructed = tokio::task::spawn_blocking(move || {
         tts::TtsPipeline::new_with_voice(
             model_dir,
             tts_active,
             tts_cancel,
             &initial_voice,
             output_device,
+            playback_speed,
         )
     })
     .await;