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. Hardware full-frame H.264 runs through decide_hw_fullframe; the 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-ARGB path.

Arguments

• settings - Capture configuration. The output_mode, use_cpu, and encode_node_index fields drive encoder selection.

Encoder selection

1. NVENC — on an NVIDIA driver (or no detectable GPU, since the attempt is cheap).
2. VA-API — on any other GPU driver. A 4:4:4 request is carried into the attempt, so a device that cannot encode 4:4:4 fails here and falls through rather than being ruled out in advance.
3. Software — X11Encoder::None: the striped (or, with video_fullframe, full-frame) software path inside encode_cpu, encoding with the build’s software H.264 encoder (SOFTWARE_H264_ENCODER). This is also where a 4:4:4 request lands when no hardware encoder can carry it; libx264 carries it, OpenH264 encodes it 4:2:0.

pub fn request_idr(&mut self)

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

pub fn encoder_name(&self) -> &str

Return a human-readable encoder type string for logging.

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

The Colorspace: field for this pipeline’s stream log, describing what its encoder settled on: VA-API only reaches 4:4:4 when the driver and FFmpeg build carry it, and the software encoder only when the build’s one does (SOFTWARE_H264_FULLCOLOR).

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 reconfigures its live session immediately; VAAPI re-opens its codec context to apply the new rate; the 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.

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.