Struct IntervalPliInterceptor 

pub struct IntervalPliInterceptor<P> { /* private fields */ }

Requests a keyframe from every bound remote stream on a fixed interval.

• Sans-I/O has no clock of its own: the interval is measured from the first Instant the interceptor is handed, whether that arrives via handle_read or handle_timeout.

Implementations

impl<P> IntervalPliInterceptor<P>

pub fn force_pli(&mut self, now: Instant)

Request a keyframe from every bound stream, now.

Why this takes an instant, and why it is not on the trait

Ein is () for every interceptor, so there is no typed event to carry an out-of-band request through a chain — and widening the trait for one interceptor would break every other. So this is an inherent method, reachable while the concrete type is still in hand (before Registry::boxed erases it). The instant is a parameter because a sans-I/O interceptor has no clock to ask.

pub fn force_pli_for(&mut self, now: Instant, ssrcs: &[u32])

Request a keyframe from specific streams, now.

SSRCs that are not bound are ignored: a PLI for a stream nobody is receiving has no destination.

pub fn bound_streams(&self) -> impl Iterator<Item = u32> + '_

The streams currently being asked for keyframes.

Trait Implementations

impl<P: Interceptor> Interceptor for IntervalPliInterceptor<P>

fn bind_local_stream(&mut self, info: &StreamInfo)

bind_local_stream lets you modify any outgoing RTP packets. It is called once for per LocalStream. The returned method will be called once per rtp packet.

fn unbind_local_stream(&mut self, info: &StreamInfo)

unbind_local_stream is called when the Stream is removed. It can be used to clean up any data related to that track.

fn bind_remote_stream(&mut self, info: &StreamInfo)

bind_remote_stream lets you modify any incoming RTP packets. It is called once for per RemoteStream. The returned method will be called once per rtp packet.

fn unbind_remote_stream(&mut self, info: &StreamInfo)

unbind_remote_stream is called when the Stream is removed. It can be used to clean up any data related to that track.

fn with<O, F>(self, f: F) -> O

where Self: Sized, F: FnOnce(Self) -> O, O: Interceptor,

Wrap this interceptor with another layer.

impl<P: Interceptor> Protocol<TransportMessage<Packet>, TransportMessage<Packet>, ()> for IntervalPliInterceptor<P>

type Rout = TransportMessage<Packet>

Output read message type

type Wout = TransportMessage<Packet>

Output write message type

type Eout = ()

Output event type

type Error = Error

Error type for protocol operations

type Time = Instant

Time/Instant type for timeout handling

fn poll_read(&mut self) -> Option<Self::Rout>

Poll for a processed read message.

fn handle_write(&mut self, msg: TaggedPacket) -> Result<(), Self::Error>

Handle an outgoing write message.

fn handle_event(&mut self, evt: ()) -> Result<(), Self::Error>

Handle a custom event.

fn poll_event(&mut self) -> Option<Self::Eout>

Poll for a generated event.

fn close(&mut self) -> Result<(), Self::Error>

Close the protocol.

fn handle_read(&mut self, msg: TaggedPacket) -> Result<(), Self::Error>

Handle an incoming read message.

fn handle_timeout(&mut self, now: Self::Time) -> Result<(), Self::Error>

Handle a timeout event.

fn poll_timeout(&mut self) -> Option<Self::Time>

Poll for the next timeout deadline.

fn poll_write(&mut self) -> Option<Self::Wout>

Poll for a processed write message.