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 output_mode: i32,
    pub video_crf: i32,
    pub video_paintover_crf: i32,
    pub video_paintover_burst_frames: i32,
    pub video_fullcolor: bool,
    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 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 output mode (striped JPEG/x264 vs full-frame H.264), the H.264 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

output_mode: i32

video_crf: i32

video_paintover_crf: i32

video_paintover_burst_frames: i32

video_fullcolor: bool

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.

video_cbr_mode: bool

video_bitrate_kbps: i32

video_vbv_multiplier: f64

CBR VBV/HRD size as a multiple of one frame’s bit budget (bitrate/framerate), so it rescales with live bitrate/fps changes. <= 0 selects the policy default: 1.5 on an infinite GOP, 3 when scheduled keyframes are enabled.

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RustCaptureSettings