Struct StripeState 

pub struct StripeState {

    pub no_motion_frame_count: u32,
    pub paint_over_sent: bool,
    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 packet_buf: Vec<u8>,
    pub last_hash: u64,
    pub consecutive_changes: u32,
    pub in_damage_block: bool,
    pub damage_block_frames_remaining: i32,
    pub hash_at_block_start: u64,
}

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.
• Paint-over / recovery: no_motion_frame_count counts consecutive static frames, paint_over_sent guards against re-sending a high-quality repaint of a still region, and h264_burst_frames_remaining tracks a post-repaint or recovery streaming burst.
• 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 / hash_at_block_start drive the sustained-motion damage block managed by content_dirty.

Fields

no_motion_frame_count: u32

paint_over_sent: bool

h264_encoder: Option<H264EncoderWrapper>

h264_burst_frames_remaining: i32

y_buf: Vec<u8>

u_buf: Vec<u8>

v_buf: Vec<u8>

packet_buf: Vec<u8>

last_hash: u64

consecutive_changes: u32

in_damage_block: bool

damage_block_frames_remaining: i32

hash_at_block_start: u64

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 once, at the end, 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. Only when the counter reaches zero is the stripe re-hashed — if it differs from the hash captured at block start the block is renewed for another duration frames, otherwise the block exits and the change counter resets. 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).

Trait Implementations

impl Default for StripeState

fn default() -> StripeState

Returns the “default value” for a type.