rustduck-core 1.1.0

Safe typed TSDuck core bindings for rustduck
Documentation
//! Processor configuration, endpoint selection, and pre-native validation.

use std::fmt;
use std::sync::Arc;

use crate::plugin::{PluginChain, PluginOptions};
use crate::{Error, MemoryInput, MemoryOutput, Result};

/// Input selected for a processor.
#[derive(Clone)]
pub enum ProcessorInput {
    /// An ordinary TSDuck input plugin.
    Native(PluginOptions),
    /// A typed bounded `memory` input endpoint.
    Memory(Arc<MemoryInput>),
}

impl fmt::Debug for ProcessorInput {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Native(value) => formatter.debug_tuple("Native").field(value).finish(),
            Self::Memory(_) => formatter.debug_tuple("Memory").finish(),
        }
    }
}

/// Output selected for a processor.
#[derive(Clone)]
pub enum ProcessorOutput {
    /// An ordinary TSDuck output plugin.
    Native(PluginOptions),
    /// A typed bounded `memory` output endpoint.
    Memory(Arc<MemoryOutput>),
}

impl fmt::Debug for ProcessorOutput {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Native(value) => formatter.debug_tuple("Native").field(value).finish(),
            Self::Memory(_) => formatter.debug_tuple("Memory").finish(),
        }
    }
}

/// Typed configuration for one `TSProcessor` start.
#[derive(Debug, Clone)]
pub struct ProcessorConfig {
    /// Ignore joint-termination plugin options.
    pub ignore_joint_termination: bool,
    /// Global packet-buffer size in bytes.
    pub buffer_size: i64,
    /// Maximum processed packets before flushing; zero selects TSDuck's default.
    pub max_flushed_packets: i64,
    /// Maximum packets per input operation; zero selects TSDuck's default.
    pub max_input_packets: i64,
    /// Maximum packets per output operation; zero is unlimited.
    pub max_output_packets: i64,
    /// Packets read before processing begins; zero selects TSDuck's default.
    pub initial_input_packets: i64,
    /// Input stuffing pair: null packets and interval.
    pub add_input_stuffing: [i64; 2],
    /// Null packets before the input stream.
    pub add_start_stuffing: i64,
    /// Null packets after the input stream.
    pub add_stop_stuffing: i64,
    /// Fixed input bitrate; zero leaves it unspecified.
    pub bitrate: i64,
    /// Bitrate adjustment interval in milliseconds.
    pub bitrate_adjust_interval: i64,
    /// Input receive timeout in milliseconds; zero selects TSDuck's default.
    pub receive_timeout: i64,
    /// Include plugin indices in log messages.
    pub log_plugin_index: bool,
    /// Application name passed to TSDuck's plugin parser.
    pub application_name: String,
    /// Optional typed input.
    pub input: Option<ProcessorInput>,
    /// Ordered processor plugins.
    pub plugins: PluginChain,
    /// Optional typed output.
    pub output: Option<ProcessorOutput>,
}

impl Default for ProcessorConfig {
    fn default() -> Self {
        Self {
            ignore_joint_termination: false,
            buffer_size: 16 * 1024 * 1024,
            max_flushed_packets: 0,
            max_input_packets: 0,
            max_output_packets: 0,
            initial_input_packets: 0,
            add_input_stuffing: [0, 0],
            add_start_stuffing: 0,
            add_stop_stuffing: 0,
            bitrate: 0,
            bitrate_adjust_interval: 5_000,
            receive_timeout: 0,
            log_plugin_index: false,
            application_name: String::new(),
            input: None,
            plugins: PluginChain::default(),
            output: None,
        }
    }
}

pub(crate) fn validate(config: &ProcessorConfig) -> Result<()> {
    for value in [
        config.buffer_size,
        config.max_flushed_packets,
        config.max_input_packets,
        config.max_output_packets,
        config.initial_input_packets,
        config.add_input_stuffing[0],
        config.add_input_stuffing[1],
        config.add_start_stuffing,
        config.add_stop_stuffing,
        config.bitrate,
        config.bitrate_adjust_interval,
        config.receive_timeout,
    ] {
        if !fits_native_long(value) {
            return Err(Error::InvalidArgument {
                field: "processor option",
                message: "does not fit the native long type".to_owned(),
            });
        }
    }
    if let Some(ProcessorInput::Native(plugin)) = &config.input {
        plugin.validate_not_memory("input")?;
    }
    if let Some(ProcessorOutput::Native(plugin)) = &config.output {
        plugin.validate_not_memory("output")?;
    }
    for plugin in config.plugins.iter() {
        plugin.validate_not_memory("plugins")?;
    }
    Ok(())
}

pub(crate) fn memory_input(config: &ProcessorConfig) -> Option<Arc<MemoryInput>> {
    match &config.input {
        Some(ProcessorInput::Memory(endpoint)) => Some(Arc::clone(endpoint)),
        _ => None,
    }
}

pub(crate) fn memory_output(config: &ProcessorConfig) -> Option<Arc<MemoryOutput>> {
    match &config.output {
        Some(ProcessorOutput::Memory(endpoint)) => Some(Arc::clone(endpoint)),
        _ => None,
    }
}

fn fits_native_long(value: i64) -> bool {
    size_of::<std::ffi::c_long>() != size_of::<i32>()
        || (i64::from(i32::MIN)..=i64::from(i32::MAX)).contains(&value)
}