Struct XScreen 

struct XScreen {
    conn: RustConnection,
    root: Window,
    depth: u8,
    byte_order: ImageOrder,
    gc: Gcontext,
    damage: RootDamage,
    rgb_format: Pictformat,
    argb_format: Pictformat,
    modifiers: Vec<u64>,
    explicit: bool,
    device: String,
    semaphore_opcode: Option<u8>,
}

The X side of the capture: the private connection and the server objects the blit needs.

Fields

conn: RustConnection

root: Window

depth: u8

byte_order: ImageOrder

gc: Gcontext

damage: RootDamage

The server’s report that the root changed, which both ends a frame’s wait early and says whether to encode one at all: nothing here reads pixels, so there is no content hash to stand in for it.

rgb_format: Pictformat

The Render format of the screen’s depth, for the destination pictures.

argb_format: Pictformat

The Render format of a premultiplied ARGB cursor image.

modifiers: Vec<u64>

What the server accepts for buffers of the screen’s depth; empty leaves the driver’s choice and the server learns the layout from the modifier the allocation reports.

explicit: bool

Whether the server takes a buffer with its modifier (DRI3 1.2). A DRI3 1.0 server (the NVIDIA X driver before 595) learns no layout with a buffer, so the pool is linear there and each buffer goes over with its stride alone (PixmapFromBuffer).

device: String

semaphore_opcode: Option<u8>

SELKIES-SEMAPHORE’s major opcode, where the server offers it.

Implementations

impl XScreen

fn open(node: i32) -> Result<(Self, OwnedFd), String>

Connect and negotiate everything the blit needs, or say what the server lacks.

fn semaphore_request( &self, minor: u8, fields: &[u32], fds: Vec<OwnedFd>, ) -> Result<VoidCookie<'_, RustConnection>, String>

One SELKIES-SEMAPHORE request: its minor opcode and CARD32 fields, and an fd if it takes one.

fn import_semaphore(&self, fd: OwnedFd) -> Result<u32, String>

Hand the server a semaphore to signal after the blits it is asked to (signal_semaphore), returning its id there.

fn signal_semaphore(&self, id: u32) -> Result<(), String>

Have the server signal the semaphore once the rendering requested before has landed. The check’s round trip answers once the server has queued the signal, which is what the encoder’s wait has to come after; an error means no signal is coming.

fn free_semaphore(&self, id: u32)

fn await_blit(&self, pixmap: Pixmap) -> Result<(), String>

Wait for the blit into pixmap to land: the reply to a read of one of its pixels comes back only after the server’s GPU work ordered before it has completed.

fn upload_sprite( &self, argb: &[u32], width: u16, height: u16, ) -> Result<Sprite, String>

Hand the server an ARGB image as a pixmap it can composite from. argb is one premultiplied 0xAARRGGBB word per pixel, which is what Render’s OVER expects.

fn free_sprite(&self, s: &Sprite)

fn free_buffer(&self, b: &GpuBuffer)

fn free_cursor(&self, c: &CursorSprite)