speechd_module_sys/

types.rs

use std::os::raw;

use bitflags::bitflags;


unsafe fn cstr_eq(a: *const raw::c_char, b: *const raw::c_char) -> bool {
	if a.is_null() && b.is_null() {
		true
	} else if a.is_null() != b.is_null() {
		false
	} else {
		unsafe { libc::strcmp(a, b) == 0 }
	}
}


#[repr(C)]
#[non_exhaustive]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub enum MessageType {
	#[default]
	Text = 0,
	SoundIcon = 1,
	Char = 2,
	Key = 3,
	Spell = 99,
}


/// Symbolic voice type
///
/// These values are approximations for human display, output modules are
/// free to interpret their meanings in any way they consider sensible.
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub enum VoiceType {
	Male1 = 1,
	Male2 = 2,
	Male3 = 3,
	Female1 = 4,
	Female2 = 5,
	Female3 = 6,
	ChildMale = 7,
	ChildFemale = 8,
	#[default]
	Unspecified = -1,
}

impl<'a> TryFrom<&'a str> for VoiceType {
	type Error = ();

	fn try_from(text: &'a str) -> Result<Self, ()> {
		match text {
			"male1" => Ok(Self::Male1),
			"male2" => Ok(Self::Male2),
			"male3" => Ok(Self::Male3),
			"female1" => Ok(Self::Female1),
			"female2" => Ok(Self::Female2),
			"female3" => Ok(Self::Female3),
			"child_male" => Ok(Self::ChildMale),
			"child_female" => Ok(Self::ChildFemale),
			"other" | "unspecified" | "non_binary" | "androgynous" | "agender" => Ok(Self::Unspecified),

			_ => Err(()),
		}
	}
}


/// Punctuation verbosity mode
///
/// Which characters full under the [`Some`](Punctuation::Some) and
/// [`Most`](Punctuation::Most) sets is ultimately up to each output module.
/// For instance, `module_utils.c` defines “`~#$%^&*+=|<>[]_`” as a possible
/// default set, but ultimately this should be made configurable or carefully
/// trained for in your module.
#[repr(u32)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub enum Punctuation {
	/// Speak all punctuation characters
	All = 0,

	/// Speak none of the punctuation characters
	#[default]
	None = 1,

	/// Speak a smaller intermediate set of punctuation characters
	Some = 2,

	/// Speak a larger intermediate set of punctuation characters
	Most = 3,
}

impl<'a> TryFrom<&'a str> for Punctuation {
	type Error = ();

	fn try_from(text: &'a str) -> Result<Self, ()> {
		match text {
			"none" => Ok(Self::None),
			"all" => Ok(Self::All),
			"some" => Ok(Self::Some),
			"most" => Ok(Self::Most),

			_ => Err(()),
		}
	}
}


/// Capital letter recognition
///
/// This settings only affect consecutive runs of capital letters (eg: “SSIP”),
/// not words starting with a single capital letter (eg: “Berlin”).
#[repr(C)]
#[non_exhaustive]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub enum CapitalLetters {
	/// Captial letter blocks should be pronounced as as other words
	#[default]
	None = 0,

	/// Captial letter blocks should be spelled as individual letters
	Spell = 1,

	/// Captial letter blocks should have each letter prepended by the
	/// “`capital`” sound icon (generally a short tick sound)
	Icon = 2,
}

impl<'a> TryFrom<&'a str> for CapitalLetters {
	type Error = ();

	fn try_from(text: &'a str) -> Result<Self, ()> {
		match text {
			"none" => Ok(Self::None),
			"spell" => Ok(Self::Spell),
			"icon" => Ok(Self::Icon),

			_ => Err(()),
		}
	}
}


/// Spelling mode enabled
///
/// Informational in the context of an output module, as speech dispatcher
/// itself will perform the transformation of regular text into indiviual
/// character spellings.
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub enum Spelling {
	#[default]
	Off = 0,
	On = 1,
}

impl<'a> TryFrom<&'a str> for Spelling {
	type Error = ();

	fn try_from(text: &'a str) -> Result<Self, ()> {
		match text {
			"on" => Ok(Self::On),
			"off" => Ok(Self::Off),

			_ => Err(()),
		}
	}
}


#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub enum DataMode {
	#[default]
	Text = 0,
	SSML = 1,
}


#[repr(C)]
#[non_exhaustive]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub enum Priority {
	Important = 1,
	#[default]
	Message = 2,
	Text = 3,
	Notification = 4,
	Progress = 5,
}

impl<'a> TryFrom<&'a str> for Priority {
	type Error = ();

	fn try_from(text: &'a str) -> Result<Self, ()> {
		match text {
			"important" => Ok(Self::Important),
			"message" => Ok(Self::Message),
			"text" => Ok(Self::Text),
			"notification" => Ok(Self::Notification),
			"progress" => Ok(Self::Progress),

			_ => Err(()),
		}
	}
}


bitflags! {
	#[non_exhaustive]
	#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
	pub struct Notification: u32 {
		const Begin      = 0b00000001;
		const End        = 0b00000010;
		const IndexMarks = 0b00000100;
		const Cancel     = 0b00001000;
		const Pause      = 0b00010000;
		const Resume     = 0b00100000;
		const All        = 0b00111111;
	}
}

impl Default for Notification {
	fn default() -> Self {
		Notification::empty()
	}
}


#[repr(C)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum NotificationType {
	Begin = 0,
	End = 1,
	IndexMark = 2,
	Cancel = 3,
	Pause = 4,
	Resume = 5,
}


#[repr(C)]
#[derive(Debug, Default, Eq)]
pub struct Voice {
	/// Name of the voice (id)
	pub name: *const raw::c_char,

	/// Subset of BCP-47
	///
	/// A 2/3-letter ISO language code, possibly followed by a hyphen and a
	/// 2/3-letter ISO region code (e.g.: `en-US`).
	pub language: *const raw::c_char,

	/// Custom string describing dialect and other properties
	pub variant: *const raw::c_char,
}

impl PartialEq for Voice {
	fn eq(&self, other: &Self) -> bool {
		(unsafe { cstr_eq(self.name, other.name) }) &&
		(unsafe { cstr_eq(self.language, other.language) }) &&
		(unsafe { cstr_eq(self.variant, other.variant) })
	}
}


#[repr(C)]
#[derive(Debug, Default, PartialEq, Eq)]
pub struct MsgSettings {
	pub rate: raw::c_int,
	pub pitch: raw::c_int,
	pub pitch_range: raw::c_int,
	pub volume: raw::c_int,
	pub punctuation_mode: Punctuation,
	pub spelling_mode: Spelling,
	pub cap_let_recogn: CapitalLetters,
	pub voice_type: VoiceType,
	pub voice: Voice,
}