use std::panic::{AssertUnwindSafe, catch_unwind};
use std::sync::OnceLock;
pub type MemoryCallbackDispatcher =
fn(u32, &[u8], &[u8], usize, bool, u8) -> ffi::RustDuckMemoryCallbackResult;
pub type MemoryCallbackErrorReporter = fn(u32);
pub type ReportCallbackDispatcher = fn(i32, &[u8], bool);
static MEMORY_CALLBACK_DISPATCHER: OnceLock<MemoryCallbackDispatcher> = OnceLock::new();
static MEMORY_CALLBACK_ERROR_REPORTER: OnceLock<MemoryCallbackErrorReporter> = OnceLock::new();
static REPORT_CALLBACK_DISPATCHER: OnceLock<ReportCallbackDispatcher> = OnceLock::new();
pub fn install_memory_callback_dispatcher(
dispatcher: MemoryCallbackDispatcher,
error_reporter: MemoryCallbackErrorReporter,
) -> bool {
let dispatcher_matches = match MEMORY_CALLBACK_DISPATCHER.set(dispatcher) {
Ok(()) => true,
Err(existing) => std::ptr::fn_addr_eq(existing, dispatcher),
};
let reporter_matches = match MEMORY_CALLBACK_ERROR_REPORTER.set(error_reporter) {
Ok(()) => true,
Err(existing) => std::ptr::fn_addr_eq(existing, error_reporter),
};
dispatcher_matches && reporter_matches
}
pub fn install_report_callback_dispatcher(dispatcher: ReportCallbackDispatcher) -> bool {
match REPORT_CALLBACK_DISPATCHER.set(dispatcher) {
Ok(()) => true,
Err(existing) => std::ptr::fn_addr_eq(existing, dispatcher),
}
}
fn rustduck_memory_callback_writeback_failure(event_code: u32) {
let Some(reporter) = MEMORY_CALLBACK_ERROR_REPORTER.get() else {
return;
};
let _ = catch_unwind(AssertUnwindSafe(|| reporter(event_code)));
}
fn rustduck_memory_callback(
event_code: u32,
plugin_name: &[u8],
data: &[u8],
data_max_size: usize,
data_read_only: bool,
validity: u8,
) -> ffi::RustDuckMemoryCallbackResult {
let Some(dispatcher) = MEMORY_CALLBACK_DISPATCHER.get() else {
return ffi::RustDuckMemoryCallbackResult {
ok: false,
data: Vec::new(),
};
};
catch_unwind(AssertUnwindSafe(|| {
dispatcher(
event_code,
plugin_name,
data,
data_max_size,
data_read_only,
validity,
)
}))
.unwrap_or(ffi::RustDuckMemoryCallbackResult {
ok: false,
data: Vec::new(),
})
}
fn rustduck_report_forward_callback(severity: i32, message: &[u8], message_valid: bool) {
let Some(dispatcher) = REPORT_CALLBACK_DISPATCHER.get() else {
return;
};
let _ = catch_unwind(AssertUnwindSafe(|| {
dispatcher(severity, message, message_valid);
}));
}
#[cxx::bridge]
pub mod ffi {
struct RustDuckProcessorConfig {
ignore_joint_termination: i64,
buffer_size: i64,
max_flushed_packets: i64,
max_input_packets: i64,
max_output_packets: i64,
initial_input_packets: i64,
add_input_stuffing_0: i64,
add_input_stuffing_1: i64,
add_start_stuffing: i64,
add_stop_stuffing: i64,
bitrate: i64,
bitrate_adjust_interval: i64,
receive_timeout: i64,
log_plugin_index: bool,
plugins: Vec<u8>,
}
struct RustDuckInputSwitcherConfig {
fast_switch: bool,
delayed_switch: bool,
terminate: bool,
reuse_port: bool,
first_input: i64,
primary_input: i64,
cycle_count: i64,
buffered_packets: i64,
max_input_packets: i64,
max_output_packets: i64,
sock_buffer: i64,
remote_server_port: i64,
receive_timeout: i64,
event_udp_port: i64,
event_ttl: i64,
plugins: Vec<u8>,
event_command: Vec<u8>,
event_udp_address: Vec<u8>,
event_local_address: Vec<u8>,
}
struct RustDuckMemoryCallbackResult {
ok: bool,
data: Vec<u8>,
}
struct RustDuckAnalyzerSummary {
packet_count: u64,
ts_bitrate: f64,
ts_pcr_bitrate_188: f64,
invalid_sync_count: u64,
transport_error_count: u64,
pcr_pid_count: u64,
}
struct RustDuckAnalyzerCaDescriptor {
cas_id: u16,
ca_pid: u16,
program_level: bool,
has_elementary_pid: bool,
elementary_pid: u16,
}
struct RustDuckAnalyzerService {
service_id: u16,
name: String,
provider: String,
pid_count: u64,
pmt_pid: u16,
pcr_pid: u16,
bitrate: f64,
packet_count: u64,
scrambled_pid_count: u64,
ca_descriptors: Vec<RustDuckAnalyzerCaDescriptor>,
}
struct RustDuckAnalyzerPid {
pid: u16,
services: Vec<u16>,
carries_video: bool,
carries_audio: bool,
scrambled: bool,
description: String,
packet_count: u64,
scrambled_packet_count: u64,
invalid_pes_count: u64,
invalid_pes_start_count: u64,
bitrate: f64,
ts_pcr_bitrate: f64,
current_continuity: u8,
unexpected_discontinuity_count: u64,
duplicated_packet_count: u64,
invalid_scrambling_control_count: u64,
cas_id: u16,
cas_operators: Vec<u32>,
current_scrambling_control: u8,
}
struct RustDuckAnalyzerReport {
summary: RustDuckAnalyzerSummary,
services: Vec<RustDuckAnalyzerService>,
pids: Vec<RustDuckAnalyzerPid>,
}
extern "Rust" {
fn rustduck_memory_callback_writeback_failure(event_code: u32);
fn rustduck_memory_callback(
event_code: u32,
plugin_name: &[u8],
data: &[u8],
data_max_size: usize,
data_read_only: bool,
validity: u8,
) -> RustDuckMemoryCallbackResult;
fn rustduck_report_forward_callback(severity: i32, message: &[u8], message_valid: bool);
}
unsafe extern "C++" {
include!("rustduck-sys/native/exception_boundary.h");
include!("rustduck-sys/native/bridge/report.h");
include!("rustduck-sys/native/bridge/context.h");
include!("rustduck-sys/native/bridge/section_file.h");
include!("rustduck-sys/native/bridge/memory_handler.h");
include!("rustduck-sys/native/bridge/processor.h");
include!("rustduck-sys/native/bridge/analyzer.h");
include!("rustduck-sys/native/bridge/input_switcher.h");
include!("rustduck-sys/native/bridge/system_monitor.h");
include!("rustduck-sys/native/bridge/test_hooks.h");
type RustDuckReport;
type RustDuckDuckContext;
type RustDuckSectionFile;
type RustDuckMemoryHandler;
type RustDuckTSProcessor;
type RustDuckProcessorAbortToken;
type RustDuckTSAnalyzer;
type RustDuckInputSwitcher;
type RustDuckSystemMonitor;
fn rustduck_memory_handler_new() -> Result<UniquePtr<RustDuckMemoryHandler>>;
fn rustduck_processor_new(
report: &RustDuckReport,
) -> Result<UniquePtr<RustDuckTSProcessor>>;
fn rustduck_processor_register_input(
processor: Pin<&mut RustDuckTSProcessor>,
handler: &RustDuckMemoryHandler,
) -> Result<()>;
fn rustduck_processor_register_output(
processor: Pin<&mut RustDuckTSProcessor>,
handler: &RustDuckMemoryHandler,
) -> Result<()>;
fn rustduck_processor_start(
processor: Pin<&mut RustDuckTSProcessor>,
config: &RustDuckProcessorConfig,
) -> Result<bool>;
fn rustduck_processor_abort(processor: Pin<&mut RustDuckTSProcessor>) -> Result<()>;
fn rustduck_processor_wait(processor: Pin<&mut RustDuckTSProcessor>) -> Result<()>;
fn rustduck_processor_is_started(processor: &RustDuckTSProcessor) -> Result<bool>;
fn rustduck_processor_abort_token(
processor: &RustDuckTSProcessor,
) -> SharedPtr<RustDuckProcessorAbortToken>;
fn rustduck_processor_abort_token_request(
token: &RustDuckProcessorAbortToken,
) -> Result<()>;
fn rustduck_analyzer_new(
context: &RustDuckDuckContext,
) -> Result<UniquePtr<RustDuckTSAnalyzer>>;
fn rustduck_analyzer_feed(
analyzer: Pin<&mut RustDuckTSAnalyzer>,
packets: &[u8],
) -> Result<()>;
fn rustduck_analyzer_set_bitrate_hint(
analyzer: Pin<&mut RustDuckTSAnalyzer>,
bitrate: f64,
confidence: u8,
) -> Result<()>;
fn rustduck_analyzer_snapshot(
analyzer: Pin<&mut RustDuckTSAnalyzer>,
) -> Result<RustDuckAnalyzerReport>;
fn rustduck_analyzer_reset(analyzer: Pin<&mut RustDuckTSAnalyzer>) -> Result<()>;
fn rustduck_input_switcher_new(
report: &RustDuckReport,
) -> Result<UniquePtr<RustDuckInputSwitcher>>;
fn rustduck_input_switcher_register_input(
switcher: Pin<&mut RustDuckInputSwitcher>,
handler: &RustDuckMemoryHandler,
) -> Result<()>;
fn rustduck_input_switcher_register_output(
switcher: Pin<&mut RustDuckInputSwitcher>,
handler: &RustDuckMemoryHandler,
) -> Result<()>;
fn rustduck_input_switcher_start(
switcher: Pin<&mut RustDuckInputSwitcher>,
config: &RustDuckInputSwitcherConfig,
) -> Result<bool>;
fn rustduck_input_switcher_stop(switcher: Pin<&mut RustDuckInputSwitcher>) -> Result<()>;
fn rustduck_input_switcher_wait(switcher: Pin<&mut RustDuckInputSwitcher>) -> Result<()>;
fn rustduck_system_monitor_new(
report: &RustDuckReport,
config: &[u8],
) -> Result<UniquePtr<RustDuckSystemMonitor>>;
fn rustduck_system_monitor_start(monitor: Pin<&mut RustDuckSystemMonitor>) -> Result<()>;
fn rustduck_system_monitor_stop(monitor: Pin<&mut RustDuckSystemMonitor>) -> Result<()>;
fn rustduck_system_monitor_wait(monitor: Pin<&mut RustDuckSystemMonitor>) -> Result<()>;
fn rustduck_report_null() -> Result<UniquePtr<RustDuckReport>>;
fn rustduck_report_stderr() -> Result<UniquePtr<RustDuckReport>>;
fn rustduck_report_asynchronous(
severity: i32,
synchronous_log: bool,
timed_log: bool,
log_message_count: usize,
) -> Result<UniquePtr<RustDuckReport>>;
fn rustduck_report_asynchronous_with_forwarder(
severity: i32,
synchronous_log: bool,
log_message_count: usize,
) -> Result<UniquePtr<RustDuckReport>>;
fn rustduck_report_set_max_severity(
report: Pin<&mut RustDuckReport>,
severity: i32,
) -> Result<()>;
fn rustduck_report_log(
report: &RustDuckReport,
severity: i32,
message: &[u8],
) -> Result<()>;
fn rustduck_report_terminate(report: Pin<&mut RustDuckReport>) -> Result<()>;
fn rustduck_context_new(report: &RustDuckReport) -> Result<UniquePtr<RustDuckDuckContext>>;
fn rustduck_context_set_default_charset(
context: Pin<&mut RustDuckDuckContext>,
charset: &[u8],
) -> Result<bool>;
fn rustduck_context_set_default_cas_id(
context: Pin<&mut RustDuckDuckContext>,
cas_id: u16,
) -> Result<()>;
fn rustduck_context_set_default_pds(
context: Pin<&mut RustDuckDuckContext>,
pds: u32,
) -> Result<()>;
fn rustduck_context_add_standards(
context: Pin<&mut RustDuckDuckContext>,
standards: u32,
) -> Result<()>;
fn rustduck_context_standards(context: &RustDuckDuckContext) -> Result<u32>;
fn rustduck_context_reset_standards(
context: Pin<&mut RustDuckDuckContext>,
standards: u32,
) -> Result<()>;
fn rustduck_context_set_time_reference_offset(
context: Pin<&mut RustDuckDuckContext>,
offset_millis: i64,
) -> Result<()>;
fn rustduck_context_set_time_reference(
context: Pin<&mut RustDuckDuckContext>,
name: &[u8],
) -> Result<bool>;
fn rustduck_section_file_new(
context: &RustDuckDuckContext,
) -> Result<UniquePtr<RustDuckSectionFile>>;
fn rustduck_section_file_clear(section_file: Pin<&mut RustDuckSectionFile>) -> Result<()>;
fn rustduck_section_file_binary_size(section_file: &RustDuckSectionFile) -> Result<usize>;
fn rustduck_section_file_sections_count(
section_file: &RustDuckSectionFile,
) -> Result<usize>;
fn rustduck_section_file_tables_count(section_file: &RustDuckSectionFile) -> Result<usize>;
fn rustduck_section_file_set_crc_validation(
section_file: Pin<&mut RustDuckSectionFile>,
mode: i32,
) -> Result<()>;
fn rustduck_section_file_load_binary_buffer(
section_file: Pin<&mut RustDuckSectionFile>,
data: &[u8],
) -> Result<bool>;
fn rustduck_section_file_to_binary(section_file: &RustDuckSectionFile) -> Result<Vec<u8>>;
fn rustduck_section_file_load_binary(
section_file: Pin<&mut RustDuckSectionFile>,
path: &[u8],
) -> Result<bool>;
fn rustduck_section_file_save_binary(
section_file: &RustDuckSectionFile,
path: &[u8],
) -> Result<bool>;
fn rustduck_section_file_load_xml(
section_file: Pin<&mut RustDuckSectionFile>,
source: &[u8],
) -> Result<bool>;
fn rustduck_section_file_save_xml(
section_file: &RustDuckSectionFile,
path: &[u8],
) -> Result<bool>;
fn rustduck_section_file_save_json(
section_file: &RustDuckSectionFile,
path: &[u8],
) -> Result<bool>;
fn rustduck_section_file_to_xml_utf16(
section_file: &RustDuckSectionFile,
) -> Result<Vec<u8>>;
fn rustduck_section_file_to_json_utf16(
section_file: &RustDuckSectionFile,
) -> Result<Vec<u8>>;
#[cfg(feature = "native_test_hooks")]
#[doc(hidden)]
fn rustduck_test_set_failure(point: i32, trigger_after: i32, unknown: bool) -> Result<()>;
#[cfg(feature = "native_test_hooks")]
#[doc(hidden)]
fn rustduck_test_clear_failure() -> Result<()>;
#[cfg(feature = "native_test_hooks")]
#[doc(hidden)]
fn rustduck_test_throw_standard() -> Result<()>;
#[cfg(feature = "native_test_hooks")]
#[doc(hidden)]
fn rustduck_test_throw_unknown() -> Result<()>;
}
}