use rustduck_sys::bridge::ffi;
use crate::buffer::encode_utf16;
use crate::memory::{MemoryInputBinding, MemoryOutputBinding};
use crate::plugin::{PluginOptions, encode_multistring};
use crate::{Error, Result};
use super::{InputSwitcherConfig, SwitcherInput, SwitcherOutput};
pub(super) fn build(
config: &InputSwitcherConfig,
input_bindings: &[MemoryInputBinding],
output_binding: Option<&MemoryOutputBinding>,
) -> Result<ffi::RustDuckInputSwitcherConfig> {
let inputs = input_plugins(config, input_bindings)?;
let output = output_plugin(config, output_binding)?;
let mut values = vec![config.application_name.clone()];
for input in inputs {
values.push("-I".to_owned());
input.append_to(&mut values);
}
if let Some(output) = output {
values.push("-O".to_owned());
output.append_to(&mut values);
}
Ok(ffi::RustDuckInputSwitcherConfig {
fast_switch: config.fast_switch,
delayed_switch: config.delayed_switch,
terminate: config.terminate,
reuse_port: config.reuse_port,
first_input: config.first_input,
primary_input: config.primary_input,
cycle_count: config.cycle_count,
buffered_packets: config.buffered_packets,
max_input_packets: config.max_input_packets,
max_output_packets: config.max_output_packets,
sock_buffer: config.sock_buffer,
remote_server_port: config.remote_server_port,
receive_timeout: config.receive_timeout,
event_udp_port: config.event_udp_port,
event_ttl: config.event_ttl,
plugins: encode_multistring(&values),
event_command: encode_utf16(&config.event_command),
event_udp_address: encode_utf16(&config.event_udp_address),
event_local_address: encode_utf16(&config.event_local_address),
})
}
fn input_plugins(
config: &InputSwitcherConfig,
bindings: &[MemoryInputBinding],
) -> Result<Vec<PluginOptions>> {
let mut bindings = bindings.iter();
config
.inputs
.iter()
.map(|input| match input {
SwitcherInput::Native(plugin) => Ok(plugin.clone()),
SwitcherInput::Memory(_) => bindings
.next()
.map(|binding| memory_plugin(binding.event_code()))
.ok_or(Error::CallbackProtocol {
operation: "InputSwitcher::input_binding",
}),
})
.collect()
}
fn output_plugin(
config: &InputSwitcherConfig,
binding: Option<&MemoryOutputBinding>,
) -> Result<Option<PluginOptions>> {
match (&config.output, binding) {
(Some(SwitcherOutput::Native(plugin)), _) => Ok(Some(plugin.clone())),
(Some(SwitcherOutput::Memory(_)), Some(binding)) => {
Ok(Some(memory_plugin(binding.event_code())))
}
(None, None) => Ok(None),
_ => Err(Error::CallbackProtocol {
operation: "InputSwitcher::output_binding",
}),
}
}
fn memory_plugin(event_code: u32) -> PluginOptions {
PluginOptions::new(
"memory",
["--event-code".to_owned(), event_code.to_string()],
)
}