Struct AppSource 

pub struct AppSource { /* private fields */ }

A source whose data comes from application code pushing buffers in, rather than this element reading them itself — GStreamer’s appsrc equivalent, the reverse of crate::elements::AppSink. Push encoded MediaBuffer::Packets (straight into a decoder) or already-decoded MediaBuffer::Video/MediaBuffer::Audio (e.g. frames from a camera SDK, or synthetic test data) via AppSourceHandle, from any thread — a live capture callback, a network receive loop, a test.

Unlike crate::elements::FileDemuxer, whose blocking read can only be checked against ControlMsg once per loop iteration (see drain_control’s docs), AppSource::run selects on its control channel and its data channel together — a Stop (or any other control message) is handled the moment it arrives, even if AppSourceHandle::push never gets called again.

Push MediaBuffer::Eos when done, or just drop every AppSourceHandle clone — either ends run the same way, pushing exactly one Eos of its own to src_pads().

Has no timeline of its own, so SourceElement::seek is a no-op that reports back whatever was requested as where it “landed” — nothing to reposition when the app, not a file offset, decides what comes next.

Implementations

impl AppSource

pub fn new(name: impl Into<String>, capacity: usize) -> (Self, AppSourceHandle)

capacity bounds how many pushed buffers may sit unconsumed before AppSourceHandle::push blocks — same trade-off as crate::queue::Queue’s own capacity.

Trait Implementations

impl Element for AppSource

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 AppSource

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

Returns every output pad owned by this element.

impl SourceElement for AppSource

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

No-op: AppSource has nothing of its own to reposition — whatever comes next is whatever the app pushes next, not a position in a file. Reports target back as where it “landed” so downstream (e.g. a crate::elements::Pacer resetting its clock offset) still sees a consistent crate::bus::BusEvent::Seeked.

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 run(&mut self, control: &ControlReceiver, bus: &Bus) -> Result<()>

Drives this source until Eos (normal completion), crate::pipeline::Pipeline::finish, or Stop (see ControlMsg::Stop) — call crate::control::drain_control once per loop iteration to make control responsive between blocking reads.

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.