Struct SharedFramebuffer 

pub(crate) struct SharedFramebuffer {
    opcode: u8,
    id: u32,
    framebuffer: Mapping,
    watch: Mapping,
    event: OwnedFd,
    pub width: u32,
    pub height: u32,
    stride: usize,
    pixel_offset: usize,
    tile: u32,
    tiles_x: u32,
    tiles_y: u32,
}

A watch on the framebuffer of the screen of one root window (module docblock).

Fields

opcode: u8

id: u32

framebuffer: Mapping

watch: Mapping

event: OwnedFd

width: u32

height: u32

stride: usize

pixel_offset: usize

tile: u32

tiles_x: u32

tiles_y: u32

Implementations

impl SharedFramebuffer

pub(crate) fn open(conn: &RustConnection, root: u32) -> Opened

Watch the framebuffer of root’s screen, where the server offers one of 32 bits a pixel.

fn watch(conn: &RustConnection, opcode: u8, root: u32) -> Result<Self, String>

pub(crate) fn close(self, conn: &RustConnection)

End the watch on the server; the mappings go with self.

pub(crate) fn retired(&self) -> bool

Whether the screen has moved to another framebuffer (a resize): the watch is over.

fn words(&self) -> usize

The words of the tile bitmap.

pub(crate) fn drawn(&self) -> bool

Whether any tile was drawn into since the bitmap was last taken.

fn take(&self, into: impl FnMut(usize, u64))

Take the tiles drawn since the last take, handing each nonzero word of the bitmap to into with its index.

pub(crate) fn wait(&self, timeout: Duration) -> bool

Wait at most timeout for a drawing operation to end on a tile not yet taken, or for the framebuffer to retire: true where one did, or already had.

fn settled_seq(&self) -> Option<u64>

The drawing count once no operation runs, or None past DRAW_WAIT.

fn copy_tiles( &self, pending: &[u64], dst: &mut [u8], dst_stride: usize, (x, y, width, height): (u32, u32, u32, u32), )

Copy the tiles pending marks within the region at (x, y) of width x height into dst (dst_stride bytes a row, the region’s top-left at its start). Each row of tiles lands in rows of dst of its own, so a change past PARALLEL_BYTES copies its rows of tiles on COPY_THREADS threads: one thread copying a whole 2560x1600 screen took 1.2 to 6.7 ms, reading what the server had just drawn from another core’s cache, which held a full-screen change back behind an XShm grab, the server’s copy from its own.

fn convert_tiles( &self, pending: &[u64], planes: &mut Nv12Planes, (x, y, width, height): (u32, u32, u32, u32), bands: usize, ) -> bool

Convert the rows of tiles pending marks within the region at (x, y) of width x height to 8-bit 4:2:0 BT.709 limited range in planes (the region’s top-left at their first pixel), as the NV12 x264 encodes in place, across the region’s whole width for each run of such rows, split into bands of rows converted in parallel as the encode thread’s own conversion is: the conversion reads the screen where the server keeps it, in place of copying it out first. False where the conversion refused the geometry.