Struct Timeline 

pub struct Timeline { /* private fields */ }

A stateful conversion session.

Implementations

impl Timeline

pub fn new() -> Self

New session with no anchor.

pub fn with_anchor(anchor: TimeAnchor) -> Self

New session with a wall-clock anchor.

Examples found in repository

examples/scte35_to_hls.rs (line 29)

fn main() {
    // Real Unified Streaming splice: ID 2002, out-of-network, break_duration 24 s.
    let hex = "FC302100000000000000FFF01005000007D27FEF7F7E0020F580C0000000000088B9661D";
    let raw: Vec<u8> = (0..hex.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
        .collect();

    // Wall-clock anchor: assume PTS 0 == 2024-01-15T12:00:00.000Z (ms since epoch).
    let utc_epoch_ms: i64 = 1_705_320_000_000; // 2024-01-15 12:00:00 UTC
    let anchor = TimeAnchor {
        pts_90k: 0,
        utc_epoch_ms,
    };

    let mut timeline = Timeline::with_anchor(anchor);

    // Parse the SCTE-35 section and unroll PTS wrap.
    let event = timeline.push_scte35(&raw).expect("valid splice");

    // Convert to a DATERANGE.
    let daterange = timeline.to_daterange(&event).expect("anchor is set");

    println!("Event kind  : {}", event.kind);
    println!("Event id    : {:?}", event.id);
    println!(
        "Duration    : {:?}s",
        event.duration.map(|d| d.as_seconds_f64())
    );
    println!();
    println!("{}", daterange.to_tag_line());
}

examples/scte35_to_dash.rs (line 27)

fn main() {
    // Real Unified Streaming splice: ID 2002, out-of-network, break_duration 24 s.
    let hex = "FC302100000000000000FFF01005000007D27FEF7F7E0020F580C0000000000088B9661D";
    let raw: Vec<u8> = (0..hex.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
        .collect();

    let anchor = TimeAnchor {
        pts_90k: 0,
        utc_epoch_ms: 1_705_320_000_000,
    };
    let mut timeline = Timeline::with_anchor(anchor);
    let event = timeline.push_scte35(&raw).expect("valid splice");

    // Build emsg config: 90 kHz timescale, segment-relative delta 0, 24 s duration.
    let cfg = EmsgConfig {
        timescale: 90_000,
        presentation: PresentationTime::Delta(0),
        event_duration: 2_160_000, // 24s * 90000
        value: "34".to_string(),   // segmentation_type_id for Provider Ad Start
        id: event.id.unwrap_or(0),
    };

    let emsg_bytes = timeline
        .to_emsg(&event, &cfg)
        .expect("SCTE-35-sourced event");

    println!("Event kind  : {}", event.kind);
    println!("Event id    : {:?}", event.id);
    println!("emsg length : {} bytes", emsg_bytes.len());
    println!();
    println!(
        "emsg hex: {}",
        emsg_bytes
            .iter()
            .map(|b| format!("{:02X}", b))
            .collect::<Vec<_>>()
            .join("")
    );

    // Verify round-trip: extract the splice from the emsg and compare.
    use timed_metadata::convert::emsg_to_scte35;
    let extracted = emsg_to_scte35(&emsg_bytes).expect("round-trip");
    assert_eq!(extracted, raw, "splice bytes must survive verbatim");
    println!();
    println!("Round-trip verified: splice bytes survive verbatim in emsg message_data.");
}

pub fn set_anchor(&mut self, anchor: TimeAnchor)

Set / replace the anchor.

pub fn push_scte35(&mut self, bytes: &[u8]) -> Result<TimedEvent>

Parse a SCTE-35 section; unroll its PTS into an absolute MediaTime.

Examples found in repository

examples/scte35_to_hls.rs (line 32)

fn main() {
    // Real Unified Streaming splice: ID 2002, out-of-network, break_duration 24 s.
    let hex = "FC302100000000000000FFF01005000007D27FEF7F7E0020F580C0000000000088B9661D";
    let raw: Vec<u8> = (0..hex.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
        .collect();

    // Wall-clock anchor: assume PTS 0 == 2024-01-15T12:00:00.000Z (ms since epoch).
    let utc_epoch_ms: i64 = 1_705_320_000_000; // 2024-01-15 12:00:00 UTC
    let anchor = TimeAnchor {
        pts_90k: 0,
        utc_epoch_ms,
    };

    let mut timeline = Timeline::with_anchor(anchor);

    // Parse the SCTE-35 section and unroll PTS wrap.
    let event = timeline.push_scte35(&raw).expect("valid splice");

    // Convert to a DATERANGE.
    let daterange = timeline.to_daterange(&event).expect("anchor is set");

    println!("Event kind  : {}", event.kind);
    println!("Event id    : {:?}", event.id);
    println!(
        "Duration    : {:?}s",
        event.duration.map(|d| d.as_seconds_f64())
    );
    println!();
    println!("{}", daterange.to_tag_line());
}

examples/scte35_to_dash.rs (line 28)

fn main() {
    // Real Unified Streaming splice: ID 2002, out-of-network, break_duration 24 s.
    let hex = "FC302100000000000000FFF01005000007D27FEF7F7E0020F580C0000000000088B9661D";
    let raw: Vec<u8> = (0..hex.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
        .collect();

    let anchor = TimeAnchor {
        pts_90k: 0,
        utc_epoch_ms: 1_705_320_000_000,
    };
    let mut timeline = Timeline::with_anchor(anchor);
    let event = timeline.push_scte35(&raw).expect("valid splice");

    // Build emsg config: 90 kHz timescale, segment-relative delta 0, 24 s duration.
    let cfg = EmsgConfig {
        timescale: 90_000,
        presentation: PresentationTime::Delta(0),
        event_duration: 2_160_000, // 24s * 90000
        value: "34".to_string(),   // segmentation_type_id for Provider Ad Start
        id: event.id.unwrap_or(0),
    };

    let emsg_bytes = timeline
        .to_emsg(&event, &cfg)
        .expect("SCTE-35-sourced event");

    println!("Event kind  : {}", event.kind);
    println!("Event id    : {:?}", event.id);
    println!("emsg length : {} bytes", emsg_bytes.len());
    println!();
    println!(
        "emsg hex: {}",
        emsg_bytes
            .iter()
            .map(|b| format!("{:02X}", b))
            .collect::<Vec<_>>()
            .join("")
    );

    // Verify round-trip: extract the splice from the emsg and compare.
    use timed_metadata::convert::emsg_to_scte35;
    let extracted = emsg_to_scte35(&emsg_bytes).expect("round-trip");
    assert_eq!(extracted, raw, "splice bytes must survive verbatim");
    println!();
    println!("Round-trip verified: splice bytes survive verbatim in emsg message_data.");
}

pub fn to_daterange(&self, ev: &TimedEvent) -> Result<DateRange>

Convert to a DATERANGE (requires an anchor).

Examples found in repository

examples/scte35_to_hls.rs (line 35)

fn main() {
    // Real Unified Streaming splice: ID 2002, out-of-network, break_duration 24 s.
    let hex = "FC302100000000000000FFF01005000007D27FEF7F7E0020F580C0000000000088B9661D";
    let raw: Vec<u8> = (0..hex.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
        .collect();

    // Wall-clock anchor: assume PTS 0 == 2024-01-15T12:00:00.000Z (ms since epoch).
    let utc_epoch_ms: i64 = 1_705_320_000_000; // 2024-01-15 12:00:00 UTC
    let anchor = TimeAnchor {
        pts_90k: 0,
        utc_epoch_ms,
    };

    let mut timeline = Timeline::with_anchor(anchor);

    // Parse the SCTE-35 section and unroll PTS wrap.
    let event = timeline.push_scte35(&raw).expect("valid splice");

    // Convert to a DATERANGE.
    let daterange = timeline.to_daterange(&event).expect("anchor is set");

    println!("Event kind  : {}", event.kind);
    println!("Event id    : {:?}", event.id);
    println!(
        "Duration    : {:?}s",
        event.duration.map(|d| d.as_seconds_f64())
    );
    println!();
    println!("{}", daterange.to_tag_line());
}

pub fn to_emsg(&self, ev: &TimedEvent, cfg: &EmsgConfig) -> Result<Vec<u8>>

Convert to a serialized SCTE-35 emsg box.

Examples found in repository

examples/scte35_to_dash.rs (line 40)

fn main() {
    // Real Unified Streaming splice: ID 2002, out-of-network, break_duration 24 s.
    let hex = "FC302100000000000000FFF01005000007D27FEF7F7E0020F580C0000000000088B9661D";
    let raw: Vec<u8> = (0..hex.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
        .collect();

    let anchor = TimeAnchor {
        pts_90k: 0,
        utc_epoch_ms: 1_705_320_000_000,
    };
    let mut timeline = Timeline::with_anchor(anchor);
    let event = timeline.push_scte35(&raw).expect("valid splice");

    // Build emsg config: 90 kHz timescale, segment-relative delta 0, 24 s duration.
    let cfg = EmsgConfig {
        timescale: 90_000,
        presentation: PresentationTime::Delta(0),
        event_duration: 2_160_000, // 24s * 90000
        value: "34".to_string(),   // segmentation_type_id for Provider Ad Start
        id: event.id.unwrap_or(0),
    };

    let emsg_bytes = timeline
        .to_emsg(&event, &cfg)
        .expect("SCTE-35-sourced event");

    println!("Event kind  : {}", event.kind);
    println!("Event id    : {:?}", event.id);
    println!("emsg length : {} bytes", emsg_bytes.len());
    println!();
    println!(
        "emsg hex: {}",
        emsg_bytes
            .iter()
            .map(|b| format!("{:02X}", b))
            .collect::<Vec<_>>()
            .join("")
    );

    // Verify round-trip: extract the splice from the emsg and compare.
    use timed_metadata::convert::emsg_to_scte35;
    let extracted = emsg_to_scte35(&emsg_bytes).expect("round-trip");
    assert_eq!(extracted, raw, "splice bytes must survive verbatim");
    println!();
    println!("Round-trip verified: splice bytes survive verbatim in emsg message_data.");
}

Trait Implementations

impl Debug for Timeline

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Timeline

fn default() -> Timeline

Returns the “default value” for a type.