Struct VideoPipe

struct VideoPipe {
    path: String,
    size: (u32, u32),
    fps: f64,
    duration: f64,
    child: Option<(Child, ChildStdout)>,
    out_size: (u32, u32),
    next: i64,
    cur: Frame,
    have: bool,
    end: f64,
    scaled: Vec<u8>,
    skey: (i64, u32, u32),
}

Fields

path: String

size: (u32, u32)

fps: f64

duration: f64

child: Option<(Child, ChildStdout)>

out_size: (u32, u32)

Output size of the running process.

next: i64

Absolute frame index of the next frame the pipe will deliver.

cur: Frame

Last delivered frame (index next-1), valid when have is true.

have: bool

end: f64

Earliest known end (set when the pipe hits EOF) — avoids respawn storms past the end.

scaled: Vec<u8>

cur shrunk to skey = (frame index, w, h): repeated calls at the same t and size are free.

skey: (i64, u32, u32)

Implementations

impl VideoPipe

fn respawn(&mut self, idx: i64, w: u32, h: u32) -> bool

fn read_next(&mut self) -> bool

Read the next frame into cur. False at EOF (child is reaped, end updated).

Trait Implementations

impl Drop for VideoPipe

fn drop(&mut self)

Executes the destructor for this type.

impl VideoSource for VideoPipe

fn size(&self) -> (u32, u32)

Native (coded) size.

fn frame_at(&mut self, t: f64, w: u32, h: u32, out: &mut Frame) -> bool

Decode the frame displayed at source time t, scaled (aspect-ignorant, caller picks w/h; the compositor never asks for more than native size, so upscaling need only be correct) into out. Returns false at/after EOF or on error (then out is untouched). Must be cheap for sequential increasing t (playback: keep decoding forward); may seek for other jumps.