Struct SmoothOrigin 

pub struct SmoothOrigin { /* private fields */ }

Available on crate feature std only.

The live Smooth origin over one Trunk.

Implementations

impl SmoothOrigin

pub fn new(config: SmoothOriginConfig) -> Self

An origin over config.trunk; it describes whatever segments the trunk currently holds, once an init segment is stored and at least one track is announced.

pub fn trunk(&self) -> &Arc<Trunk>

The Trunk this origin reads.

pub fn stream_keys(&self) -> Vec<StreamKey>

The streams this origin currently advertises, in manifest order — the vocabulary SmoothRequest::parse needs to read a request path. Empty while the trunk has nothing to describe.

pub fn set_init(&self, bytes: impl Into<Bytes>)

Store the fMP4 init segment the trunk’s segments are muxed with — the one thing no Trunk ring holds, and what a fragment request is re-demuxed against. Storing the segment already held changes nothing, so a host may call this on every request without invalidating the cached plan.

pub fn init(&self) -> Option<Bytes>

The init segment currently stored, if any.

pub fn fragments(&self) -> Result<Vec<FragmentLocation>, SmoothOriginError>

The fragments currently advertised, in manifest order, or None while the trunk has nothing to advertise yet.

pub fn manifest( &self, now: Timestamp, await_policy: AwaitPolicy, ) -> EgressResponse<String>

Render the live client Manifest, or why it cannot be rendered yet (EgressResponse::Await) or at all (EgressResponse::BadRequest).

Trait Implementations

impl ServedEgress for SmoothOrigin

type Request = SmoothRequest

The protocol-specific request shape (e.g. LL-HLS’s Media Sequence Number + part index; a DASH segment/manifest request; a catch-up time range) — owned by the implementing crate, not this one.

type Body = SmoothBody

The protocol-specific resolved body (a playlist string, manifest XML, segment bytes, …).

fn resolve( &self, request: SmoothRequest, now: Timestamp, await_policy: AwaitPolicy, ) -> EgressResponse<SmoothBody>

Resolve request against this implementation’s current state at time now, bounded by await_policy — see EgressResponse::Await’s contract.

fn is_warm(&self, request: &SmoothRequest) -> bool

true when resolveing request now is cheap: no scan, demux or packaging is left to do. An implementation that has such work answers false until prepare has run, so an async host can do that work on a blocking thread rather than on the worker that woke the request. The default is always warm.

fn prepare(&self, request: SmoothRequest)

Do the heavy work request needs so that the next resolve is warm. Blocking and CPU-bound; call it on a thread that may block. The default does nothing.