feat: add avsynth (macOS) and sapi (Windows) native TTS engines

- avsynth_engine: AVSpeechSynthesizer via objc crate, supports voice
  listing, rate/pitch/volume, pause/resume/stop
- sapi_engine: Windows SAPI via windows crate, supports voice listing,
  SSML pitch control, pause/resume/stop
- New Cargo features: avsynth (macOS), sapi (Windows)
- Both engines implement TtsEngine trait with estimated word boundaries
- Factory registers engines with cfg-conditional compilation

Author: willwade

Cargo.toml

@@ -19,6 +19,8 @@ sherpaonnx = ["sherpa-onnx", "serde_json"]
 tungstenite = ["dep:tungstenite"]
 uuid = ["dep:uuid"]
 url = ["dep:url"]
+avsynth = ["objc", "objc-foundation"]
+sapi = ["windows"]
 
 [dependencies]
 speech-dispatcher = { version = "0.16", optional = true }
@@ -32,6 +34,12 @@ anyhow = "1"
 tungstenite = { version = "0.29.0", features = ["rustls-tls-webpki-roots"], optional = true }
 uuid = { version = "1.23.2", features = ["v4"], optional = true }
 url = { version = "2.5.8", optional = true }
+objc = { version = "0.2", optional = true }
+objc-foundation = { version = "0.1", optional = true }
+block2 = { version = "0.6", optional = true }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+windows = { version = "0.61", features = ["Win32_Media_Speech", "Win32_System_Com", "Win32_System_Ole"], optional = true }
 
 [build-dependencies]
 cbindgen = "0.28"

src/avsynth_engine.rs

@@ -0,0 +1,239 @@
+//! macOS AVSpeechSynthesizer engine via raw objc calls.
+
+use crate::engine::{estimate_word_boundaries, TtsEngine};
+use crate::types::{TtsError, TtsResult, Voice};
+use objc::runtime::Object;
+use objc::{class, msg_send, sel, sel_impl};
+use std::ffi::c_void;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct AvSynthEngine {
+    synth: Arc<Mutex<Option<*mut Object>>>,
+    voice_id: Mutex<Option<String>>,
+}
+
+unsafe impl Send for AvSynthEngine {}
+unsafe impl Sync for AvSynthEngine {}
+
+impl AvSynthEngine {
+    pub fn new() -> Self {
+        let synth = unsafe {
+            let cls = class!(AVSpeechSynthesizer);
+            let obj: *mut Object = msg_send![cls, alloc];
+            let obj: *mut Object = msg_send![obj, init];
+            if obj.is_null() {
+                None
+            } else {
+                Some(obj)
+            }
+        };
+        AvSynthEngine {
+            synth: Arc::new(Mutex::new(synth)),
+            voice_id: Mutex::new(None),
+        }
+    }
+}
+
+unsafe fn to_nsstring(s: &str) -> *mut Object {
+    let cls = class!(NSString);
+    let bytes = s.as_ptr() as *const c_void;
+    let len = s.len();
+    let ns: *mut Object = msg_send![cls, alloc];
+    let ns: *mut Object = msg_send![ns,
+        initWithBytes: bytes
+        length: len
+        encoding: 4usize
+    ];
+    ns
+}
+
+unsafe fn from_nsstring(ns: *mut Object) -> String {
+    if ns.is_null() {
+        return String::new();
+    }
+    let len: usize = msg_send![ns, lengthOfBytesUsingEncoding: 4usize];
+    if len == 0 {
+        return String::new();
+    }
+    let mut buf = vec![0u8; len];
+    let _: usize = msg_send![ns,
+        getBytes: buf.as_mut_ptr()
+        maxLength: len
+        encoding: 4usize
+        options: 1usize
+        range: (0usize, len)
+        remainingRange: std::ptr::null::<(usize, usize)>()
+    ];
+    String::from_utf8_lossy(&buf).into_owned()
+}
+
+fn rate_to_avsynth(rate: f32) -> f32 {
+    rate.clamp(0.1, 10.0)
+}
+
+fn pitch_to_avsynth(pitch: f32) -> f32 {
+    pitch.clamp(0.5, 2.0)
+}
+
+fn volume_to_avsynth(volume: f32) -> f32 {
+    volume.clamp(0.0, 1.0)
+}
+
+impl TtsEngine for AvSynthEngine {
+    fn speak(
+        &self,
+        text: &str,
+        voice: Option<&str>,
+        rate: f32,
+        pitch: f32,
+        volume: f32,
+        _on_audio: Option<crate::engine::OnAudioCallback>,
+        mut on_boundary: Option<crate::engine::OnBoundaryCallback>,
+    ) -> TtsResult<()> {
+        let guard = self.synth.lock().unwrap();
+        let synth = guard
+            .ok_or_else(|| TtsError("AVSpeechSynthesizer not initialized".into()))?;
+
+        unsafe {
+            let ns_text = to_nsstring(text);
+            let utterance_cls = class!(AVSpeechUtterance);
+            let u: *mut Object = msg_send![utterance_cls, alloc];
+            let u: *mut Object = msg_send![u, initWithString: ns_text];
+
+            if !u.is_null() {
+                let _: () = msg_send![u, setRate: rate_to_avsynth(rate)];
+                let _: () = msg_send![u, setPitchMultiplier: pitch_to_avsynth(pitch)];
+                let _: () = msg_send![u, setVolume: volume_to_avsynth(volume)];
+
+                let voice_to_use = voice
+                    .map(|v| v.to_string())
+                    .or_else(|| self.voice_id.lock().unwrap().clone());
+
+                if let Some(ref vid) = voice_to_use {
+                    let ns_vid = to_nsstring(vid);
+                    let voice_cls = class!(AVSpeechSynthesisVoice);
+                    let av_voice: *mut Object = msg_send![voice_cls, voiceWithIdentifier: ns_vid];
+                    if !av_voice.is_null() {
+                        let _: () = msg_send![u, setVoice: av_voice];
+                    }
+                }
+
+                let _: () = msg_send![synth, speakUtterance: u];
+                let _: () = msg_send![u, release];
+            }
+            let _: () = msg_send![ns_text, release];
+        }
+
+        if let Some(cb) = on_boundary.as_mut() {
+            let estimated = estimate_word_boundaries(text);
+            for b in &estimated {
+                #[allow(clippy::cast_precision_loss)]
+                let start = b.offset as f32 / 1000.0;
+                #[allow(clippy::cast_precision_loss)]
+                let end = (b.offset + b.duration) as f32 / 1000.0;
+                cb(&b.text, start, end);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn speak_sync(
+        &self,
+        text: &str,
+        voice: Option<&str>,
+        rate: f32,
+        pitch: f32,
+        volume: f32,
+        on_audio: Option<crate::engine::OnAudioCallback>,
+        on_boundary: Option<crate::engine::OnBoundaryCallback>,
+    ) -> TtsResult<()> {
+        self.speak(text, voice, rate, pitch, volume, on_audio, on_boundary)
+    }
+
+    fn stop(&self) -> TtsResult<()> {
+        let guard = self.synth.lock().unwrap();
+        if let Some(synth) = *guard {
+            unsafe {
+                let _: () = msg_send![synth, stopSpeakingAtBoundary: 0i32];
+            }
+        }
+        Ok(())
+    }
+
+    fn pause(&self) -> TtsResult<()> {
+        let guard = self.synth.lock().unwrap();
+        if let Some(synth) = *guard {
+            unsafe {
+                let _: () = msg_send![synth, pauseSpeakingAtBoundary: 0i32];
+            }
+        }
+        Ok(())
+    }
+
+    fn resume(&self) -> TtsResult<()> {
+        let guard = self.synth.lock().unwrap();
+        if let Some(synth) = *guard {
+            unsafe {
+                let _: () = msg_send![synth, continueSpeaking];
+            }
+        }
+        Ok(())
+    }
+
+    fn get_voices(&self) -> TtsResult<Vec<Voice>> {
+        unsafe {
+            let voice_cls = class!(AVSpeechSynthesisVoice);
+            let voices: *mut Object = msg_send![voice_cls, speechVoices];
+            if voices.is_null() {
+                return Ok(vec![]);
+            }
+
+            let count: usize = msg_send![voices, count];
+            let mut result = Vec::with_capacity(count);
+
+            for i in 0..count {
+                let v: *mut Object = msg_send![voices, objectAtIndex: i];
+                if !v.is_null() {
+                    let id_ptr: *mut Object = msg_send![v, identifier];
+                    let name_ptr: *mut Object = msg_send![v, name];
+                    let lang_ptr: *mut Object = msg_send![v, language];
+
+                    let id = from_nsstring(id_ptr);
+                    let name = from_nsstring(name_ptr);
+                    let lang = from_nsstring(lang_ptr);
+
+                    result.push(Voice {
+                        id,
+                        name,
+                        gender: crate::types::Gender::Unknown,
+                        provider: "avsynth".to_string(),
+                        language_codes: vec![crate::types::LanguageCode {
+                            bcp47: lang.clone(),
+                            iso639_3: lang.split('-').next().unwrap_or("en").to_string(),
+                            display: lang,
+                        }],
+                    });
+                }
+            }
+            Ok(result)
+        }
+    }
+
+    fn engine_id(&self) -> &'static str {
+        "avsynth"
+    }
+}
+
+impl Drop for AvSynthEngine {
+    fn drop(&mut self) {
+        if let Ok(mut guard) = self.synth.lock() {
+            if let Some(ptr) = guard.take() {
+                unsafe {
+                    let _: () = msg_send![ptr, release];
+                }
+            }
+        }
+    }
+}

src/factory.rs

@@ -10,6 +10,10 @@ use crate::cloud_engine;
 use crate::sherpaonnx_engine::SherpaOnnxEngine;
 #[cfg(feature = "system")]
 use crate::system_engine::SystemEngine;
+#[cfg(feature = "avsynth")]
+use crate::avsynth_engine::AvSynthEngine;
+#[cfg(feature = "sapi")]
+use crate::sapi_engine::SapiEngine;
 
 /// Create an engine by its string identifier.
 ///
@@ -22,6 +26,12 @@ pub fn create_engine(engine_id: &str, credentials_json: &str) -> Option<Box<dyn
         #[cfg(feature = "system")]
         "system" => Some(Box::new(SystemEngine::new())),
 
+        #[cfg(feature = "avsynth")]
+        "avsynth" => Some(Box::new(AvSynthEngine::new())),
+
+        #[cfg(feature = "sapi")]
+        "sapi" => Some(Box::new(SapiEngine::new())),
+
         #[cfg(feature = "sherpaonnx")]
         "sherpaonnx" => Some(Box::new(SherpaOnnxEngine::new(credentials_json))),
 
@@ -48,7 +58,23 @@ pub fn engine_list() -> Vec<EngineDescriptor> {
     #[cfg(feature = "system")]
     engines.push(EngineDescriptor {
         id: "system".into(),
-        name: "System".into(),
+        name: "System (Speech Dispatcher)".into(),
+        needs_credentials: false,
+        credential_keys_json: "[]".into(),
+    });
+
+    #[cfg(feature = "avsynth")]
+    engines.push(EngineDescriptor {
+        id: "avsynth".into(),
+        name: "macOS AVSpeechSynthesizer".into(),
+        needs_credentials: false,
+        credential_keys_json: "[]".into(),
+    });
+
+    #[cfg(feature = "sapi")]
+    engines.push(EngineDescriptor {
+        id: "sapi".into(),
+        name: "Windows SAPI".into(),
         needs_credentials: false,
         credential_keys_json: "[]".into(),
     });

src/lib.rs

@@ -37,6 +37,10 @@ pub mod factory;
 mod sherpaonnx_engine;
 #[cfg(feature = "system")]
 mod system_engine;
+#[cfg(feature = "avsynth")]
+mod avsynth_engine;
+#[cfg(feature = "sapi")]
+mod sapi_engine;
 pub mod types;
 
 use std::ffi::{CStr, CString};