mod audio;
mod shared;
mod state;
use std::path::{Path, PathBuf};
use std::time::Duration;
use plughost_core::CapabilityReport;
use plughost_core::PluginRef;
use plughost_core::ipc::{Request, Response};
use plughost_core::render::Tail;
use plughost_core::{Event, HostIdentity, ParameterInfo, PluginInfo, PluginState, events_fit};
use crate::errors::Error;
use crate::helper::{Helper, Mode};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Timeouts {
pub load: Duration,
pub control: Duration,
pub process: Duration,
}
impl Default for Timeouts {
fn default() -> Timeouts {
Timeouts {
load: Duration::from_secs(300),
control: Duration::from_secs(60),
process: Duration::from_secs(10),
}
}
}
pub struct Chain {
identity: HostIdentity,
helper_path: PathBuf,
helper: Helper,
plugins: Vec<PluginRef>,
infos: Vec<PluginInfo>,
timeouts: Timeouts,
config: Option<plughost_core::RoutedChainConfig>,
shared: Option<shared::Transport>,
generation: u64,
latency: u32,
tail: Tail,
}
impl std::fmt::Debug for Chain {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Chain")
.field("helper", &self.helper.monitor())
.field("plugins", &self.infos)
.field("config", &self.config)
.field("prepared", &self.shared.is_some())
.field("latency", &self.latency)
.field("tail", &self.tail)
.finish_non_exhaustive()
}
}
impl Chain {
pub fn spawn(
helper: &Path,
plugins: &[PluginRef],
host: &HostIdentity,
timeouts: Timeouts,
) -> Result<Chain, Error> {
host.validate()
.map_err(|error| Error::Input { slot: None, error })?;
if plugins.is_empty() {
return Err(Error::Input {
slot: None,
error: plughost_core::InputError::EmptyChain,
});
}
start(helper, plugins, &[], host, timeouts)
}
pub fn recover(&self, states: &[PluginState]) -> Result<Chain, Error> {
if !states.is_empty() && states.len() != self.plugins.len() {
return Err(Error::Input {
slot: None,
error: plughost_core::InputError::StateCount,
});
}
for (slot, state) in states.iter().enumerate() {
state.validate().map_err(|error| Error::Input {
slot: Some(slot),
error,
})?;
}
let mut chain = start(
&self.helper_path,
&self.plugins,
states,
&self.identity,
self.timeouts,
)?;
if let Some(config) = &self.config {
chain.prepare_audio(config)?;
}
Ok(chain)
}
pub fn plugins(&self) -> &[PluginInfo] {
&self.infos
}
pub fn helper_monitor(&self) -> crate::HelperMonitor {
self.helper.monitor()
}
pub fn take_diagnostics(&mut self) -> Result<plughost_core::DiagnosticBatch, Error> {
match self.request(Request::Diagnostics, self.timeouts.control)? {
Response::Diagnostics(batch) => Ok(batch),
_ => Err(self.protocol_error()),
}
}
pub fn capabilities(&mut self, slot: usize) -> Result<CapabilityReport, Error> {
match self.request(Request::Capabilities { slot }, self.timeouts.control)? {
Response::Capabilities(report) => Ok(report),
_ => Err(self.protocol_error()),
}
}
pub fn take_changes(&mut self) -> Result<plughost_core::ChangeBatch, Error> {
match self.request(Request::Changes, self.timeouts.control)? {
Response::Changes(batch) => Ok(batch),
_ => Err(self.protocol_error()),
}
}
pub fn reprepare(&mut self) -> Result<(), Error> {
let config = self.config.clone().ok_or(Error::NotPrepared)?;
self.prepare_audio(&config).map(|_| ())
}
pub fn latency(&self) -> u32 {
self.latency
}
pub fn tail(&self) -> Tail {
self.tail
}
pub fn parameters(&mut self, slot: usize) -> Result<Vec<(ParameterInfo, f64)>, Error> {
match self.request(Request::Parameters { slot }, self.timeouts.control)? {
Response::Parameters(parameters) => Ok(parameters),
_ => Err(self.protocol_error()),
}
}
pub fn parameter_details(
&mut self,
slot: usize,
id: u64,
) -> Result<plughost_core::ParameterDetails, Error> {
match self.request(
Request::ParameterDetails { slot, id },
self.timeouts.control,
)? {
Response::ParameterDetails(details) => Ok(details),
_ => Err(self.protocol_error()),
}
}
pub fn parameter_choices(
&mut self,
slot: usize,
id: u64,
start: u64,
count: u32,
) -> Result<plughost_core::ParameterChoicePage, Error> {
plughost_core::validate_choice_page(start, count).map_err(|error| Error::Input {
slot: Some(slot),
error,
})?;
match self.request(
Request::ParameterChoices {
slot,
id,
start,
count,
},
self.timeouts.control,
)? {
Response::ParameterChoices(page) => Ok(page),
_ => Err(self.protocol_error()),
}
}
pub fn set_parameter(&mut self, slot: usize, id: u64, value: f64) -> Result<(), Error> {
let request = Request::SetParameter { slot, id, value };
self.request_timing(request).map(|_| ())
}
pub fn parameter_text(&mut self, slot: usize, id: u64, value: f64) -> Result<String, Error> {
match self.request(
Request::ParameterText { slot, id, value },
self.timeouts.control,
)? {
Response::ParameterText(text) => Ok(text),
_ => Err(self.protocol_error()),
}
}
pub fn set_parameter_text(&mut self, slot: usize, id: u64, text: &str) -> Result<(), Error> {
plughost_core::validate_parameter_text(text).map_err(|error| Error::Input {
slot: Some(slot),
error,
})?;
self.request_timing(Request::SetParameterText {
slot,
id,
text: text.to_owned(),
})
.map(|_| ())
}
pub fn parameter_from_text(&mut self, slot: usize, id: u64, text: &str) -> Result<f64, Error> {
plughost_core::validate_parameter_text(text).map_err(|error| Error::Input {
slot: Some(slot),
error,
})?;
match self.request(
Request::ParameterFromText {
slot,
id,
text: text.to_owned(),
},
self.timeouts.control,
)? {
Response::ParameterValue(value) => Ok(value),
_ => Err(self.protocol_error()),
}
}
pub fn parameter_to_plain(&mut self, slot: usize, id: u64, value: f64) -> Result<f64, Error> {
match self.request(
Request::ParameterToPlain { slot, id, value },
self.timeouts.control,
)? {
Response::ParameterValue(value) => Ok(value),
_ => Err(self.protocol_error()),
}
}
pub fn parameter_to_normalized(
&mut self,
slot: usize,
id: u64,
plain: f64,
) -> Result<f64, Error> {
match self.request(
Request::ParameterToNormalized { slot, id, plain },
self.timeouts.control,
)? {
Response::ParameterValue(value) => Ok(value),
_ => Err(self.protocol_error()),
}
}
pub fn reset(&mut self) -> Result<(), Error> {
self.request_timing(Request::Reset).map(|_| ())
}
pub fn open_editor(&mut self, slot: usize) -> Result<(), Error> {
self.request_done(Request::OpenEditor { slot }, self.timeouts.load)
}
pub fn close_editor(&mut self, slot: usize) -> Result<(), Error> {
self.request_done(Request::CloseEditor { slot }, self.timeouts.control)
}
pub fn editor_open(&mut self, slot: usize) -> Result<bool, Error> {
match self.request(Request::EditorOpen { slot }, self.timeouts.control)? {
Response::EditorOpen(open) => Ok(open),
_ => Err(self.protocol_error()),
}
}
fn request(&mut self, request: Request<'_>, timeout: Duration) -> Result<Response, Error> {
let result = self.helper.request(request, timeout);
if matches!(
result,
Err(Error::Protocol | Error::Crashed { .. } | Error::TimedOut { .. })
) {
self.shared = None;
}
result
}
fn request_done(&mut self, request: Request<'_>, timeout: Duration) -> Result<(), Error> {
match self.request(request, timeout)? {
Response::Done => Ok(()),
_ => Err(self.protocol_error()),
}
}
fn read_timing(&mut self) -> Result<bool, Error> {
if !self.is_prepared() {
return Ok(false);
}
self.request_timing(Request::Timing)
}
fn request_timing(&mut self, request: Request<'_>) -> Result<bool, Error> {
match self.request(request, self.timeouts.control)? {
Response::Timing {
latency,
tail,
latency_changed,
} => {
self.latency = latency;
self.tail = tail;
Ok(latency_changed)
}
_ => Err(self.protocol_error()),
}
}
fn is_prepared(&self) -> bool {
self.shared.is_some()
}
}
fn start(
helper: &Path,
plugins: &[PluginRef],
states: &[PluginState],
host: &HostIdentity,
timeouts: Timeouts,
) -> Result<Chain, Error> {
for (slot, plugin) in plugins.iter().enumerate() {
if plugin
.bundle
.as_ref()
.is_some_and(|path| path.to_str().is_none())
{
return Err(Error::Input {
slot: Some(slot),
error: plughost_core::InputError::PathEncoding,
});
}
}
let mut process = Helper::spawn(helper, Mode::Host)?;
let infos = match process.load(host, plugins, timeouts.load)? {
Response::Loaded(infos) if infos.len() == plugins.len() => infos,
_ => return Err(Error::Protocol),
};
for (slot, state) in states.iter().enumerate() {
let request = Request::LoadState {
slot,
state: std::borrow::Cow::Borrowed(state),
};
expect_done(process.request(request, timeouts.load)?)?;
}
Ok(Chain {
identity: host.clone(),
helper_path: helper.to_path_buf(),
helper: process,
plugins: plugins.to_vec(),
infos,
timeouts,
config: None,
shared: None,
generation: 0,
latency: 0,
tail: Tail::Samples(0),
})
}
fn expect_done(response: Response) -> Result<(), Error> {
match response {
Response::Done => Ok(()),
_ => Err(Error::Protocol),
}
}