rustduck-core 1.1.0

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

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