Struct Controls 

pub struct Controls {
    pub stop: AtomicBool,
    pub finished: AtomicBool,
    pub force_idr: AtomicBool,
    pub rate_dirty: AtomicBool,
    pub bitrate_kbps: AtomicI32,
    pub vbv_mult_milli: AtomicI32,
    pub fps_milli: AtomicU64,
    pub tunables_dirty: AtomicBool,
    pub tunables: Mutex<Option<LiveTunables>>,
    pub capture_cursor: AtomicBool,
    pub region_dirty: AtomicBool,
    pub region: Mutex<(i32, i32, i32, i32)>,
}

Cross-thread controls for a running capture: a bag of atomics (plus two mutex-guarded payloads) the owning ScreenCapture pyclass flips from the Python thread and the capture thread reads at the top of each iteration.

It exists so Python never has to reach into the pipeline. The X11Pipeline and its encoder are only safe to touch from the capture and encode threads, so request_idr / rate / fps / region changes are posted here as atomic flags and applied later on the thread that owns the pipeline, rather than mutating encoder state across the thread boundary from Python.

1. Lifecycle: stop ends the capture loop; force_idr requests an on-demand keyframe on the next processed frame.
2. Rate control (gated by rate_dirty): bitrate_kbps, vbv_mult_milli (the VBV frame-time multiplier * 1000, held as an integer for atomics; <= 0 selects the policy default), and fps_milli (target fps * 1000, re-read every frame for dynamic pacing and rate control). These atomics always hold the CURRENT values, so a pipeline rebuild can carry live rates forward.
3. Tunables (gated by tunables_dirty): one LiveTunables struct behind tunables, set rarely, carrying the per-frame quality knobs for the encode thread.
4. Capture geometry: capture_cursor toggles the cursor overlay (read on every grab); region_dirty guards region = (x, y, w, h) (w/h <= 0 extends to the root edge), applied by the capture thread with the same drain/recreate machinery as auto-adjust.

Fields

stop: AtomicBool

finished: AtomicBool

Set by the capture thread as it returns — after it has joined its encode thread and so dropped the NVENC/CUDA session. The atexit sweep waits on this (bounded) before letting the interpreter finalize, because that hardware-session drop racing process exit segfaults, exactly as the Wayland branch fences with a Barrier.

force_idr: AtomicBool

rate_dirty: AtomicBool

bitrate_kbps: AtomicI32

vbv_mult_milli: AtomicI32

fps_milli: AtomicU64

tunables_dirty: AtomicBool

tunables: Mutex<Option<LiveTunables>>

capture_cursor: AtomicBool

region_dirty: AtomicBool

region: Mutex<(i32, i32, i32, i32)>

Implementations

impl Controls

pub fn new(s: &RustCaptureSettings) -> Self

Seed the controls from the initial settings so the first loop iteration reads the configured bitrate / VBV / fps / region / cursor state rather than defaults.