rustduck-core 1.1.0

Safe typed TSDuck core bindings for rustduck
Documentation
//! Conversion from typed switcher configuration to bridge-only native values.

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()],
    )
}