mod audio;
mod realtime;
mod recovery;
mod shared;
mod state;
use std::path::{Path, PathBuf};
use std::time::Duration;
use plughost_core::internal::{events_fit, validate_choice_page, validate_parameter_text};
use plughost_core::ipc::{Request, Response};
use plughost_core::render::Tail;
use plughost_core::{
CapabilityReport, Events, HostIdentity, ParameterInfo, PluginInfo, PluginRef, PluginState,
};
use crate::errors::Error;
use crate::helper::{Helper, Mode};
pub use recovery::ChainSnapshot;
#[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),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct ChainSlot {
pub plugin: PluginRef,
pub state: Option<PluginState>,
pub bypass: Option<bool>,
}
impl ChainSlot {
#[must_use]
pub fn new(plugin: PluginRef) -> ChainSlot {
ChainSlot {
plugin,
state: None,
bypass: None,
}
}
#[must_use]
pub fn with_state(mut self, state: PluginState) -> ChainSlot {
self.state = Some(state);
self
}
#[must_use]
pub fn with_bypass(mut self, enabled: bool) -> ChainSlot {
self.bypass = Some(enabled);
self
}
}
impl From<PluginRef> for ChainSlot {
fn from(plugin: PluginRef) -> ChainSlot {
ChainSlot::new(plugin)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct SpawnOptions {
pub host: HostIdentity,
pub timeouts: Timeouts,
}
impl SpawnOptions {
#[must_use]
pub fn new(host: HostIdentity, timeouts: Timeouts) -> SpawnOptions {
SpawnOptions { host, timeouts }
}
}
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,
realtime: Option<realtime::Realtime>,
}
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,
slots: &[ChainSlot],
options: &SpawnOptions,
) -> Result<Chain, Error> {
options
.host
.validate()
.map_err(|error| Error::Input { slot: None, error })?;
start(helper, slots, &options.host, options.timeouts)
}
pub fn recover(&self, slots: &[ChainSlot]) -> Result<Chain, Error> {
let mut chain = start(&self.helper_path, slots, &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 references(&self) -> &[PluginRef] {
&self.plugins
}
pub fn helper_monitor(&self) -> crate::HelperMonitor {
self.helper.monitor()
}
pub fn canceller(&self) -> crate::ChainCanceller {
self.helper.canceller()
}
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, Option<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> {
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> {
self.request_edit(Request::SetParameter { slot, id, value })
}
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> {
validate_parameter_text(text).map_err(|error| Error::Input {
slot: Some(slot),
error,
})?;
self.request_edit(Request::SetParameterText {
slot,
id,
text: text.to_owned(),
})
}
pub fn parameter_from_text(&mut self, slot: usize, id: u64, text: &str) -> Result<f64, Error> {
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.refuse_while_realtime()?;
self.request_refreshed(Request::Reset)
}
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 { .. }
| Error::Cancelled { .. })
) {
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_edit(&mut self, request: Request<'_>) -> Result<(), Error> {
if self.realtime_running() {
return self.request_done(request, self.timeouts.control);
}
self.request_refreshed(request)
}
fn request_refreshed(&mut self, request: Request<'_>) -> Result<(), Error> {
match self.request(request, self.timeouts.control)? {
Response::Timing { latency, tail, .. } => {
self.latency = latency;
self.tail = tail;
Ok(())
}
Response::Done => Ok(()),
_ => Err(self.protocol_error()),
}
}
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,
slots: &[ChainSlot],
host: &HostIdentity,
timeouts: Timeouts,
) -> Result<Chain, Error> {
if slots.is_empty() {
return Err(Error::Input {
slot: None,
error: plughost_core::InputError::EmptyChain,
});
}
for (slot, spec) in slots.iter().enumerate() {
if spec
.plugin
.bundle()
.is_some_and(|path| path.to_str().is_none())
{
return Err(Error::Input {
slot: Some(slot),
error: plughost_core::InputError::PathEncoding,
});
}
if let Some(state) = &spec.state {
state.validate().map_err(|error| Error::Input {
slot: Some(slot),
error,
})?;
}
}
let plugins: Vec<PluginRef> = slots.iter().map(|spec| spec.plugin.clone()).collect();
let plugins = plugins.as_slice();
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, spec) in slots.iter().enumerate() {
if let Some(state) = &spec.state {
let request = Request::LoadState {
slot,
state: std::borrow::Cow::Borrowed(state),
};
expect_done(process.request(request, timeouts.load)?)?;
}
}
let mut chain = 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),
realtime: None,
};
for (slot, spec) in slots.iter().enumerate() {
if let Some(enabled) = spec.bypass {
chain.set_bypass(slot, enabled)?;
}
}
Ok(chain)
}
fn expect_done(response: Response) -> Result<(), Error> {
match response {
Response::Done => Ok(()),
_ => Err(Error::Protocol),
}
}