Struct FramebufferGrab 

pub(crate) struct FramebufferGrab {
    pub fb: SharedFramebuffer,
    pending: Vec<Vec<u64>>,
    drawn: Vec<u64>,
    carry: Vec<u64>,
}

The capture’s watch, the tiles each pool surface is missing (module docblock), and those drawn since the last frame said where it changed (changed).

A frame’s change is the tiles its read took from the watch: a read takes them before it copies, and again before each copy it repeats, so every tile it took is in the surface. A tile the server draws after the read is left in the watch for the frame that will hold it, since a change named with a frame that does not hold it is never named with the one that does, and an encoder told the tile held still then keeps the stale picture until the tile is drawn again. A surface grabbed through XShm instead (Self::grabbed) takes the watch after the server answered, so a tile drawn in between is named with that frame and the next, which is the first that holds it.

Fields

fb: SharedFramebuffer

pending: Vec<Vec<u64>>

drawn: Vec<u64>

carry: Vec<u64>

The tiles the last XShm grab took, named again with the frame after it.

Implementations

impl FramebufferGrab

pub(crate) fn new(fb: SharedFramebuffer, surfaces: usize) -> Self

A grab for surfaces pool surfaces, each missing the whole screen.

fn take(&mut self)

Take the tiles drawn since the last take into every surface’s and into drawn.

pub(crate) fn changed( &mut self, (x, y, width, height): (u32, u32, u32, u32), ) -> Vec<Rectangle<i32, Physical>>

Where the frame just read differs from the one before, within the region at (x, y) of width x height, in its coordinates: a rectangle a run of tiles along a row of them. The tiles are those the reads since the last call took (the type’s docblock), so this is called once after each frame’s read.

pub(crate) fn invalidate(&mut self)

Mark the whole screen missing from every surface and drawn since the last frame (a region moved, the surfaces were recreated): the next frame differs from the one before wherever it lies, which no drawing reported.

pub(crate) fn overlaid( &mut self, idx: usize, x: i32, y: i32, width: i32, height: i32, )

Mark the area at (x, y), width x height, in screen coordinates, missing from surface idx: an overlay drawn onto it.

pub(crate) fn read( &mut self, idx: usize, dst: &mut [u8], dst_stride: usize, region: (u32, u32, u32, u32), ) -> bool

Bring surface idx (dst, dst_stride bytes a row) up to the screen over the region at (x, y) of width x height: false where no whole read came in READ_ATTEMPTS, or the region runs past the framebuffer (a resize the capture has not followed yet), the surface left to an XShm grab, which Self::grabbed then records.

pub(crate) fn convert( &mut self, idx: usize, planes: &mut Nv12Planes, region: (u32, u32, u32, u32), bands: usize, ) -> bool

Self::read into the planes of surface idx (planes) instead of its pixels: the tiles it misses converted from the screen under the same drawing count, false where no whole conversion came in READ_ATTEMPTS or the region is not one the planes can hold (an odd edge, planes of another size, past the framebuffer, or a last row that starts inside it and so ends short of a whole stride).

pub(crate) fn grabbed(&mut self, idx: usize)

Surface idx was grabbed whole through XShm: it misses nothing drawn before the server answered. The tiles taken here may have been drawn after that answer, so they stay missing from the surface and are named with the next frame as well (carry).