Struct RustCaptureSettings 

pub struct RustCaptureSettings {

    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_fullframe: bool,
    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 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 keyframe_interval_s: f64,
    pub video_min_qp: i32,
    pub video_max_qp: i32,
}

The full set of capture + encode parameters the Python layer hands to the Rust backend.

A single value configures a capture session end to end: capture geometry and frame rate, the codec (striped JPEG, striped or full-frame H.264, 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.

Fields

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

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_fullframe: bool

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

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 software x264 session at a peak of video_bitrate_kbps with this buffer, and <= 0 leaves it uncapped.

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; CRF/CQP modes pin their QP directly and ignore these.

video_max_qp: i32

Trait Implementations

impl Clone for RustCaptureSettings

fn clone(&self) -> RustCaptureSettings

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RustCaptureSettings

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

Formats the value using the given formatter.

impl Default for RustCaptureSettings

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for RustCaptureSettings

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RustCaptureSettings