Struct Producer 

pub struct Producer { /* private fields */ }

Writes frames to a group in order.

Each group is delivered independently over a QUIC stream. Use Self::write_frame for simple single-buffer frames, or Self::create_frame for multi-chunk streaming writes.

Implementations

impl Producer

pub fn timescale(&self) -> Timescale

The parent track’s timescale.

pub fn write_frame<B: IntoBytes>( &mut self, timestamp: Timestamp, data: B, ) -> Result<()>

A helper method to write a frame from a single byte buffer.

If you want to write multiple chunks, use Self::create_frame to get a frame producer. But an upfront size is required.

timestamp is converted into the parent track’s timescale. For data without a presentation time, pass Timestamp::now explicitly.

pub fn write_frames<const N: usize>( &mut self, frames: &mut Buffer<N>, ) -> Result<()>

Write a whole batch of frames at once, draining frames.

One lock covers the batch, so an ingest with several frames in hand pays the group mutex and the track’s eviction settle once rather than per frame. Build the batch with frame::Buffer::push.

The batch is validated before anything is written, so a rejected frame leaves both the group and the buffer exactly as they were, ready to retry or redirect. Returns Error::FrameOpen if another handle is streaming a frame into this group, since appending around it would reorder the group.

pub fn create_frame(&mut self, frame: Info) -> Result<Producer<'_>>

Create a frame with an upfront size and presentation timestamp, streamed in chunks. Borrows the group exclusively until the returned frame::Producer is finished or dropped, so only one frame is open at a time.

The timestamp is converted into the parent track’s timescale, so the scale you build it with doesn’t have to match the track. Returns Error::FrameTooLarge if the declared size exceeds the group’s byte budget (refused before allocating) or Error::TimestampMismatch if the timestamp can’t be converted (overflow).

pub fn frame_count(&self) -> usize

Return the number of frames written so far (completed plus any in-flight).

pub fn finish(&mut self) -> Result<()>

Mark the group as complete; no more frames will be written.

Borrows rather than consumes, so a later failure can still be reported through abort. The handle also keeps the cached frames readable.

pub fn abort(self, err: Error) -> Result<()>

Abort the group with the given error.

Consumes the handle. Drops the cached frames so a stale Consumer can’t pin their buffers in memory forever; consumers that haven’t drained yet surface the abort error instead of the leftover cache.

pub fn consume(&self) -> Consumer

Create a new consumer for the group.

pub async fn closed(&self) -> Error

Block until the group is closed or aborted.

pub fn poll_closed(&self, waiter: &Waiter) -> Poll<Error>

Poll until the group is closed or aborted; ready with the cause.

pub async fn unused(&self) -> Result<()>

Block until there are no active consumers.

Trait Implementations

impl Clone for Producer

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for Producer

type Target = Info

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.