Struct X11Pipeline 

pub struct X11Pipeline { /* private fields */ }

Everything the X11 host-ARGB path has to remember between frames.

Unlike the Wayland backend, X11 capture has no compositor to report what changed, so this context exists to hold the state that stands in for that missing damage signal: the per-stripe hashes and the persistent encoder session that let process() discover damage by comparing content frame-to-frame. A full-frame encoder runs through decide_hw_fullframe; the striped software path (JPEG, striped or full-frame software H.264) runs through encode_cpu with hash_damage=true.

Recording fan-out (socket sink and MP4 recorder) is handled at the delivery layer; a consumer needing a keyframe goes through X11Pipeline::request_idr like everyone else.

Implementations

impl X11Pipeline

pub fn new(settings: RustCaptureSettings) -> Self

Build the context, choosing the full-frame encoder for the X11 host-BGRA path through the shared ladder (select_frame_encoder): the hardware backend the encode node’s driver selects, then the codec’s software encoder, or the striped software path for JPEG and H.264. A codec no backend serves falls through to the video codecs the host does serve, JPEG last.

pub fn request_idr(&mut self)

Request an on-demand keyframe on the next processed frame.

pub fn take_report(&mut self, report: ReferenceReport)

Apply what the consumers say of a frame (FrameEncoder::take_report): a loss leaves it and every frame after it out of the predictions, a key frame where the encoder cannot.

pub fn encoder_name(&self) -> String

The encoder’s name for the stream log: the hardware backend, the software library of a full-frame session, or CPU with the library of the striped software path.

pub fn codec(&self) -> Codec

The codec the pipeline actually emits, after any demotion.

pub fn is_hardware(&self) -> bool

Whether the pipeline encodes on a GPU.

pub fn fixed_rate_control(&self) -> Option<&'static str>

The encoder’s one rate control where its backend has one alone (FrameEncoder::fixed_rate_control), for this pipeline’s stream log.

pub fn holds_quantizer(&self) -> bool

Whether the encoder holds a cleanup at the quantizer asked for (FrameEncoder::holds_quantizer, software::stripes_hold_quantizer), for this pipeline’s stream log.

pub fn colorspace_desc(&self) -> &'static str

The Colorspace: field for this pipeline’s stream log, describing what its encoder settled on: a hardware session only reaches 4:4:4 when the device carries it, the software path only when the build’s encoder for the codec does.

pub fn reshape( &mut self, settings: &RustCaptureSettings, size_changed: bool, ) -> bool

Adapt the live pipeline to recreated capture surfaces without rebuilding it.

Arguments

• settings - New geometry plus current live rates.
• size_changed - Whether the capture dimensions changed.

Returns

true if the pipeline was successfully adapted in place; false when the active encoder cannot follow (VAAPI on resize) and the caller must rebuild.

pub fn update_rate(&mut self, bitrate_kbps: i32, vbv_multiplier: f64, fps: f64)

Apply a runtime rate-control / framerate change: the CBR target bitrate + VBV (kbps / kb; ignored unless CBR is active) and the target fps. NVENC and libvpx reconfigure their live session, as x265 does unless the frame rate moved; x265 then re-opens, as kvazaar and SVT-AV1 always do; a VA-API session starts a new sequence; the striped software path picks the new values up on the next process() (encode_cpu reads the updated settings and reconfigures each stripe’s encoder).

pub fn update_tunables(&mut self, t: &LiveTunables)

Apply live per-frame tunables (quality, paint-over, streaming mode, keyframe cadence); every encoder re-reads them from the settings on the next process().

pub fn process(&mut self, argb: &[u8], stride: usize) -> Vec<EncodedStripe>

Encode one host-ARGB frame and return the encoded stripes.

Damage is read from the content hash (hash_bands). Without Turbo the hash decides whether a frame (or a stripe) is sent, so it runs first. Turbo sends every video frame, and only its cleanup reads the damage, so there the frame’s hash runs beside its encode (hash_beside) and the cleanup reads the frame before’s (turbo_dirty; the striped path as the rows it maps onto its stripes): the hash, a millisecond and a half at 1080p and six at 4K, stays off the path to the client. A frame the cleanup codes at its own quality is hashed before its encode instead, so a change landing on it is coded at the session’s. With the paint-over off nothing reads it, and Turbo hashes nothing.

Arguments

• argb - Packed BGRA pixel buffer (B,G,R,A byte order, stride bytes per row).
• stride - Bytes per row (must equal width * 4 for the software path).

Returns

Vec of EncodedStripe — empty when nothing changed.