Struct CaptureSettings 

pub struct CaptureSettings {

    pub display_id: u32,
    pub use_wayland: Option<bool>,
    pub render_node_path: String,
    pub encode_node_path: String,
    pub auto_gpu: String,
    pub cursor_size: i32,
    pub width: i32,
    pub height: i32,
    pub scale: f64,
    pub capture_x: i32,
    pub capture_y: i32,
    pub target_fps: f64,
    pub jpeg_quality: i32,
    pub paint_over_jpeg_quality: i32,
    pub use_paint_over_quality: bool,
    pub paint_over_trigger_frames: u32,
    pub damage_block_threshold: u32,
    pub damage_block_duration: u32,
    pub codec: Codec,
    pub video_crf: i32,
    pub video_paintover_crf: i32,
    pub video_paintover_burst_frames: i32,
    pub video_fullcolor: bool,
    pub video_bit_depth: i32,
    pub video_streaming_mode: bool,
    pub capture_cursor: bool,
    pub cursor_size_cap: i32,
    pub watermark_path: String,
    pub watermark_location_enum: i32,
    pub encode_node_index: i32,
    pub use_cpu: bool,
    pub cpu_encode_threading: bool,
    pub debug_logging: bool,
    pub auto_adjust_screen_capture_size: bool,
    pub recording_socket: String,
    pub wayland_host_display: String,
    pub omit_stripe_headers: bool,
    pub acknowledge_references: bool,
    pub video_reference_frames: u32,
    pub video_cbr_mode: bool,
    pub video_bitrate_kbps: i32,
    pub video_vbv_multiplier: f64,
    pub video_link_kbps: i32,
    pub keyframe_interval_s: f64,
    pub video_min_qp: i32,
    pub video_max_qp: i32,
}

The full set of capture + encode parameters a consumer hands the backend.

A single value configures a capture session end to end: which display and backend, capture geometry and frame rate, the codec (striped JPEG or a full-frame video codec), the video quality and rate-control knobs, cursor and watermark options, the encode-device selection, and the optional recording socket. It derives PartialEq so the backend can detect when a live setting actually changed, and Clone so each capture pipeline can own its own copy. Default is the library’s own baseline; the Python CaptureSettings class carries the defaults selkies sessions start from.

Fields

display_id: u32

Wayland display key this capture binds to (0 = primary output); ignored on X11.

use_wayland: Option<bool>

Backend choice: Some(true) or Some(false) force Wayland or X11; None follows WAYLAND_DISPLAY (wants_wayland).

render_node_path: String

Compositor render node (Wayland): an explicit path wins; empty with auto_gpu set lets the library pick one; empty without falls back to the encoder node.

encode_node_path: String

The encoder’s render node by path, where the consumer names one beside encode_node_index; the Wayland backend takes it as the fallback render node.

auto_gpu: String

Auto-GPU request: empty for off, true for the first GPU, any other token for the first GPU whose kernel identity matches (vendor name, driver name, DT prefix, PCI id).

cursor_size: i32

Compositor cursor-theme size in pixels; <= 0 keeps the theme default (24).

width: i32

height: i32

scale: f64

capture_x: i32

capture_y: i32

target_fps: f64

jpeg_quality: i32

paint_over_jpeg_quality: i32

use_paint_over_quality: bool

paint_over_trigger_frames: u32

Still frames before a cleanup, counted at TRIGGER_FPS (paint_over_trigger).

damage_block_threshold: u32

damage_block_duration: u32

codec: Codec

video_crf: i32

video_paintover_crf: i32

video_paintover_burst_frames: i32

video_fullcolor: bool

video_bit_depth: i32

Bits per sample asked of the encoder, 8 or 10; a session that cannot carry 10 stays at 8 (encoders::session_bit_depth says which it runs).

video_streaming_mode: bool

capture_cursor: bool

cursor_size_cap: i32

Longest cursor edge the out-of-band cursor callback delivers; larger images are downscaled (<= 0 = uncapped). Compositing via capture_cursor is unaffected.

watermark_path: String

watermark_location_enum: i32

encode_node_index: i32

use_cpu: bool

cpu_encode_threading: bool

Whether a software session threads within a frame (session::encode_threads); off, each software encoder codes and converts on one thread, and JPEG its stripes one after another.

debug_logging: bool

auto_adjust_screen_capture_size: bool

recording_socket: String

wayland_host_display: String

Wayland display of an EXTERNAL compositor to capture (host-capture mode); empty composites own clients as usual.

omit_stripe_headers: bool

When true, encoders emit the raw payload without the per-stripe header byte block; stripe metadata is then carried only on the frame attributes.

acknowledge_references: bool

The consumer acknowledges the frames every client holds (acknowledge_reference), so an anchor predicts from a frame every client was sent, and where a session keeps two long-term references (H.265, and AV1, which keeps one otherwise) the newest every client holds stays pinned beside the one the schedule marks. H.264 keeps one.

video_reference_frames: u32

The most frames an H.264 or H.265 stream keeps for reference (its decoded picture buffer), 0 for as many as the level admits up to REFERENCE_FRAMES: a decoder that holds its whole buffer before it shows a picture (GStreamer’s hardware decoders in WebKitGTK and WPE) shows each that many frames later.

video_cbr_mode: bool

video_bitrate_kbps: i32

video_vbv_multiplier: f64

VBV size as a multiple of one frame’s bit budget (bitrate/framerate), so it rescales with live bitrate/fps changes. Under CBR, <= 0 selects the policy default: 1.5 on an infinite GOP, 3 when scheduled keyframes are enabled. Under CRF, a positive value caps the session at a peak of video_bitrate_kbps with this buffer, which a live bitrate change moves without a key frame (encoders::CAPPED_VBV_FRAMES), and <= 0 leaves it uncapped. Whether a session is capped is fixed when it opens.

video_link_kbps: i32

The rate the path a stream crosses carries, as its transport measures it, which a still screen’s constant-rate cleanup may run at (pipeline::cleanup_rate); 0 where none was said, which keeps the cleanup to the session’s rate. Live, through update_link_rate.

keyframe_interval_s: f64

Seconds between scheduled recovery keyframes; <= 0 keeps the GOP infinite (IDRs only on demand: client join / reset, recorder connect).

video_min_qp: i32

Rate-controlled (CBR) QP clamp: video_max_qp bounds the quality FLOOR (screen text stays legible under motion at the cost of overshooting impossible targets), video_min_qp bounds bit WASTE on easy content. 0 keeps the encoder’s own default, which for the software H.264 session is the paint-over quality while the screen moves and none while a still screen is cleaned up (encoders::software::encode_cpu); CRF/CQP modes pin their QP directly and ignore these.

video_max_qp: i32

Implementations

impl CaptureSettings

pub fn wants_wayland(&self) -> bool

Whether this capture goes through the Wayland backend: an explicit use_wayland wins (selkies forwards –wayland / SELKIES_WAYLAND there); left unset, capture goes through Wayland exactly when the session exposes a WAYLAND_DISPLAY.

pub fn cleans_up(&self) -> bool

Whether a still screen is cleaned up (pipeline::cleanup_due): a constant-rate video stream always, whose rate control alone stops short of a clean picture where the rate is low for the frame rate, to the paint-over quality (video_paintover_crf), the finest a still screen is refined to, as fast as its path carries; otherwise only with the paint-over on.

pub fn paint_over_trigger(&self) -> u32

paint_over_trigger_frames at the session’s frame rate: below TRIGGER_FPS the same time (2 frames of 15 at 8 fps), above it the same frames.

Trait Implementations

impl Clone for CaptureSettings

fn clone(&self) -> CaptureSettings

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CaptureSettings

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CaptureSettings

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for CaptureSettings

fn eq(&self, other: &CaptureSettings) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CaptureSettings