Struct FragmentWriter 

pub struct FragmentWriter<W: Write> {
    out: W,
    seq: u32,
    wrote_init: bool,
    pending: Option<PendingSample>,
    last_dts: Option<u64>,
    durations: Vec<u32>,
    audio: Option<AudioTrackConfig>,
    audio_pending: Vec<(Vec<u8>, u32)>,
    audio_batch_dts: u64,
    audio_next_dts: u64,
    stats: Mp4Stats,
}

Codec-agnostic fMP4 fragment writer: ftyp+moov once, then one moof+mdat pair per video sample, each anchored at its wall-clock decode time via tfdt, and one per batch of audio samples.

Fields

out: W

seq: u32

wrote_init: bool

pending: Option<PendingSample>

last_dts: Option<u64>

durations: Vec<u32>

Every flushed inter-frame duration, kept so the final buffered sample (whose successor never arrives) can close on the MEDIAN — damage-driven capture makes the last observed delta an outlier as often as not (a long static gap, a burst pair).

audio: Option<AudioTrackConfig>

audio_pending: Vec<(Vec<u8>, u32)>

Pending audio packets with their durations; contiguous from audio_batch_dts.

audio_batch_dts: u64

audio_next_dts: u64

stats: Mp4Stats

Implementations

impl<W: Write> FragmentWriter<W>

pub fn new(out: W) -> Self

pub fn with_audio(self, cfg: AudioTrackConfig) -> Self

Declare the audio track; must precede write_init.

pub fn init_written(&self) -> bool

pub fn stats(&self) -> Mp4Stats

Counters for the fragments written so far (the buffered pending sample is not yet included; finish folds it in).

pub fn write_init(&mut self, cfg: &TrackConfig) -> Result<()>

Write ftyp + moov (the video track, the audio track when declared, and the mvex/trex marking the movie fragmented). Must be called once, before the first sample.

pub fn push_sample( &mut self, data: Vec<u8>, sync: bool, pts_us: u64, ) -> Result<()>

Queue one sample at pts_us (wall-clock microseconds since recording start), flushing the previously buffered sample with its now-known duration. Timestamps are clamped strictly monotonic so a repeated or reordered clock can never emit a zero/negative duration.

fn median_duration(&self) -> u32

Median of the observed inter-frame durations (default 1/30 s when fewer than two frames were pushed), used to close the final sample.

fn write_fragment(&mut self, s: &PendingSample, duration: u32) -> Result<()>

pub fn push_audio(&mut self, data: Vec<u8>, dts: u64) -> Result<()>

Queue one audio packet decoding at dts on the 48 kHz clock. A packet that does not follow the pending ones directly (a gap in the stream) closes their fragment first, so every fragment’s samples are contiguous from its tfdt.

fn flush_audio(&mut self) -> Result<()>

Write the pending audio packets as one fragment of track 2, every sample a sync sample with its own duration and size.

pub fn finish(self) -> Result<Mp4Stats>

Flush the pending audio and the final buffered video sample, closed with the MEDIAN observed inter-frame duration (its successor never arrives), and return the aggregate counters.