Struct WebRtcTrackSource 

pub struct WebRtcTrackSource { /* private fields */ }

Available on crate feature webrtc only.

One inbound track — the mirror image of WebRtcTrackSink. A plain SourceElement, same shape as crate::elements::AppSource: it links into its own crate::pipeline::Pipeline via src_pads() like any other source. The difference from AppSource is only who feeds it — instead of an crate::elements::AppSourceHandle the app calls itself, crate::driver::Driver::run pushes into the sending half of this same channel internally, from its own thread, for every Event::MediaData on this track’s Mid. Nothing here ever calls back into caller-supplied code from WebRtcPeer::run’s own thread — that thread only ever touches this crate’s own types (see the module docs for why WebRtcPeer hands tracks out through WebRtcHandle::next_track instead of a callback).

Implementations

impl WebRtcTrackSource

pub fn wait_stream_info(&self, timeout: Duration) -> Result<WebRtcStreamInfo>

Blocks for at most timeout until actual RTP media confirms enough stream parameters to construct downstream consumers. Most codecs are known from the first payload; H.264 waits until both SPS and PPS have arrived. The returned WebRtcStreamInfo can derive the RTP time base and FFmpeg parameters for a decoder or supported muxer.

A timeout returns WebRtcError::StreamInfoTimeout without consuming or invalidating anything, so the caller may retry. Once confirmed, the value is cached and every later call returns it immediately. If the peer closes before the required media information arrives, this returns WebRtcError::Closed. This method does not consume media packets: they remain buffered for SourceElement::run.

pub fn negotiated_codecs(&self) -> Vec<Codec>

Returns the distinct codec families this track can currently receive after SDP negotiation. The order is informational.

This is available as soon as the source is created. For a source on the side that originated the media section, the initial offered list is narrowed when WebRtcHandle::set_answer applies the answer. WebRtcTrackSource::codec remains separate: it reports which codec the remote sender actually chose once media starts arriving.

pub fn codec(&self) -> Option<Codec>

The codec this track is actually carrying, as seen on the most recently received packet’s RTP payload type — None until the first one arrives. Unlike WebRtcHandle::add_track’s codec (which the caller declares up front for an outbound track), an inbound track’s codec isn’t knowable ahead of time: SDP negotiation can accept several codecs for one m= line, and only the packets actually arriving say which one the remote side picked (see Event::MediaData’s own params field). Whatever’s downstream (e.g. a decoder) needs a keyframe before it can do anything useful anyway, so waiting for the first packet to learn the codec isn’t an extra constraint in practice. Use Self::wait_stream_info when the downstream graph must be configured before this source starts running.

Trait Implementations

impl Element for WebRtcTrackSource

fn name(&self) -> Arc<str>

Returns a cheap clone (refcount bump, not a deep copy) of this element’s name — crate::bus::BusEvent stores names as Arc<str> for exactly this reason: a hot path like crate::queue::Queue posting BusEvent::Dropped once per overflowed buffer shouldn’t pay for a fresh heap allocation every time it wants to report which element it is.

fn element_type(&self) -> ElementType

See ElementType.

fn pp_log(&self) -> &PpLog

This element’s identity for crate::bus::Bus::post — same id/name as Element::name, just already wrapped as the crate::pp_log::PpLog its pp_info!/pp_warn!/pp_error! macros need. A stored private field, not built fresh per call, for the same reason name() returns a cheap Arc<str> clone instead of a fresh String — see its own docs.

fn pp_log_mut(&mut self) -> &mut PpLog

Mutable access to the same field Element::pp_log reads — used by crate::pipeline::ChainBuilder to stamp the owning crate::pipeline::Pipeline’s id onto every element that passes through it, via element_pp_log. Not meant to be called from anywhere else.

fn graph_id(&self) -> Option<ElementId>

A pre-reserved graph identity for elements that expose dynamic attachment handles. Most elements receive an ID from ChainBuilder and keep the default None implementation.

fn attach_context(&mut self, _context: &Arc<Context>)

Hands this element the pipeline it is being wired into, at the moment and for the reason Element::pp_log_mut hands it the pipeline’s identity: the clock, the playback clock and the bus are the pipeline’s to give, not the caller’s to choose.

impl Source for WebRtcTrackSource

fn src_pads(&mut self) -> &mut [SrcPad]

Returns every output pad owned by this element.

impl SourceElement for WebRtcTrackSource

fn run(&mut self, control: &ControlReceiver, bus: &Bus) -> Result<()>

Identical shape to crate::elements::AppSource::run: selects on control and its own data channel together, so Stop/Pause never wait behind a remote peer that’s gone quiet. The data channel disconnecting — WebRtcPeer gone, whether from Stop or the connection dying on its own — ends this the same way AppSource ends when every AppSourceHandle is dropped: one final Eos, no error.

fn seek(&mut self, target: Duration) -> Result<Duration>

No timeline of its own — same reasoning as crate::elements::AppSource::seek: a WebRTC connection has nothing to reposition.

fn is_live(&self) -> bool

Whether this source produces data from a live, externally advancing input rather than from a finite or application-controlled timeline.

fn is_seekable(&self) -> bool

Whether this source can reposition its own input timeline through Self::seek.

fn on_control(&mut self, _msg: &ControlMsg)

Reacts to one control message before it is forwarded to this source’s own pads — the same ordering Self::seek gets, and for the same reason: whatever this source holds must already reflect the message by the time downstream elements see it.