Struct WlCapture 

pub struct WlCapture {

    pub settings: CaptureSettings,
    pub callback: Option<Arc<dyn FrameSink>>,
    pub zero_copy: Option<Arc<Mutex<Option<FrameEncoder>>>>,
    pub gpu_pool: Option<Arc<WlFramePool<Dmabuf>>>,
    pub gpu_ring: Vec<(BufferObject<()>, Dmabuf)>,
    pub host_still: Option<(BufferObject<()>, Dmabuf)>,
    pub host_inflight: Vec<(u64, HostFrame)>,
    pub scanout_inflight: Vec<(u64, Buffer)>,
    pub direct: Option<Result<(), &'static str>>,
    pub published: u64,
    pub host_retained_use: u64,
    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 encode_pool: Option<Arc<WlFramePool>>,
    pub encode_join: Option<JoinHandle<Option<FrameEncoder>>>,
    pub encode_controls: Arc<WlEncodeControls>,
    pub encode_stats: Arc<WlEncodeStats>,
    pub report: Arc<StreamReport>,
    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 pace: FramePace,
    pub change_pending: bool,
    pub callbacks_at: Option<Instant>,
    pub callbacks_owed: 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: CaptureSettings

callback: Option<Arc<dyn FrameSink>>

The frame sink, 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.

zero_copy: Option<Arc<Mutex<Option<FrameEncoder>>>>

Zero-copy GPU session (GLES render + same-GPU dmabuf encode), driven by the encode thread on gpu_pool’s targets and taken back by a restart (crate::ZeroCopySession); None whenever a readback path is active for this display.

gpu_pool: Option<Arc<WlFramePool<Dmabuf>>>

The zero-copy session’s render targets, handed between the calloop, which composites into one, and the encode thread, which encodes it in place; gpu_ring owns them.

gpu_ring: Vec<(BufferObject<()>, Dmabuf)>

host_still: Option<(BufferObject<()>, Dmabuf)>

A quiet host’s GPU frame copied out of the stream’s buffer (detach_retained_gpu).

host_inflight: Vec<(u64, HostFrame)>

Host frames replaced while a frame in flight to the encode thread still reads them, each with the count of recycled frames (WlEncodeStats::recycled) after which it is free to go back to the host; published counts the frames handed over.

scanout_inflight: Vec<(u64, Buffer)>

Client buffers encoded as they stood (crate::scanout_candidate), each held, so its client is not told to draw into it again, until the recycled count passes the frame that reads it, as host_inflight holds host frames.

direct: Option<Result<(), &'static str>>

Whether the last frame was encoded from a client’s buffer, else why it was composited, so only a change is logged; None before the first frame.

published: u64

host_retained_use: u64

The frame count of the last publish that encodes the retained host frame.

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 the sink and only drains: its exit is then bounded by the one in-flight call.

encode_pool: Option<Arc<WlFramePool>>

encode_join: Option<JoinHandle<Option<FrameEncoder>>>

encode_controls: Arc<WlEncodeControls>

encode_stats: Arc<WlEncodeStats>

report: Arc<StreamReport>

What this capture streams and how, for ScreenCapture::stream_info.

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

pace: FramePace

One frame a period, a change taking its period’s frame as it lands, and the extra frames a change in a taken period may spend (FramePace::windowed), as the X11 captures pace.

change_pending: bool

A change (a client’s commit, input, a host frame) found its period’s frame taken and waits for the next period to open (serve_changes); any frame rendered clears it.

callbacks_at: Option<Instant>

The window boundary whose frame callbacks went out (answer_frame_callbacks).

callbacks_owed: bool

A boundary’s frame callbacks wait for the render of a change still pending at it.

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).

pub fn invalidate_reference(&mut self, frame_id: u16, withheld: bool)

Leave frame frame_id and every frame after it out of the predictions, for a client that lost it or a sender that withheld it (withheld): handed to the encode thread, which applies it ahead of its next encode. An encoder that cannot codes a keyframe instead.

pub fn acknowledge_reference(&mut self, frame_id: u16, held: bool)

Note that every consumer holds frame frame_id, or where not held was sent it (ReferenceWindow::acknowledge), handed on as invalidate_reference hands a loss.

fn take_report(&mut self, report: ReferenceReport)

pub fn pooled(&self) -> bool

Whether an encode thread runs this capture’s encodes (a readback pool or the zero-copy session’s): every one does once its delivery is up.