Struct WlCapture 

pub struct WlCapture {

    pub settings: RustCaptureSettings,
    pub callback: Option<Arc<Py<PyAny>>>,
    pub video_encoder: Option<GpuEncoder>,
    pub vaapi_state: StripeState,
    pub recording_sink: Option<Arc<RecordingSink>>,
    pub deliver_tx: Option<SyncSender<Vec<EncodedStripe>>>,
    pub deliver_join: Option<JoinHandle<()>>,
    pub deliver_discard: Option<Arc<AtomicBool>>,
    pub pending_hw_delivery: Option<Vec<EncodedStripe>>,
    pub pending_hw_damage: bool,
    pub encode_pool: Option<Arc<WlFramePool>>,
    pub encode_join: Option<JoinHandle<Option<GpuEncoder>>>,
    pub encode_controls: Arc<WlEncodeControls>,
    pub encode_stats: Arc<WlEncodeStats>,
    pub pool_last_render: Vec<u64>,
    pub render_seq: u64,
    pub pool_content_gen: Vec<u64>,
    pub content_gen: u64,
    pub frame_counter: u16,
    pub pending_force_idr: bool,
    pub needs_full_render: bool,
    pub last_tick: Option<Instant>,
    pub hw_error_streak: u32,
    pub hw_rebuilt: bool,
}

One capture pipeline bound to one output (display id): its settings, encoder set, frame pools, delivery thread, and per-stream bookkeeping. Exactly one capture may run per output; all fields mirror the pipeline strategy documented on AppState, instantiated per display.

Fields

settings: RustCaptureSettings

callback: Option<Arc<Py<PyAny>>>

The Python frame callback, shared with the delivery thread. Kept here so a reconfigure the calloop performs on its own (a host that kept a different mode) can respawn delivery with the same consumer; None for a recorder-owned capture.

video_encoder: Option<GpuEncoder>

Zero-copy GPU session (GLES render + same-GPU dmabuf encode), calloop-affine; None whenever a readback path is active for this display.

vaapi_state: StripeState

recording_sink: Option<Arc<RecordingSink>>

deliver_tx: Option<SyncSender<Vec<EncodedStripe>>>

deliver_join: Option<JoinHandle<()>>

deliver_discard: Option<Arc<AtomicBool>>

Raised at teardown so the deliver thread stops calling into Python and only drains: its exit is then bounded by the one in-flight callback.

pending_hw_delivery: Option<Vec<EncodedStripe>>

pending_hw_damage: bool

encode_pool: Option<Arc<WlFramePool>>

encode_join: Option<JoinHandle<Option<GpuEncoder>>>

encode_controls: Arc<WlEncodeControls>

encode_stats: Arc<WlEncodeStats>

pool_last_render: Vec<u64>

render_seq: u64

pool_content_gen: Vec<u64>

content_gen: u64

frame_counter: u16

pending_force_idr: bool

needs_full_render: bool

last_tick: Option<Instant>

Last tick this capture actually rendered; paces per-display fps under the one shared render timer (which fires at the fastest active capture’s rate).

hw_error_streak: u32

Consecutive zero-copy encode failures; reset by any frame that encodes cleanly. Reaching HW_ERROR_RECOVERY_THRESHOLD triggers recovery.

hw_rebuilt: bool

Whether the zero-copy session has already been rebuilt without a clean frame since. Recovery rebuilds once and demotes to readback on the next streak, so a session that constructs but never encodes cannot loop rebuilding forever.

Implementations

impl WlCapture

pub fn request_idr(&mut self)

Arm a keyframe on whichever path is live, plus a full render so a static screen still produces the frame. Exactly ONE flag is set: the pool encode loop consumes the atomic, every other path consumes pending_force_idr — setting both would leave one armed forever (the host-mode idle gate polls them every tick, so a stuck flag disables idle skipping for the session).