Struct StripeState 

pub struct StripeState {

    pub no_motion_frame_count: u32,
    pub paint_over_sent: bool,
    pub dirty_run: u32,
    pub change_mass: f32,
    pub unclean_frames: u32,
    pub motion: f32,
    pub burst_held: bool,
    pub clean_quality: bool,
    pub rc_bytes: usize,
    pub idle_frames: u32,
    pub over_frames: u32,
    pub same_frames: u32,
    pub finest: Option<u32>,
    pub finest_frames: u32,
    pub settled: bool,
    pub fine_frames: u32,
    pub measured: Option<f32>,
    pub measuring: bool,
    pub level_checks: u32,
    pub measure_in: u32,
    pub sweep: Option<(f64, f64)>,
    pub sweep_frames: u32,
    pub sweep_coarser: u32,
    pub h264_encoder: Option<H264EncoderWrapper>,
    pub h264_burst_frames_remaining: i32,
    pub y_buf: Vec<u8>,
    pub u_buf: Vec<u8>,
    pub v_buf: Vec<u8>,
    pub yuv16: [Vec<u16>; 3],
    pub packet_buf: Vec<u8>,
    pub last_hash: u64,
    pub consecutive_changes: u32,
    pub in_damage_block: bool,
    pub damage_block_frames_remaining: i32,
}

Everything one horizontal stripe must remember between frames: its reused buffers, its own live encoder, and the motion / paint-over / damage bookkeeping that drives its send decision.

The frame is striped so independent screen regions can encode in parallel and an unchanged region can be skipped on its own, and that only works if each stripe carries its own cross-frame history. So one instance lives per stripe for the whole session and nothing per-stripe is rebuilt or recomputed from scratch each frame:

• Reused buffers: y_buf / u_buf / v_buf hold the stripe’s YUV planes and packet_buf the encoded output, grown in place rather than reallocated per frame.
• Encoder: h264_encoder is the stripe’s software H.264 instance — libx264 in a gpl build, OpenH264 otherwise — reused until its geometry (or, for x264, chroma format) changes.
• Cleanup / recovery: no_motion_frame_count counts consecutive static frames, paint_over_sent records that the region was cleaned up since it last changed, h264_burst_frames_remaining tracks a post-cleanup or recovery streaming burst (held at the paint-over quantizer where burst_held), and dirty_run, change_mass, unclean_frames, and motion (the share of recent frames in motion) are what pipeline::cleanup_due weighs to pick the cleanup’s moment and kind; clean_quality keeps a constant-quality session at the paint-over quality from a cleanup until the region changes again; rc_bytes (the bytes of the stripe’s last frame under its rate control), idle_frames (a constant-rate cleanup’s run of small frames short of the paint-over quality, of empty ones for x264), same_frames (of frames the size of the one before), finest and finest_frames (the finest quality index its rate control has coded at and the frames since), and over_frames (its run of frames over pipeline::OVERSHOOT_BUDGETS) tell a cleanup that runs through the rate control when it has converged, stalled, or been pinned at its coarsest quantizer, fine_frames counts its run of frames at the paint-over quantizer or finer, measured, measuring, level_checks, and measure_in are the last measurement of the picture it is refining, whether the frame before was measured, the measurements in a row that found it level, and the frames to the next (pipeline::plateau), settled records that such a cleanup ran its course under a rate control it cannot hold a quantizer under, so no other starts before the region moves, and sweep (the next band’s start and the last band’s size, as shares of the picture) carries the band sweep a full-frame refresh falls back to (pipeline::decide_hw_fullframe), sweep_frames its bands so far and sweep_coarser the steps they are coded coarser than the refresh.
• Content-hash damage (only for sources without external damage, i.e. X11): last_hash is the previous frame’s content hash, consecutive_changes counts changed frames toward the damage-block threshold, and in_damage_block / damage_block_frames_remaining drive the sustained-motion damage block managed by content_dirty.

Fields

no_motion_frame_count: u32

paint_over_sent: bool

dirty_run: u32

change_mass: f32

unclean_frames: u32

motion: f32

burst_held: bool

clean_quality: bool

rc_bytes: usize

idle_frames: u32

over_frames: u32

same_frames: u32

finest: Option<u32>

finest_frames: u32

settled: bool

fine_frames: u32

measured: Option<f32>

measuring: bool

level_checks: u32

measure_in: u32

sweep: Option<(f64, f64)>

sweep_frames: u32

sweep_coarser: u32

h264_encoder: Option<H264EncoderWrapper>

h264_burst_frames_remaining: i32

y_buf: Vec<u8>

u_buf: Vec<u8>

v_buf: Vec<u8>

yuv16: [Vec<u16>; 3]

The planes of a 10-bit stripe, as 16-bit samples.

packet_buf: Vec<u8>

last_hash: u64

consecutive_changes: u32

in_damage_block: bool

damage_block_frames_remaining: i32

Implementations

impl StripeState

pub fn content_dirty( &mut self, bytes: &[u8], threshold: u32, duration: i32, ) -> bool

Stand in for the compositor damage that X11 capture does not provide: hash this stripe to decide whether it changed since last frame, and once it is clearly in motion, stop re-hashing it every frame by committing to a sustained-motion “damage block”.

The hash is not free, and a region that changes every frame would otherwise be re-hashed forever while always reporting dirty anyway. So after threshold consecutive changes the stripe enters a damage block that just reports dirty for duration frames and re-hashes only on its last two frames, to decide whether to extend the block or let it lapse — trading a little extra sending for far fewer hashes on exactly the regions that need them least:

1. Inside a damage block: the stripe is treated as dirty without re-hashing, and the block’s remaining-frame counter is decremented. The stripe is hashed on the block’s last two frames: if they differ the region is still moving and the block is renewed for another duration frames, otherwise the block exits and the change counter resets, so motion that stopped inside a block is read as stopped when that block ends, not a block later. This keeps a continuously-moving region streaming for duration frames per re-check rather than hashing every frame.
2. Outside a block: the stripe is hashed and compared to the previous frame. A change increments consecutive_changes, and reaching threshold consecutive changes opens a new damage block; an unchanged frame resets the counter to zero.

Returns true whenever the stripe is considered dirty (always true while inside a block).

pub fn hash_dirty(&mut self, hash: u64, threshold: u32, duration: i32) -> bool

content_dirty for a stripe hashed elsewhere (on the GPU, where the frame was uploaded): the same state, read off hash.

Trait Implementations

impl Default for StripeState

fn default() -> StripeState

Returns the “default value” for a type.