use std::rc::Rc;
use rustduck_sys::bridge::ffi;
use crate::error::native_exception;
use crate::{DuckContext, Error, Result, TS_PACKET_SIZE};
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)]
#[non_exhaustive]
pub enum BitRateConfidence {
#[default]
Low = 0,
PcrContinuous = 1,
PcrAverage = 2,
Clock = 3,
Hardware = 4,
Override = 5,
}
impl BitRateConfidence {
const fn abi_value(self) -> u8 {
self as u8
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct TSAnalyzerSummary {
pub packet_count: u64,
pub ts_bitrate: f64,
pub ts_pcr_bitrate_188: f64,
pub invalid_sync_count: u64,
pub transport_error_count: u64,
pub pcr_pid_count: u64,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TSAnalyzerCaDescriptor {
pub cas_id: u16,
pub ca_pid: u16,
pub program_level: bool,
pub elementary_pid: Option<u16>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct TSAnalyzerService {
pub service_id: u16,
pub name: String,
pub provider: String,
pub pid_count: u64,
pub pmt_pid: u16,
pub pcr_pid: u16,
pub bitrate: f64,
pub packet_count: u64,
pub scrambled_pid_count: u64,
pub ca_descriptors: Vec<TSAnalyzerCaDescriptor>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct TSAnalyzerPid {
pub pid: u16,
pub services: Vec<u16>,
pub carries_video: bool,
pub carries_audio: bool,
pub scrambled: bool,
pub description: String,
pub packet_count: u64,
pub scrambled_packet_count: u64,
pub invalid_pes_count: u64,
pub invalid_pes_start_count: u64,
pub bitrate: f64,
pub ts_pcr_bitrate: f64,
pub current_continuity: u8,
pub unexpected_discontinuity_count: u64,
pub duplicated_packet_count: u64,
pub invalid_scrambling_control_count: u64,
pub cas_id: u16,
pub cas_operators: Vec<u32>,
pub current_scrambling_control: u8,
}
#[derive(Debug, Clone, PartialEq)]
pub struct TSAnalyzerReport {
pub summary: TSAnalyzerSummary,
pub services: Vec<TSAnalyzerService>,
pub pids: Vec<TSAnalyzerPid>,
}
pub struct TSAnalyzer {
native: cxx::UniquePtr<ffi::RustDuckTSAnalyzer>,
context: Rc<DuckContext>,
reset_failed: bool,
}
impl TSAnalyzer {
pub fn new(context: Rc<DuckContext>) -> Result<Self> {
let native = ffi::rustduck_analyzer_new(context.native())
.map_err(|error| native_exception("TSAnalyzer::new", error))?;
if native.is_null() {
return Err(Error::NativeFailure {
operation: "TSAnalyzer::new",
});
}
Ok(Self {
native,
context,
reset_failed: false,
})
}
pub fn context(&self) -> &Rc<DuckContext> {
&self.context
}
pub fn set_bitrate_hint(&mut self, bitrate: f64, confidence: BitRateConfidence) -> Result<()> {
self.require_usable("set_bitrate_hint")?;
if !bitrate.is_finite() || bitrate < 0.0 {
return Err(Error::InvalidArgument {
field: "bitrate",
message: "must be a finite, non-negative bits-per-second value".to_owned(),
});
}
ffi::rustduck_analyzer_set_bitrate_hint(
self.native.pin_mut(),
bitrate,
confidence.abi_value(),
)
.map_err(|error| native_exception("TSAnalyzer::set_bitrate_hint", error))
}
pub fn feed(&mut self, packets: &[u8]) -> Result<()> {
self.require_usable("feed")?;
if packets.len() % TS_PACKET_SIZE != 0 {
return Err(Error::InvalidArgument {
field: "packets",
message: format!(
"size must be a multiple of {TS_PACKET_SIZE} bytes, got {}",
packets.len()
),
});
}
if let Err(error) = ffi::rustduck_analyzer_feed(self.native.pin_mut(), packets) {
let feed_error = native_exception("TSAnalyzer::feed", error);
if let Err(error) = ffi::rustduck_analyzer_reset(self.native.pin_mut()) {
self.reset_failed = true;
return Err(native_exception("TSAnalyzer::feed_reset", error));
}
return Err(feed_error);
}
Ok(())
}
pub fn snapshot(&mut self) -> Result<TSAnalyzerReport> {
self.require_usable("snapshot")?;
ffi::rustduck_analyzer_snapshot(self.native.pin_mut())
.map(copy_report)
.map_err(|error| native_exception("TSAnalyzer::snapshot", error))
}
pub fn reset(&mut self) -> Result<()> {
self.require_usable("reset")?;
if let Err(error) = ffi::rustduck_analyzer_reset(self.native.pin_mut()) {
self.reset_failed = true;
return Err(native_exception("TSAnalyzer::reset", error));
}
Ok(())
}
fn require_usable(&self, operation: &'static str) -> Result<()> {
if self.reset_failed {
Err(Error::InvalidState {
object: "TSAnalyzer",
operation,
state: "failed",
})
} else {
Ok(())
}
}
}
fn copy_report(value: ffi::RustDuckAnalyzerReport) -> TSAnalyzerReport {
TSAnalyzerReport {
summary: copy_summary(value.summary),
services: value.services.into_iter().map(copy_service).collect(),
pids: value.pids.into_iter().map(copy_pid).collect(),
}
}
fn copy_summary(value: ffi::RustDuckAnalyzerSummary) -> TSAnalyzerSummary {
TSAnalyzerSummary {
packet_count: value.packet_count,
ts_bitrate: value.ts_bitrate,
ts_pcr_bitrate_188: value.ts_pcr_bitrate_188,
invalid_sync_count: value.invalid_sync_count,
transport_error_count: value.transport_error_count,
pcr_pid_count: value.pcr_pid_count,
}
}
fn copy_service(value: ffi::RustDuckAnalyzerService) -> TSAnalyzerService {
TSAnalyzerService {
service_id: value.service_id,
name: value.name,
provider: value.provider,
pid_count: value.pid_count,
pmt_pid: value.pmt_pid,
pcr_pid: value.pcr_pid,
bitrate: value.bitrate,
packet_count: value.packet_count,
scrambled_pid_count: value.scrambled_pid_count,
ca_descriptors: value
.ca_descriptors
.into_iter()
.map(copy_ca_descriptor)
.collect(),
}
}
fn copy_ca_descriptor(value: ffi::RustDuckAnalyzerCaDescriptor) -> TSAnalyzerCaDescriptor {
TSAnalyzerCaDescriptor {
cas_id: value.cas_id,
ca_pid: value.ca_pid,
program_level: value.program_level,
elementary_pid: value.has_elementary_pid.then_some(value.elementary_pid),
}
}
fn copy_pid(value: ffi::RustDuckAnalyzerPid) -> TSAnalyzerPid {
TSAnalyzerPid {
pid: value.pid,
services: value.services,
carries_video: value.carries_video,
carries_audio: value.carries_audio,
scrambled: value.scrambled,
description: value.description,
packet_count: value.packet_count,
scrambled_packet_count: value.scrambled_packet_count,
invalid_pes_count: value.invalid_pes_count,
invalid_pes_start_count: value.invalid_pes_start_count,
bitrate: value.bitrate,
ts_pcr_bitrate: value.ts_pcr_bitrate,
current_continuity: value.current_continuity,
unexpected_discontinuity_count: value.unexpected_discontinuity_count,
duplicated_packet_count: value.duplicated_packet_count,
invalid_scrambling_control_count: value.invalid_scrambling_control_count,
cas_id: value.cas_id,
cas_operators: value.cas_operators,
current_scrambling_control: value.current_scrambling_control,
}
}