use sightloom_core::{FrameStamp, MediaTime, SourceId};
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum DropPolicy {
#[default]
RejectNew,
DropOldest,
DropNewest,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum LateFramePolicy {
#[default]
Reject,
AcceptMark,
Drop,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum OutOfOrderPolicy {
#[default]
Reject,
Accept,
Drop,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct IngestPolicy {
pub max_queue_depth: usize,
pub drop_policy: DropPolicy,
pub late_frame_policy: LateFramePolicy,
pub out_of_order_policy: OutOfOrderPolicy,
pub max_lateness_ns: i64,
}
impl Default for IngestPolicy {
fn default() -> Self {
Self {
max_queue_depth: 64,
drop_policy: DropPolicy::RejectNew,
late_frame_policy: LateFramePolicy::Reject,
out_of_order_policy: OutOfOrderPolicy::Reject,
max_lateness_ns: 0,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SourceWatermark {
pub source_id: SourceId,
pub high_pts: Option<MediaTime>,
pub high_frame_index: u64,
pub sequence: u64,
}
impl SourceWatermark {
#[must_use]
pub const fn new(source_id: SourceId) -> Self {
Self {
source_id,
high_pts: None,
high_frame_index: 0,
sequence: 0,
}
}
pub fn advance(&mut self, stamp: FrameStamp) {
self.high_pts = Some(stamp.pts);
self.high_frame_index = self.high_frame_index.max(stamp.frame_index);
self.sequence = self.sequence.saturating_add(1);
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum IngestDecision {
Accept,
Drop,
RejectLate,
RejectOutOfOrder,
}
#[must_use]
pub fn evaluate_stamp(
policy: &IngestPolicy,
watermark: &SourceWatermark,
stamp: FrameStamp,
) -> IngestDecision {
if let Some(high) = watermark.high_pts {
let delta = high.as_nanos().saturating_sub(stamp.pts.as_nanos());
if delta > policy.max_lateness_ns && stamp.pts.as_nanos() < high.as_nanos() {
return match policy.late_frame_policy {
LateFramePolicy::Reject => IngestDecision::RejectLate,
LateFramePolicy::Drop => IngestDecision::Drop,
LateFramePolicy::AcceptMark => IngestDecision::Accept,
};
}
if stamp.pts.as_nanos() < high.as_nanos() {
return match policy.out_of_order_policy {
OutOfOrderPolicy::Reject => IngestDecision::RejectOutOfOrder,
OutOfOrderPolicy::Drop => IngestDecision::Drop,
OutOfOrderPolicy::Accept => IngestDecision::Accept,
};
}
}
IngestDecision::Accept
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct IngestMetrics {
pub accepted: u64,
pub dropped: u64,
pub rejected_late: u64,
pub rejected_ooo: u64,
pub queue_hwm: u64,
pub source_resets: u64,
pub checkpoints: u64,
}
impl IngestMetrics {
pub fn record(&mut self, decision: IngestDecision) {
match decision {
IngestDecision::Accept => self.accepted = self.accepted.saturating_add(1),
IngestDecision::Drop => self.dropped = self.dropped.saturating_add(1),
IngestDecision::RejectLate => self.rejected_late = self.rejected_late.saturating_add(1),
IngestDecision::RejectOutOfOrder => {
self.rejected_ooo = self.rejected_ooo.saturating_add(1);
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SourceLifecycle {
Added {
source_id: SourceId,
},
Removed {
source_id: SourceId,
reset_tracker: bool,
},
Reconnected {
source_id: SourceId,
},
Reset {
source_id: SourceId,
},
}