speechd_module_rs/

audio.rs

use std::borrow;
use std::ffi;
use std::mem;
use std::os::raw;
use std::ptr;

use crate::context;
use crate::modapi;


#[repr(transparent)]
#[derive(Debug, Default, PartialEq, Eq)]
pub struct Params(modapi::audio::Params);

impl Params {
	/// Set param entry by name returns whether the given `name` was recognized
	/// and hence updated or not
	pub fn set(&mut self, name: &str, value: &[u8]) -> bool {
		let value = mbox::MBox::into_raw(mbox::MArray::from_slice(value).into_mbox());
		unsafe { self.0.set_by_name(name, value as *const raw::c_char) }
	}

	
	/// Look up parameter by name, returns [`None`] if `name` was not recognized
	#[must_use]
	pub fn get(&self, name: &str) -> Option<&[u8]> {
		self.0.get_by_name(name).map(|value| {
			unsafe { ffi::CStr::from_ptr(value) }.to_bytes()
		})
	}

	/// Return an iterator enumerating all valid parameter names
	pub fn keys<'ret>(&self) -> impl Iterator<Item=&'ret str> + use<'ret> {
		modapi::audio::Params::FIELDS.into_iter()
	}

	#[must_use]
	pub fn as_ptr(&self) -> *const modapi::audio::Params {
		&raw const self.0
	}

	#[must_use]
	pub fn into_raw(self) -> modapi::audio::Params {
		// Trick to “destructure” a transparent type without running `drop()`
		//
		// Workaround for beloved E0509, since transmute effectively forgets
		// then writes the new (identical) one in its place.
		let inner: modapi::audio::Params = unsafe { mem::transmute(self) };
		inner
	}
}

impl Drop for Params {
	fn drop(&mut self) {
		for name in self.keys() {
			unsafe { self.0.set_by_name(name, ptr::null()) };
		}
	}
}


#[derive(Debug, Default)]
pub struct Context {
	backends: Vec<String>,
	instance: Option<modapi::audio::ID>,
	params: Params,
}

impl Context {
	/// Create a new [`Context`] instance
	#[must_use]
	pub fn new() -> Self {
		Self::default()
	}

	/// List audio backend plugins requested by the server
	pub fn backends(&self) -> impl Iterator<Item=&str> {
		self.backends.iter().map(AsRef::as_ref)
	}

	/// List audio backend plugins requested by the server (mutable)
	#[must_use]
	pub fn backends_mut(&mut self) -> &mut Vec<String> {
		&mut self.backends
	}

	/// Audio parameters set by the server
	#[must_use]
	pub fn params(&self) -> &Params {
		&self.params
	}

	/// Audio parameters set by the server (mutable)
	#[must_use]
	pub fn params_mut(&mut self) -> &mut Params {
		&mut self.params
	}

	/// Pointer to opaque audio backend instance (if loaded)
	#[must_use]
	pub fn backend_ptr(&self) -> Option<*const modapi::audio::ID> {
		self.instance.as_ref().map(ptr::from_ref)
	}
}


/// Set audio parameter
#[unsafe(no_mangle)]
unsafe extern "C" fn module_audio_set(name: *const raw::c_char, value: *const raw::c_char) -> raw::c_int {
	let name = unsafe { ffi::CStr::from_ptr(name) }.to_string_lossy();
	let value = unsafe { ffi::CStr::from_ptr(value) }.to_bytes();
	
	let result = context::with_module(|module| {
		let audio_ctx = module.audio_ctx();
		if name == "audio_output_method" {
			for backend_name in value.split(|c| *c == b',') {
				audio_ctx.backends_mut().push(String::from_utf8_lossy(backend_name).into_owned());
			}

			true
		} else {
			audio_ctx.params_mut().set(&name, value)
		}
	});

	#[expect(clippy::bool_to_int_with_if, reason="More readable this way")]
	if result { 0 } else { 1 }
}

/// Initialize audio
#[unsafe(no_mangle)]
unsafe extern "C" fn module_audio_init(status_info: *mut *mut raw::c_char) -> raw::c_int {
	log::debug!("Initializing audio output system");

	let mut response = mbox::MString::default();
	let code = context::with_module(|module| {
		let audio_ctx = module.audio_ctx();
		
		if audio_ctx.backends_mut().is_empty() {
			response = mbox::MString::from(
				"No audio backend names received. Perhaps none of the \
				specified output plugins are functional?"
			);
			return 1;
		}

		let mut error_out: *mut raw::c_char = ptr::null_mut();
		let mut first_error: Option<borrow::Cow<'static, str>> = None;
		for backend_name in audio_ctx.backends() {
			if backend_name == "server" {
				first_error.get_or_insert(
					borrow::Cow::Borrowed("Server audio support unavailable")
				);
				continue;
			}

			let backend_name_cstr =
				ffi::CString::new(backend_name)
				.expect("String created from CSting never contains NUL-bytes");
			let audio_id = unsafe { modapi::audio::spd_audio_open(
				backend_name_cstr.as_ptr(),
				audio_ctx.params().as_ptr(),
				&raw mut error_out,
			) };
			if !audio_id.is_null() {
				assert!(error_out.is_null(), "`spd_audio_open` returned both backend handle and error message");

				log::info!("Initialized “{backend_name}” audio backend");

				// Original `module_utils.c` code also does this?
				if unsafe { modapi::audio::spd_audio_set_volume(audio_id, 85) } < 0 {
					log::warn!("Can’t set volume? Is the audio backend ready?");
				}

				response = mbox::MString::from("Audio initialized successfully");
				return 0;
			}

			// Log message and try next backend
			assert!(!error_out.is_null(), "`spd_audio_open` returned neither backend handle nor error message");
			let error_msg = unsafe { ffi::CStr::from_ptr(error_out) }.to_string_lossy();
			log::info!("Failed to initialize audio backend “{backend_name}”: {error_msg}");
			first_error.get_or_insert_with(|| borrow::Cow::Owned(error_msg.into_owned()));

			// Manual clean-up for returned error
			unsafe { libc::free(error_out.cast::<raw::c_void>()) };
			error_out = ptr::null_mut();
		}

		// Tried all backends, no luck
		if let Some(first_error) = first_error {
			response = mbox::MString::from(format!(
				"{0}: {1}", "Opening audio devices failed", first_error
			).as_str());
		} else {
			response = mbox::MString::from("Opening audio devices failed");
		}

		1
	});

	// Write response text
	unsafe { *status_info = mbox::MBox::into_raw(response.into_bytes().into_mbox()).cast::<raw::c_char>() };
	code
}