Struct AppSink 

pub struct AppSink<F, C> { /* private fields */ }

Terminal sink that hands every buffer (and, optionally, every control message) to a plain closure instead of requiring a bespoke struct + Element/Sink impl — the equivalent of GStreamer’s appsink: the pipeline’s job ends here, and whatever the caller does with the data (run inference, forward it to a channel, write it out, …) is none of this crate’s concern.

FrameCounter/PacketCounter are what a one-off consumer looked like before this existed — this is the general case of the same pattern, for when a whole new type per use site is more ceremony than the actual logic warrants:

let mut count = 0usize;
let sink = AppSink::new("counter", move |buf: MediaBuffer| {
    if matches!(buf, MediaBuffer::Video(_)) {
        count += 1;
    }
    Ok(())
});

Implementations

impl<F> AppSink<F, fn(ControlMsg) -> Result<()>>

where F: FnMut(MediaBuffer) -> Result<()> + Send + 'static,

pub fn new(name: impl Into<String>, consume: F) -> Self

consume is the only thing this reacts to — every ControlMsg (Pause/Resume/Stop/Seek) is silently ignored, the same as FrameCounter/PacketCounter. Reach for AppSink::with_control instead if the closure needs to know about one of those — e.g. resetting a tracker’s history, or a batch buffer, on Seek, the same way SwDecoder/Pacer react to it internally.

impl<F, C> AppSink<F, C>

where F: FnMut(MediaBuffer) -> Result<()> + Send + 'static, C: FnMut(ControlMsg) -> Result<()> + Send + 'static,

pub fn with_control(name: impl Into<String>, consume: F, control: C) -> Self

Same as AppSink::new, but also hands every ControlMsg to control instead of silently dropping it.

let sink = AppSink::with_control(
    "detector",
    |_buf| Ok(()),
    |msg| {
        if let ControlMsg::Seek(_) = msg {
            // e.g. clear a tracker's history here
        }
        Ok(())
    },
);

Trait Implementations

impl<F, C> Element for AppSink<F, C>

where F: FnMut(MediaBuffer) -> Result<()> + Send + 'static, C: FnMut(ControlMsg) -> Result<()> + Send + 'static,

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.

impl<F, C> Sink for AppSink<F, C>

where F: FnMut(MediaBuffer) -> Result<()> + Send + 'static, C: FnMut(ControlMsg) -> Result<()> + Send + 'static,

fn consume(&mut self, buf: MediaBuffer) -> Result<()>

fn control(&mut self, msg: ControlMsg) -> Result<()>

Reacts to a ControlMsg (pause/resume/stop) and, for anything with a downstream of its own, forwards it on — same shape as consume, just a separate channel from MediaBuffer so it can reach every element (not just ones that already know how to interpret a data buffer) and, at a crate::queue::Queue, jump ahead of whatever data is backed up instead of waiting behind it. No default: every Sink has to consciously decide what this means for it, rather than silently dropping it.