use rustduck_sys::bridge::ffi;
use crate::memory::{MemoryInputBinding, MemoryOutputBinding};
use crate::plugin::{PluginOptions, processor_plugins};
use crate::{Error, Result};
use super::{ProcessorConfig, ProcessorInput, ProcessorOutput};
pub(super) fn build(
config: &ProcessorConfig,
input_binding: Option<&MemoryInputBinding>,
output_binding: Option<&MemoryOutputBinding>,
) -> Result<ffi::RustDuckProcessorConfig> {
let input = input_plugin(config, input_binding)?;
let output = output_plugin(config, output_binding)?;
Ok(ffi::RustDuckProcessorConfig {
ignore_joint_termination: i64::from(config.ignore_joint_termination),
buffer_size: config.buffer_size,
max_flushed_packets: config.max_flushed_packets,
max_input_packets: config.max_input_packets,
max_output_packets: config.max_output_packets,
initial_input_packets: config.initial_input_packets,
add_input_stuffing_0: config.add_input_stuffing[0],
add_input_stuffing_1: config.add_input_stuffing[1],
add_start_stuffing: config.add_start_stuffing,
add_stop_stuffing: config.add_stop_stuffing,
bitrate: config.bitrate,
bitrate_adjust_interval: config.bitrate_adjust_interval,
receive_timeout: config.receive_timeout,
log_plugin_index: config.log_plugin_index,
plugins: processor_plugins(
&config.application_name,
input.as_ref(),
&config.plugins,
output.as_ref(),
),
})
}
fn input_plugin(
config: &ProcessorConfig,
binding: Option<&MemoryInputBinding>,
) -> Result<Option<PluginOptions>> {
match (&config.input, binding) {
(Some(ProcessorInput::Native(plugin)), _) => Ok(Some(plugin.clone())),
(Some(ProcessorInput::Memory(_)), Some(binding)) => {
Ok(Some(memory_plugin(binding.event_code())))
}
(None, None) => Ok(None),
_ => Err(Error::CallbackProtocol {
operation: "TSProcessor::input_binding",
}),
}
}
fn output_plugin(
config: &ProcessorConfig,
binding: Option<&MemoryOutputBinding>,
) -> Result<Option<PluginOptions>> {
match (&config.output, binding) {
(Some(ProcessorOutput::Native(plugin)), _) => Ok(Some(plugin.clone())),
(Some(ProcessorOutput::Memory(_)), Some(binding)) => {
Ok(Some(memory_plugin(binding.event_code())))
}
(None, None) => Ok(None),
_ => Err(Error::CallbackProtocol {
operation: "TSProcessor::output_binding",
}),
}
}
fn memory_plugin(event_code: u32) -> PluginOptions {
PluginOptions::new(
"memory",
["--event-code".to_owned(), event_code.to_string()],
)
}