.drone.yml

@@ -1,27 +0,0 @@
-kind: pipeline
-type: docker
-name: default
-
-steps:
-  - name: test
-    image: rust
-    commands:
-      - rustup component add clippy rustfmt
-      - apt-get update -qq
-      - apt-get install -qqy llvm-dev libclang-dev clang libspeechd-dev
-      - cargo fmt --all --check
-      - cargo test --no-default-features --features 0_10
-      - cargo clippy --no-default-features --features 0_10
-  - name: release
-    image: rust
-    commands:
-      - apt-get update -qq
-      - apt-get install -qqy llvm-dev libclang-dev clang libspeechd-dev
-      - cargo publish --no-default-features --features 0_10 --manifest-path speech-dispatcher-sys/Cargo.toml || true                                                                                                                                       
-      - cargo publish --no-default-features --features 0_10 --manifest-path speech-dispatcher/Cargo.toml                                                                                                                                                   
-    when:
-      ref:
-        - refs/tags/v*
-    environment:
-      CARGO_REGISTRY_TOKEN:
-        from_secret: cargo_registry_token

.gitlab-ci.yml

@@ -0,0 +1,25 @@
+image: rust
+
+stages:
+  - test
+  - publish
+
+before_script:
+  - apt-get update
+  - apt-get install -y libspeechd-dev llvm-dev libclang-dev clang
+
+test:
+  stage: test
+  script:
+  - cargo test
+
+publish:
+  stage: publish
+  script:
+  - cargo login $CARGO_TOKEN
+  - cargo package --manifest-path speech-dispatcher-sys/Cargo.toml
+  - cargo publish --manifest-path speech-dispatcher-sys/Cargo.toml || true
+  - cargo package --manifest-path speech-dispatcher/Cargo.toml
+  - cargo publish --manifest-path speech-dispatcher/Cargo.toml
+  only:
+  - tags

cliff.toml

@@ -1,60 +0,0 @@
-# configuration file for git-cliff (0.1.0)
-
-[changelog]
-# changelog header
-header = """
-# Changelog\n
-All notable changes to this project will be documented in this file.\n
-"""
-# template for the changelog body
-# https://tera.netlify.app/docs/#introduction
-body = """
-{% if version %}\
-    ## Version {{ version | trim_start_matches(pat="v") }} - {{ timestamp | date(format="%Y-%m-%d") }}
-{% else %}\
-    ## Unreleased
-{% endif %}\
-{% for group, commits in commits | group_by(attribute="group") %}
-    ### {{ group | upper_first }}
-    {% for commit in commits %}
-        - {% if commit.breaking %}[**breaking**] {% endif %}{{ commit.message | upper_first }}\
-    {% endfor %}
-{% endfor %}\n
-"""
-# remove the leading and trailing whitespace from the template
-trim = true
-# changelog footer
-footer = """
-<!-- generated by git-cliff -->
-"""
-
-[git]
-# parse the commits based on https://www.conventionalcommits.org
-conventional_commits = true
-# filter out the commits that are not conventional
-filter_unconventional = true
-# regex for parsing and grouping commits
-commit_parsers = [
-    { message = "^feat", group = "Features"},
-    { message = "^fix", group = "Bug Fixes"},
-    { message = "^doc", group = "Documentation"},
-    { message = "^perf", group = "Performance"},
-    { message = "^refactor", group = "Refactor"},
-    { message = "^style", group = "Styling"},
-    { message = "^test", group = "Testing"},
-    { message = "^chore\\(release\\): prepare for", skip = true},
-    { message = "^chore", group = "Miscellaneous Tasks"},
-    { body = ".*security", group = "Security"},
-]
-# filter out the commits that are not matched by commit parsers
-filter_commits = false
-# glob pattern for matching git tags
-tag_pattern = "v[0-9]*"
-# regex for skipping tags
-skip_tags = ""
-# regex for ignoring tags
-ignore_tags = ""
-# sort the tags chronologically
-date_order = false
-# sort the commits inside sections by oldest/newest order
-sort_commits = "oldest"

speech-dispatcher-sys/Cargo.toml

@@ -1,17 +1,13 @@
 [package]
 name = "speech-dispatcher-sys"
-version = "0.7.0"
+version = "0.5.2"
 authors = ["Nolan Darilek <nolan@thewordnerd.info>"]
-repository = "https://dev.thewordnerd.info/nolan/speech-dispatcher-rs"
+repository = "https://gitlab.com/ndarilek/speech-dispatcher-rs"
 description = "speech-dispatcher system bindings"
-license = "LGPL-2.1 OR MIT OR Apache-2.0"
-edition = "2021"
+license = "LGPL-2.1"
+edition = "2018"
 
 [build-dependencies]
-bindgen = ">= 0.54"
 
-[package.metadata.release]
-tag-prefix = ""
-publish = false
-push = false
-pre-release-hook = ["git-cliff", "-o", "CHANGELOG.md", "--tag", "{{version}}"]
+bindgen = ">= 0.54"
+gcc = "0.3"

speech-dispatcher/Cargo.toml

@@ -1,29 +1,12 @@
 [package]
 name = "speech-dispatcher"
-version = "0.16.0"
+version = "0.8.0"
 authors = ["Nolan Darilek <nolan@thewordnerd.info>"]
-repository = "https://dev.thewordnerd.info/nolan/speech-dispatcher-rs"
+repository = "https://gitlab.com/ndarilek/speech-dispatcher-rs"
 description = "Rusty interface to the speech-dispatcher speech synthesis library"
-license = "LGPL-2.1 OR MIT OR Apache-2.0"
-edition = "2021"
-
-[features]
-0_11 = ["0_10"]
-0_10 = []
-0_9 = []
-default = ["0_11"]
+license = "LGPL-2.1"
+edition = "2018"
 
 [dependencies]
 lazy_static = "1"
-speech-dispatcher-sys = { version = "0.7", path = "../speech-dispatcher-sys" }
-libc = "0.2.125"
-
-[package.metadata.docs.rs]
-no-default-features = true
-features = ["0_9"]
-
-[package.metadata.release]
-tag-prefix = ""
-publish = false
-push = false
-pre-release-hook = ["git-cliff", "-o", "CHANGELOG.md", "--tag", "{{version}}"]
+speech-dispatcher-sys = { version = "0.5", path = "../speech-dispatcher-sys" }

speech-dispatcher/examples/clone_drop.rs

@@ -1,42 +0,0 @@
-use speech_dispatcher::*;
-use std::io;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let connection = speech_dispatcher::Connection::open(
-        "hello_world",
-        "hello_world",
-        "hello_world",
-        Mode::Threaded,
-    )?;
-    connection.on_begin(Some(Box::new(|msg_id, client_id| {
-        println!("Beginning {} from {}", msg_id, client_id)
-    })));
-    connection.on_end(Some(Box::new(|msg_id, client_id| {
-        println!("Ending {} from {}", msg_id, client_id)
-    })));
-    let connection_clone = connection.clone();
-    drop(connection);
-    connection_clone.say(
-        Priority::Important,
-        format!(
-            "Hello, world at rate {} from client {}.",
-            connection_clone.get_voice_rate(),
-            connection_clone.client_id()
-        ),
-    );
-    connection_clone.set_voice_rate(100)?;
-    connection_clone.say(Priority::Important, "This is faster.");
-    connection_clone.set_voice_rate(0)?;
-    connection_clone.set_spelling(true)?;
-    connection_clone.say(Priority::Important, "This is spelled.");
-    connection_clone.set_spelling(false)?;
-    connection_clone.set_punctuation(Punctuation::All)?;
-    connection_clone.say(
-        Priority::Important,
-        "This statement, unlike others, has punctuation that is spoken!",
-    );
-    connection_clone.set_punctuation(Punctuation::None)?;
-    let mut _input = String::new();
-    io::stdin().read_line(&mut _input).unwrap();
-    Ok(())
-}

speech-dispatcher/examples/hello_world.rs

@@ -22,18 +22,18 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             connection.client_id()
         ),
     );
-    connection.set_voice_rate(100)?;
+    connection.set_voice_rate(100);
     connection.say(Priority::Important, "This is faster.");
-    connection.set_voice_rate(0)?;
-    connection.set_spelling(true)?;
+    connection.set_voice_rate(0);
+    connection.set_spelling(true);
     connection.say(Priority::Important, "This is spelled.");
-    connection.set_spelling(false)?;
-    connection.set_punctuation(Punctuation::All)?;
+    connection.set_spelling(false);
+    connection.set_punctuation(Punctuation::All);
     connection.say(
         Priority::Important,
         "This statement, unlike others, has punctuation that is spoken!",
     );
-    connection.set_punctuation(Punctuation::None)?;
+    connection.set_punctuation(Punctuation::None);
     let mut _input = String::new();
     io::stdin().read_line(&mut _input).unwrap();
     Ok(())

speech-dispatcher/examples/list_voices.rs

@@ -1,29 +0,0 @@
-use speech_dispatcher::*;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let connection = Connection::open("list_voices", "list_voices", "list_voices", Mode::Threaded)?;
-
-    let modules = connection.list_output_modules()?;
-    println!("Modules available: {:?}", modules);
-    for module in modules {
-        if connection.set_output_module(&module).is_ok() {
-            println!("Listing voices for module {module}");
-        } else {
-            println!("Failed to set output module to {module}");
-            continue;
-        };
-        let voices = connection.list_synthesis_voices()?;
-        for voice in voices {
-            if let Some(variant) = voice.variant {
-                println!(
-                    "    Name: {} / Language: {} / Variant: {variant}",
-                    voice.name, voice.language
-                );
-            } else {
-                println!("    Name: {} / Language: {}", voice.name, voice.language);
-            }
-        }
-    }
-    // Use connection.set_synthesis_voice(voice) to set the voice to use.
-    Ok(())
-}

speech-dispatcher/src/lib.rs

@@ -1,13 +1,11 @@
 #![allow(non_upper_case_globals)]
 
-use libc::size_t;
 use std::{
     collections::HashMap,
     ffi::{CStr, CString},
     fmt,
     marker::Send,
-    os::raw::{c_char, c_int},
-    sync::{Arc, Mutex},
+    sync::Mutex,
 };
 
 use lazy_static::lazy_static;
@@ -33,46 +31,18 @@ pub enum Priority {
 #[derive(Clone, Copy, Debug)]
 #[repr(u32)]
 pub enum VoiceType {
-    Male1 = SPDVoiceType::SPD_MALE1 as u32,
-    Male2 = SPDVoiceType::SPD_MALE2 as u32,
-    Male3 = SPDVoiceType::SPD_MALE3 as u32,
-    Female1 = SPDVoiceType::SPD_FEMALE1 as u32,
-    Female2 = SPDVoiceType::SPD_FEMALE2 as u32,
-    Female3 = SPDVoiceType::SPD_FEMALE3 as u32,
-    ChildMale = SPDVoiceType::SPD_CHILD_MALE as u32,
-    ChildFemale = SPDVoiceType::SPD_CHILD_FEMALE as u32,
+    Male1 = SPDVoiceType::SPD_MALE1,
+    Male2 = SPDVoiceType::SPD_MALE2,
+    Male3 = SPDVoiceType::SPD_MALE3,
+    Female1 = SPDVoiceType::SPD_FEMALE1,
+    Female2 = SPDVoiceType::SPD_FEMALE2,
+    Female3 = SPDVoiceType::SPD_FEMALE3,
+    ChildMale = SPDVoiceType::SPD_CHILD_MALE,
+    ChildFemale = SPDVoiceType::SPD_CHILD_FEMALE,
 }
 
-#[derive(Clone, Debug, Hash, PartialEq)]
-pub struct Voice {
-    /// The name of this voice. Unique with regards to the output module it came from.
-    pub name: String,
-    /// The language of this voice. Probably a BCP 47 language tag.
-    pub language: String,
-    /// The variant of this language, if present. Loosely defined.
-    pub variant: Option<String>,
-}
-
-impl Voice {
-    /// Convert a SPDVoice to a Voice. Only fails if the fields are non-Unicode.
-    /// Does not check that the pointers are non-null, caller must ensure that.
-    unsafe fn try_from(v: &SPDVoice) -> Result<Self, std::str::Utf8Error> {
-        // SPDVoice fields appear to all be ASCII.
-        let name = CStr::from_ptr(v.name).to_str()?.to_owned();
-        let language = CStr::from_ptr(v.language).to_str()?.to_owned();
-        let variant = CStr::from_ptr(v.variant).to_str()?;
-        let variant = if variant == "none" {
-            None
-        } else {
-            Some(variant.to_owned())
-        };
-        Ok(Self {
-            name,
-            language,
-            variant,
-        })
-    }
-}
+#[derive(Clone, Debug)]
+pub struct Connection(pub *mut SPDConnection, u64);
 
 pub type Address = SPDConnectionAddress;
 
@@ -99,10 +69,8 @@ pub enum Notification {
 #[repr(u32)]
 pub enum Punctuation {
     All = SPDPunctuation::SPD_PUNCT_ALL,
-    #[cfg(feature = "0_10")]
-    Most = SPDPunctuation::SPD_PUNCT_MOST,
-    Some = SPDPunctuation::SPD_PUNCT_SOME,
     None = SPDPunctuation::SPD_PUNCT_NONE,
+    Some = SPDPunctuation::SPD_PUNCT_SOME,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -113,22 +81,18 @@ pub enum CapitalLetters {
     Icon = SPDCapitalLetters::SPD_CAP_ICON,
 }
 
-/// Converts a `0` to a success and everything else to an error.
-fn c_int_to_result(r: c_int) -> Result<(), Error> {
-    match r {
-        0 => Ok(()),
-        _ => Err(Error::OperationFailed),
-    }
+fn i32_to_bool(v: i32) -> bool {
+    v == 1
 }
 
 #[derive(Default)]
 struct Callbacks {
-    begin: Option<Box<dyn FnMut(size_t, size_t)>>,
-    end: Option<Box<dyn FnMut(size_t, size_t)>>,
-    index_mark: Option<Box<dyn FnMut(size_t, size_t, String)>>,
-    cancel: Option<Box<dyn FnMut(size_t, size_t)>>,
-    pause: Option<Box<dyn FnMut(size_t, size_t)>>,
-    resume: Option<Box<dyn FnMut(size_t, size_t)>>,
+    begin: Option<Box<dyn FnMut(u64, u64)>>,
+    end: Option<Box<dyn FnMut(u64, u64)>>,
+    index_mark: Option<Box<dyn FnMut(u64, u64, String)>>,
+    cancel: Option<Box<dyn FnMut(u64, u64)>>,
+    pause: Option<Box<dyn FnMut(u64, u64)>>,
+    resume: Option<Box<dyn FnMut(u64, u64)>>,
 }
 
 unsafe impl Send for Callbacks {}
@@ -136,13 +100,13 @@ unsafe impl Send for Callbacks {}
 unsafe impl Sync for Callbacks {}
 
 lazy_static! {
-    static ref callbacks: Mutex<HashMap<size_t, Callbacks>> = {
+    static ref callbacks: Mutex<HashMap<u64, Callbacks>> = {
         let m = HashMap::new();
         Mutex::new(m)
     };
 }
 
-unsafe extern "C" fn cb(msg_id: size_t, client_id: size_t, state: u32) {
+unsafe extern "C" fn cb(msg_id: u64, client_id: u64, state: u32) {
     let state = match state {
         SPDNotificationType_SPD_EVENT_BEGIN => Notification::Begin,
         SPDNotificationType_SPD_EVENT_END => Notification::End,
@@ -166,7 +130,7 @@ unsafe extern "C" fn cb(msg_id: size_t, client_id: size_t, state: u32) {
     }
 }
 
-unsafe extern "C" fn cb_im(msg_id: size_t, client_id: size_t, state: u32, index_mark: *mut c_char) {
+unsafe extern "C" fn cb_im(msg_id: u64, client_id: u64, state: u32, index_mark: *mut i8) {
     let index_mark = CStr::from_ptr(index_mark);
     let index_mark = index_mark.to_string_lossy().to_string();
     let state = match state {
@@ -185,36 +149,28 @@ unsafe extern "C" fn cb_im(msg_id: size_t, client_id: size_t, state: u32, index_
 }
 
 #[derive(Debug)]
-pub enum Error {
-    /// speech-dispatcher failed to initialize. Ensure speech-dispatcher is actually working on
-    /// your system; for example, does the command `spd-say hello` work?
+pub enum SpeechDispatcherError {
     InitializationError,
-    /// The operation failed
-    OperationFailed,
 }
 
-impl std::error::Error for Error {}
+impl std::error::Error for SpeechDispatcherError {}
 
-impl fmt::Display for Error {
+impl fmt::Display for SpeechDispatcherError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Error::*;
+        use SpeechDispatcherError::*;
         match self {
-            InitializationError => write!(f, "failed to initialize"),
-            OperationFailed => write!(f, "operation failed"),
+            InitializationError => write!(f, "Failed to initialize"),
         }
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct Connection(pub Arc<*mut SPDConnection>, size_t);
-
 impl Connection {
     pub fn open<S: Into<String>>(
         client_name: S,
         connection_name: S,
         user_name: S,
         mode: Mode,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self, SpeechDispatcherError> {
         let clientname = CString::new(client_name.into()).unwrap();
         let connectionname = CString::new(connection_name.into()).unwrap();
         let username = CString::new(user_name.into()).unwrap();
@@ -226,14 +182,18 @@ impl Connection {
                 mode as u32,
             );
             if c.is_null() {
-                Err(Error::InitializationError)
+                None
             } else {
-                Ok(Self::setup_connection(c))
+                Some(Self::setup_connection(c))
             }
         };
-        let mut c = Self(Arc::new(connection?), 0);
-        c.setup()?;
+        if let Some(connection) = connection {
+            let mut c = Self(connection, 0);
+            c.setup();
             Ok(c)
+        } else {
+            Err(SpeechDispatcherError::InitializationError)
+        }
     }
 
     pub unsafe fn open2<S: Into<String>>(
@@ -243,7 +203,7 @@ impl Connection {
         mode: Mode,
         address: *mut Address,
         autospawn: bool,
-    ) -> Result<Self, Error> {
+    ) -> Self {
         let auto_spawn = if autospawn { 1 } else { 0 };
         let error_result = vec![CString::new("").unwrap().into_raw()].as_mut_ptr();
         let clientname = CString::new(client_name.into()).unwrap();
@@ -259,15 +219,11 @@ impl Connection {
                 auto_spawn,
                 error_result,
             );
-            if c.is_null() {
-                Err(Error::InitializationError)
-            } else {
-                Ok(Self::setup_connection(c))
-            }
+            Self::setup_connection(c)
         };
-        let mut c = Self(Arc::new(connection?), 0);
-        c.setup()?;
-        Ok(c)
+        let mut c = Self(connection, 0);
+        c.setup();
+        c
     }
 
     unsafe fn setup_connection(c: *mut SPDConnection) -> *mut SPDConnection {
@@ -280,7 +236,7 @@ impl Connection {
         c
     }
 
-    fn setup(&mut self) -> Result<(), Error> {
+    fn setup(&mut self) {
         let client_id = self.send_data("HISTORY GET CLIENT_ID\r\n", true);
         if let Some(client_id) = client_id {
             let client_id: Vec<&str> = client_id.split("\r\n").collect();
@@ -288,26 +244,24 @@ impl Connection {
             if let Some(client_id) = client_id {
                 let client_id: Vec<&str> = client_id.split("-").collect();
                 if let Some(client_id) = client_id.get(1) {
-                    if let Ok(client_id) = client_id.parse::<size_t>() {
+                    if let Ok(client_id) = client_id.parse::<u64>() {
                         self.1 = client_id;
                     }
                 }
             }
         }
         callbacks.lock().unwrap().insert(self.1, Default::default());
-        self.set_notification_on(Notification::All)
-            .map_err(|_| Error::InitializationError)?;
-        Ok(())
+        self.set_notification_on(Notification::All);
     }
 
     pub fn close(&self) {
-        unsafe { spd_close(*self.0) };
+        unsafe { spd_close(self.0) };
     }
 
     pub fn say<S: Into<String>>(&self, priority: Priority, text: S) -> Option<u64> {
         let text: String = text.into();
         let param = CString::new(text).unwrap();
-        let rv = unsafe { spd_say(*self.0, priority as u32, param.as_ptr()) };
+        let rv = unsafe { spd_say(self.0, priority as u32, param.as_ptr()) };
         if rv != -1 {
             Some(rv as u64)
         } else {
@@ -318,7 +272,7 @@ impl Connection {
     pub fn sayf<S: Into<String>>(&self, priority: Priority, format: S) -> Option<i32> {
         let format: String = format.into();
         let param = CString::new(format).unwrap();
-        let rv = unsafe { spd_sayf(*self.0, priority as u32, param.as_ptr()) };
+        let rv = unsafe { spd_sayf(self.0, priority as u32, param.as_ptr()) };
         if rv != -1 {
             Some(rv)
         } else {
@@ -326,120 +280,107 @@ impl Connection {
         }
     }
 
-    pub fn stop(&self) -> Result<(), Error> {
-        let v = unsafe { spd_stop(*self.0) };
-        c_int_to_result(v)
+    pub fn stop(&self) -> bool {
+        let v = unsafe { spd_stop(self.0) };
+        i32_to_bool(v)
     }
 
-    pub fn stop_all(&self) -> Result<(), Error> {
-        let v = unsafe { spd_stop_all(*self.0) };
-        c_int_to_result(v)
+    pub fn stop_all(&self) -> bool {
+        let v = unsafe { spd_stop_all(self.0) };
+        i32_to_bool(v)
     }
 
-    pub fn stop_uid(&self, target_uid: i32) -> Result<(), Error> {
-        let v = unsafe { spd_stop_uid(*self.0, target_uid) };
-        c_int_to_result(v)
+    pub fn stop_uid(&self, target_uid: i32) -> bool {
+        let v = unsafe { spd_stop_uid(self.0, target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn cancel(&self) -> Result<(), Error> {
-        let v = unsafe { spd_cancel(*self.0) };
-        c_int_to_result(v)
+    pub fn cancel(&self) -> bool {
+        let v = unsafe { spd_cancel(self.0) };
+        i32_to_bool(v)
     }
 
-    pub fn cancel_all(&self) -> Result<(), Error> {
-        let v = unsafe { spd_cancel_all(*self.0) };
-        c_int_to_result(v)
+    pub fn cancel_all(&self) -> bool {
+        let v = unsafe { spd_cancel_all(self.0) };
+        i32_to_bool(v)
     }
 
-    pub fn cancel_uid(&self, target_uid: i32) -> Result<(), Error> {
-        let v = unsafe { spd_cancel_uid(*self.0, target_uid) };
-        c_int_to_result(v)
+    pub fn cancel_uid(&self, target_uid: i32) -> bool {
+        let v = unsafe { spd_cancel_uid(self.0, target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn pause(&self) -> Result<(), Error> {
-        let v = unsafe { spd_pause(*self.0) };
-        c_int_to_result(v)
+    pub fn pause(&self) -> bool {
+        let v = unsafe { spd_pause(self.0) };
+        i32_to_bool(v)
     }
 
-    pub fn pause_all(&self) -> Result<(), Error> {
-        let v = unsafe { spd_pause_all(*self.0) };
-        c_int_to_result(v)
+    pub fn pause_all(&self) -> bool {
+        let v = unsafe { spd_pause_all(self.0) };
+        i32_to_bool(v)
     }
 
-    pub fn pause_uid(&self, target_uid: i32) -> Result<(), Error> {
-        let v = unsafe { spd_pause_uid(*self.0, target_uid) };
-        c_int_to_result(v)
+    pub fn pause_uid(&self, target_uid: i32) -> bool {
+        let v = unsafe { spd_pause_uid(self.0, target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn resume(&self) -> Result<(), Error> {
-        let v = unsafe { spd_resume(*self.0) };
-        c_int_to_result(v)
+    pub fn resume(&self) -> bool {
+        let v = unsafe { spd_resume(self.0) };
+        i32_to_bool(v)
     }
 
-    pub fn resume_all(&self) -> Result<(), Error> {
-        let v = unsafe { spd_resume_all(*self.0) };
-        c_int_to_result(v)
+    pub fn resume_all(&self) -> bool {
+        let v = unsafe { spd_resume_all(self.0) };
+        i32_to_bool(v)
     }
 
-    pub fn resume_uid(&self, target_uid: i32) -> Result<(), Error> {
-        let v = unsafe { spd_resume_uid(*self.0, target_uid) };
-        c_int_to_result(v)
+    pub fn resume_uid(&self, target_uid: i32) -> bool {
+        let v = unsafe { spd_resume_uid(self.0, target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn key<S: Into<String>>(&self, priority: Priority, key_name: S) -> Result<(), Error> {
+    pub fn key<S: Into<String>>(&self, priority: Priority, key_name: S) -> bool {
         let param = CString::new(key_name.into()).unwrap();
-        let v = unsafe { spd_key(*self.0, priority as u32, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_key(self.0, priority as u32, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn char<S: Into<String>>(&self, priority: Priority, char: S) -> Result<(), Error> {
+    pub fn char<S: Into<String>>(&self, priority: Priority, char: S) -> bool {
         let param = CString::new(char.into()).unwrap();
-        let v = unsafe { spd_char(*self.0, priority as u32, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_char(self.0, priority as u32, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn wchar(&self, priority: Priority, wchar: i32) -> Result<(), Error> {
-        let v = unsafe { spd_wchar(*self.0, priority as u32, wchar as wchar_t) };
-        c_int_to_result(v)
+    pub fn wchar(&self, priority: Priority, wchar: i32) -> bool {
+        let v = unsafe { spd_wchar(self.0, priority as u32, wchar) };
+        i32_to_bool(v)
     }
 
-    pub fn sound_icon<S: Into<String>>(
-        &self,
-        priority: Priority,
-        icon_name: S,
-    ) -> Result<(), Error> {
+    pub fn sound_icon<S: Into<String>>(&self, priority: Priority, icon_name: S) -> bool {
         let param = CString::new(icon_name.into()).unwrap();
-        let v = unsafe { spd_char(*self.0, priority as u32, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_char(self.0, priority as u32, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn set_voice_type(&self, voice_type: VoiceType) -> Result<(), Error> {
-        #[cfg(all(any(feature = "0_9", feature = "0_10"), not(feature = "0_11")))]
-        let v = unsafe { spd_set_voice_type(*self.0, voice_type as u32) };
-        #[cfg(all(not(feature = "0_9"), any(feature = "0_11", not(feature = "0_10"))))]
-        let v = unsafe { spd_set_voice_type(*self.0, voice_type as i32) };
-        c_int_to_result(v)
+    pub fn set_voice_type(&self, voice_type: VoiceType) -> bool {
+        let v = unsafe { spd_set_voice_type(self.0, voice_type as u32) };
+        i32_to_bool(v)
     }
 
-    pub fn set_voice_type_all(&self, voice_type: VoiceType) -> Result<(), Error> {
-        #[cfg(all(any(feature = "0_9", feature = "0_10"), not(feature = "0_11")))]
-        let v = unsafe { spd_set_voice_type_all(*self.0, voice_type as u32) };
-        #[cfg(all(not(feature = "0_9"), any(feature = "0_11", not(feature = "0_10"))))]
-        let v = unsafe { spd_set_voice_type_all(*self.0, voice_type as i32) };
-        c_int_to_result(v)
+    pub fn set_voice_type_all(&self, voice_type: VoiceType) -> bool {
+        let v = unsafe { spd_set_voice_type_all(self.0, voice_type as u32) };
+        i32_to_bool(v)
     }
 
-    pub fn set_voice_type_uid(&self, voice_type: VoiceType, target_uid: u32) -> Result<(), Error> {
-        #[cfg(all(any(feature = "0_9", feature = "0_10"), not(feature = "0_11")))]
-        let v = unsafe { spd_set_voice_type_uid(*self.0, voice_type as u32, target_uid) };
-        #[cfg(all(not(feature = "0_9"), any(feature = "0_11", not(feature = "0_10"))))]
-        let v = unsafe { spd_set_voice_type_uid(*self.0, voice_type as i32, target_uid) };
-        c_int_to_result(v)
+    pub fn set_voice_type_uid(&self, voice_type: VoiceType, target_uid: u32) -> bool {
+        let v = unsafe { spd_set_voice_type_uid(self.0, voice_type as u32, target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn get_voice_type(&self) -> Result<VoiceType, Error> {
-        let v = unsafe { spd_get_voice_type(*self.0) };
-        Ok(match v {
+    pub fn get_voice_type(&self) -> VoiceType {
+        let v = unsafe { spd_get_voice_type(self.0) };
+        match v {
             SPDVoiceType::SPD_MALE1 => VoiceType::Male1,
             SPDVoiceType::SPD_MALE2 => VoiceType::Male2,
             SPDVoiceType::SPD_MALE3 => VoiceType::Male3,
@@ -448,234 +389,213 @@ impl Connection {
             SPDVoiceType::SPD_FEMALE3 => VoiceType::Female3,
             SPDVoiceType::SPD_CHILD_MALE => VoiceType::ChildMale,
             SPDVoiceType::SPD_CHILD_FEMALE => VoiceType::ChildFemale,
-            _ => return Err(Error::OperationFailed), // can this happen?
-        })
+            _ => panic!("Invalid voice type"),
+        }
     }
 
-    pub fn set_synthesis_voice(&self, voice: &Voice) -> Result<(), Error> {
-        let param = CString::new(voice.name.clone()).unwrap();
-        let v = unsafe { spd_set_synthesis_voice(*self.0, param.as_ptr()) };
-        c_int_to_result(v)
-    }
-
-    pub fn set_synthesis_voice_all<S: Into<String>>(&self, voice_name: S) -> Result<(), Error> {
+    pub fn set_synthesis_voice<S: Into<String>>(&self, voice_name: S) -> bool {
         let param = CString::new(voice_name.into()).unwrap();
-        let v = unsafe { spd_set_synthesis_voice_all(*self.0, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_synthesis_voice(self.0, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn set_synthesis_voice_uid<S: Into<String>>(
-        &self,
-        voice_name: S,
-        target_uid: u32,
-    ) -> Result<(), Error> {
+    pub fn set_synthesis_voice_all<S: Into<String>>(&self, voice_name: S) -> bool {
         let param = CString::new(voice_name.into()).unwrap();
-        let v = unsafe { spd_set_synthesis_voice_uid(*self.0, param.as_ptr(), target_uid) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_synthesis_voice_all(self.0, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn set_data_mode(&self, mode: DataMode) -> Result<(), Error> {
-        let v = unsafe { spd_set_data_mode(*self.0, mode as u32) };
-        c_int_to_result(v)
+    pub fn set_synthesis_voice_uid<S: Into<String>>(&self, voice_name: S, target_uid: u32) -> bool {
+        let param = CString::new(voice_name.into()).unwrap();
+        let v = unsafe { spd_set_synthesis_voice_uid(self.0, param.as_ptr(), target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn set_notification_on(&self, notification: Notification) -> Result<(), Error> {
-        let v = unsafe { spd_set_notification_on(*self.0, notification as u32) };
-        c_int_to_result(v)
+    pub fn set_data_mode(&self, mode: DataMode) -> bool {
+        let v = unsafe { spd_set_data_mode(self.0, mode as u32) };
+        i32_to_bool(v)
     }
 
-    pub fn set_notification_off(&self, notification: Notification) -> Result<(), Error> {
-        let v = unsafe { spd_set_notification_off(*self.0, notification as u32) };
-        c_int_to_result(v)
+    pub fn set_notification_on(&self, notification: Notification) -> bool {
+        let v = unsafe { spd_set_notification_on(self.0, notification as u32) };
+        i32_to_bool(v)
     }
 
-    pub fn set_notification<S: Into<String>>(
-        &self,
-        notification: Notification,
-        state: S,
-    ) -> Result<(), Error> {
+    pub fn set_notification_off(&self, notification: Notification) -> bool {
+        let v = unsafe { spd_set_notification_off(self.0, notification as u32) };
+        i32_to_bool(v)
+    }
+
+    pub fn set_notification<S: Into<String>>(&self, notification: Notification, state: S) -> bool {
         let param = CString::new(state.into()).unwrap();
-        let v = unsafe { spd_set_notification(*self.0, notification as u32, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_notification(self.0, notification as u32, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn set_voice_rate(&self, rate: i32) -> Result<(), Error> {
-        let v = unsafe { spd_set_voice_rate(*self.0, rate) };
-        c_int_to_result(v)
+    pub fn set_voice_rate(&self, rate: i32) -> bool {
+        let v = unsafe { spd_set_voice_rate(self.0, rate) };
+        i32_to_bool(v)
     }
 
-    pub fn set_voice_rate_all(&self, rate: i32) -> Result<(), Error> {
-        let v = unsafe { spd_set_voice_rate_all(*self.0, rate) };
-        c_int_to_result(v)
+    pub fn set_voice_rate_all(&self, rate: i32) -> bool {
+        let v = unsafe { spd_set_voice_rate_all(self.0, rate) };
+        i32_to_bool(v)
     }
 
-    pub fn set_voice_rate_uid(&self, rate: i32, target_uid: u32) -> Result<(), Error> {
-        let v = unsafe { spd_set_voice_rate_uid(*self.0, rate, target_uid) };
-        c_int_to_result(v)
+    pub fn set_voice_rate_uid(&self, rate: i32, target_uid: u32) -> bool {
+        let v = unsafe { spd_set_voice_rate_uid(self.0, rate, target_uid) };
+        i32_to_bool(v)
     }
 
     pub fn get_voice_rate(&self) -> i32 {
-        unsafe { spd_get_voice_rate(*self.0) }
+        unsafe { spd_get_voice_rate(self.0) }
     }
 
-    pub fn set_voice_pitch(&self, pitch: i32) -> Result<(), Error> {
-        let v = unsafe { spd_set_voice_pitch(*self.0, pitch) };
-        c_int_to_result(v)
+    pub fn set_voice_pitch(&self, pitch: i32) -> bool {
+        let v = unsafe { spd_set_voice_pitch(self.0, pitch) };
+        i32_to_bool(v)
     }
 
-    pub fn set_voice_pitch_all(&self, pitch: i32) -> Result<(), Error> {
-        let v = unsafe { spd_set_voice_pitch_all(*self.0, pitch) };
-        c_int_to_result(v)
+    pub fn set_voice_pitch_all(&self, pitch: i32) -> bool {
+        let v = unsafe { spd_set_voice_pitch_all(self.0, pitch) };
+        i32_to_bool(v)
     }
 
-    pub fn set_voice_pitch_uid(&self, pitch: i32, target_uid: u32) -> Result<(), Error> {
-        let v = unsafe { spd_set_voice_pitch_uid(*self.0, pitch, target_uid) };
-        c_int_to_result(v)
+    pub fn set_voice_pitch_uid(&self, pitch: i32, target_uid: u32) -> bool {
+        let v = unsafe { spd_set_voice_pitch_uid(self.0, pitch, target_uid) };
+        i32_to_bool(v)
     }
 
     pub fn get_voice_pitch(&self) -> i32 {
-        unsafe { spd_get_voice_pitch(*self.0) }
+        unsafe { spd_get_voice_pitch(self.0) }
     }
 
-    pub fn set_volume(&self, volume: i32) -> Result<(), Error> {
-        let v = unsafe { spd_set_volume(*self.0, volume) };
-        c_int_to_result(v)
+    pub fn set_volume(&self, volume: i32) -> bool {
+        let v = unsafe { spd_set_volume(self.0, volume) };
+        i32_to_bool(v)
     }
 
-    pub fn set_volume_all(&self, volume: i32) -> Result<(), Error> {
-        let v = unsafe { spd_set_volume_all(*self.0, volume) };
-        c_int_to_result(v)
+    pub fn set_volume_all(&self, volume: i32) -> bool {
+        let v = unsafe { spd_set_volume_all(self.0, volume) };
+        i32_to_bool(v)
     }
 
-    pub fn set_volume_uid(&self, volume: i32, target_uid: u32) -> Result<(), Error> {
-        let v = unsafe { spd_set_volume_uid(*self.0, volume, target_uid) };
-        c_int_to_result(v)
+    pub fn set_volume_uid(&self, volume: i32, target_uid: u32) -> bool {
+        let v = unsafe { spd_set_volume_uid(self.0, volume, target_uid) };
+        i32_to_bool(v)
     }
 
     pub fn get_volume(&self) -> i32 {
-        unsafe { spd_get_volume(*self.0) }
+        unsafe { spd_get_volume(self.0) }
     }
 
-    pub fn set_punctuation(&self, punctuation: Punctuation) -> Result<(), Error> {
-        let v = unsafe { spd_set_punctuation(*self.0, punctuation as u32) };
-        c_int_to_result(v)
+    pub fn set_punctuation(&self, punctuation: Punctuation) -> bool {
+        let v = unsafe { spd_set_punctuation(self.0, punctuation as u32) };
+        i32_to_bool(v)
     }
 
-    pub fn set_punctuation_all(&self, punctuation: Punctuation) -> Result<(), Error> {
-        let v = unsafe { spd_set_punctuation_all(*self.0, punctuation as u32) };
-        c_int_to_result(v)
+    pub fn set_punctuation_all(&self, punctuation: Punctuation) -> bool {
+        let v = unsafe { spd_set_punctuation_all(self.0, punctuation as u32) };
+        i32_to_bool(v)
     }
 
-    pub fn set_punctuation_uid(
-        &self,
-        punctuation: Punctuation,
-        target_uid: u32,
-    ) -> Result<(), Error> {
-        let v = unsafe { spd_set_punctuation_uid(*self.0, punctuation as u32, target_uid) };
-        c_int_to_result(v)
+    pub fn set_punctuation_uid(&self, punctuation: Punctuation, target_uid: u32) -> bool {
+        let v = unsafe { spd_set_punctuation_uid(self.0, punctuation as u32, target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn set_capital_letters(&self, capital_letters: CapitalLetters) -> Result<(), Error> {
-        let v = unsafe { spd_set_capital_letters(*self.0, capital_letters as u32) };
-        c_int_to_result(v)
+    pub fn set_capital_letters(&self, capital_letters: CapitalLetters) -> bool {
+        let v = unsafe { spd_set_capital_letters(self.0, capital_letters as u32) };
+        i32_to_bool(v)
     }
 
-    pub fn set_capital_letters_all(&self, capital_letters: CapitalLetters) -> Result<(), Error> {
-        let v = unsafe { spd_set_capital_letters_all(*self.0, capital_letters as u32) };
-        c_int_to_result(v)
+    pub fn set_capital_letters_all(&self, capital_letters: CapitalLetters) -> bool {
+        let v = unsafe { spd_set_capital_letters_all(self.0, capital_letters as u32) };
+        i32_to_bool(v)
     }
 
     pub fn set_capital_letters_uid(
         &self,
         capital_letters: CapitalLetters,
         target_uid: u32,
-    ) -> Result<(), Error> {
-        let v = unsafe { spd_set_capital_letters_uid(*self.0, capital_letters as u32, target_uid) };
-        c_int_to_result(v)
+    ) -> bool {
+        let v = unsafe { spd_set_capital_letters_uid(self.0, capital_letters as u32, target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn set_spelling(&self, spelling: bool) -> Result<(), Error> {
+    pub fn set_spelling(&self, spelling: bool) -> bool {
         let s = if spelling {
             SPDSpelling::SPD_SPELL_ON
         } else {
             SPDSpelling::SPD_SPELL_OFF
         };
-        let v = unsafe { spd_set_spelling(*self.0, s) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_spelling(self.0, s) };
+        i32_to_bool(v)
     }
 
-    pub fn set_spelling_all(&self, spelling: bool) -> Result<(), Error> {
+    pub fn set_spelling_all(&self, spelling: bool) -> bool {
         let s = if spelling {
             SPDSpelling::SPD_SPELL_ON
         } else {
             SPDSpelling::SPD_SPELL_OFF
         };
-        let v = unsafe { spd_set_spelling_all(*self.0, s) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_spelling_all(self.0, s) };
+        i32_to_bool(v)
     }
 
-    pub fn set_spelling_uid(&self, spelling: bool, target_uid: u32) -> Result<(), Error> {
+    pub fn set_spelling_uid(&self, spelling: bool, target_uid: u32) -> bool {
         let s = if spelling {
             SPDSpelling::SPD_SPELL_ON
         } else {
             SPDSpelling::SPD_SPELL_OFF
         };
-        let v = unsafe { spd_set_spelling_uid(*self.0, s, target_uid) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_spelling_uid(self.0, s, target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn set_language<S: Into<String>>(&self, language: S) -> Result<(), Error> {
+    pub fn set_language<S: Into<String>>(&self, language: S) -> bool {
         let param = CString::new(language.into()).unwrap();
-        let v = unsafe { spd_set_language(*self.0, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_language(self.0, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn set_language_all<S: Into<String>>(&self, language: S) -> Result<(), Error> {
+    pub fn set_language_all<S: Into<String>>(&self, language: S) -> bool {
         let param = CString::new(language.into()).unwrap();
-        let v = unsafe { spd_set_language_all(*self.0, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_language_all(self.0, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn set_language_uid<S: Into<String>>(
-        &self,
-        language: S,
-        target_uid: u32,
-    ) -> Result<(), Error> {
+    pub fn set_language_uid<S: Into<String>>(&self, language: S, target_uid: u32) -> bool {
         let param = CString::new(language.into()).unwrap();
-        let v = unsafe { spd_set_language_uid(*self.0, param.as_ptr(), target_uid) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_language_uid(self.0, param.as_ptr(), target_uid) };
+        i32_to_bool(v)
     }
 
-    pub fn get_language(&self) -> Result<&str, Error> {
-        let language = unsafe { spd_get_language(*self.0) };
-        if language.is_null() {
-            Err(Error::OperationFailed)
-        } else {
-            let language = unsafe { CStr::from_ptr(language) };
-            language.to_str().map_err(|_| Error::OperationFailed)
-        }
+    pub fn get_language(&self) -> &str {
+        let v = unsafe { CStr::from_ptr(spd_get_language(self.0)) };
+        v.to_str().unwrap()
     }
 
-    pub fn set_output_module<S: Into<String>>(&self, output_module: S) -> Result<(), Error> {
+    pub fn set_output_module<S: Into<String>>(&self, output_module: S) -> bool {
         let param = CString::new(output_module.into()).unwrap();
-        let v = unsafe { spd_set_output_module(*self.0, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_output_module(self.0, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
-    pub fn set_output_module_all<S: Into<String>>(&self, output_module: S) -> Result<(), Error> {
+    pub fn set_output_module_all<S: Into<String>>(&self, output_module: S) -> bool {
         let param = CString::new(output_module.into()).unwrap();
-        let v = unsafe { spd_set_output_module_all(*self.0, param.as_ptr()) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_output_module_all(self.0, param.as_ptr()) };
+        i32_to_bool(v)
     }
 
     pub fn set_output_module_uid<S: Into<String>>(
         &self,
         output_module: S,
         target_uid: u32,
-    ) -> Result<(), Error> {
+    ) -> bool {
         let param = CString::new(output_module.into()).unwrap();
-        let v = unsafe { spd_set_output_module_uid(*self.0, param.as_ptr(), target_uid) };
-        c_int_to_result(v)
+        let v = unsafe { spd_set_output_module_uid(self.0, param.as_ptr(), target_uid) };
+        i32_to_bool(v)
     }
 
     pub fn send_data<S: Into<String>>(&self, data: S, wait_for_reply: bool) -> Option<String> {
@@ -685,7 +605,7 @@ impl Connection {
             SPD_NO_REPLY as i32
         };
         let data = CString::new(data.into()).unwrap();
-        let rv = unsafe { spd_send_data(*self.0, data.as_ptr(), wfr) };
+        let rv = unsafe { spd_send_data(self.0, data.as_ptr(), wfr) };
         if rv.is_null() {
             None
         } else {
@@ -694,7 +614,7 @@ impl Connection {
         }
     }
 
-    pub fn on_begin(&self, f: Option<Box<dyn FnMut(size_t, size_t)>>) {
+    pub fn on_begin(&self, f: Option<Box<dyn FnMut(u64, u64)>>) {
         if let Ok(mut cbs) = callbacks.lock() {
             let cb = cbs.get_mut(&self.1);
             if let Some(cb) = cb {
@@ -703,7 +623,7 @@ impl Connection {
         }
     }
 
-    pub fn on_end(&self, f: Option<Box<dyn FnMut(size_t, size_t)>>) {
+    pub fn on_end(&self, f: Option<Box<dyn FnMut(u64, u64)>>) {
         if let Ok(mut cbs) = callbacks.lock() {
             let cb = cbs.get_mut(&self.1);
             if let Some(cb) = cb {
@@ -712,7 +632,7 @@ impl Connection {
         }
     }
 
-    pub fn on_cancel(&self, f: Option<Box<dyn FnMut(size_t, size_t)>>) {
+    pub fn on_cancel(&self, f: Option<Box<dyn FnMut(u64, u64)>>) {
         if let Ok(mut cbs) = callbacks.lock() {
             let cb = cbs.get_mut(&self.1);
             if let Some(cb) = cb {
@@ -721,7 +641,7 @@ impl Connection {
         }
     }
 
-    pub fn on_pause(&self, f: Option<Box<dyn FnMut(size_t, size_t)>>) {
+    pub fn on_pause(&self, f: Option<Box<dyn FnMut(u64, u64)>>) {
         if let Ok(mut cbs) = callbacks.lock() {
             let cb = cbs.get_mut(&self.1);
             if let Some(cb) = cb {
@@ -730,7 +650,7 @@ impl Connection {
         }
     }
 
-    pub fn on_resume(&self, f: Option<Box<dyn FnMut(size_t, size_t)>>) {
+    pub fn on_resume(&self, f: Option<Box<dyn FnMut(u64, u64)>>) {
         if let Ok(mut cbs) = callbacks.lock() {
             let cb = cbs.get_mut(&self.1);
             if let Some(cb) = cb {
@@ -739,7 +659,7 @@ impl Connection {
         }
     }
 
-    pub fn on_index_mark(&self, f: Option<Box<dyn FnMut(size_t, size_t, String)>>) {
+    pub fn on_index_mark(&self, f: Option<Box<dyn FnMut(u64, u64, String)>>) {
         if let Ok(mut cbs) = callbacks.lock() {
             let cb = cbs.get_mut(&self.1);
             if let Some(cb) = cb {
@@ -748,72 +668,16 @@ impl Connection {
         }
     }
 
-    pub fn list_synthesis_voices(&self) -> Result<Vec<Voice>, Error> {
-        let start = unsafe { spd_list_synthesis_voices(*self.0) };
-        let slice = unsafe { null_term_array_ptr_to_slice(start) }.ok_or(Error::OperationFailed)?;
-        let voices = unsafe {
-            slice
-                .iter()
-                .map(|v| v.read())
-                .flat_map(|v| {
-                    if v.name.is_null() || v.language.is_null() || v.variant.is_null() {
-                        None
-                    } else {
-                        Voice::try_from(&v).ok()
-                    }
-                })
-                .collect()
-        };
-        unsafe {
-            free_spd_voices(start);
-        }
-        Ok(voices)
-    }
-
-    pub fn list_output_modules(&self) -> Result<Vec<String>, Error> {
-        let start = unsafe { spd_list_modules(*self.0) };
-        let slice = unsafe { null_term_array_ptr_to_slice(start) }.ok_or(Error::OperationFailed)?;
-        let modules = unsafe {
-            slice
-                .iter()
-                .flat_map(|v| CStr::from_ptr(*v).to_str().ok().map(String::from))
-                .collect()
-        };
-        unsafe {
-            free_spd_modules(start);
-        }
-        Ok(modules)
-    }
-
-    pub fn client_id(&self) -> size_t {
+    pub fn client_id(&self) -> u64 {
         self.1
     }
 }
 
-/// Interpret a null-terminated array of pointers as a slice of pointers.
-/// None of the pointers will be null if this returns Some.
-unsafe fn null_term_array_ptr_to_slice<'a, T>(start: *mut *mut T) -> Option<&'a [*mut T]> {
-    if start.is_null() {
-        return None;
-    }
-    let mut current = start;
-    let mut len = 0;
-
-    while !current.read().is_null() {
-        len += 1;
-        current = current.add(1);
-    }
-
-    Some(std::slice::from_raw_parts(start, len))
-}
-
 unsafe impl Send for Connection {}
 
 impl Drop for Connection {
     fn drop(&mut self) {
-        if Arc::strong_count(&self.0) <= 1 {
         self.close();
         callbacks.lock().unwrap().remove(&self.1);
     }
-    }
 }