Struct GpuCapture 

struct GpuCapture {

    encoder: Option<FrameEncoder>,
    buffers: Vec<GpuBuffer>,
    cursor: Option<CursorSprite>,
    cursor_drawn: Option<Rectangle<i32, Physical>>,
    overlay: OverlayState,
    watermark: Option<Sprite>,
    x: XScreen,
    gbm: Device<File>,
    _egl: Option<EGLDisplay>,
    egl_display: *const c_void,
    next: usize,
    settings: CaptureSettings,
    request: CaptureSettings,
    cap_x: i16,
    cap_y: i16,
    root_w: u16,
    root_h: u16,
    blit_semaphore: Option<u32>,
}

A running zero-copy capture, on the thread that owns every context in it.

Field order is drop order: the encoder releases its imports before the buffers they describe go, and both go before the GBM device and EGL display they were made on.

Fields

encoder: Option<FrameEncoder>

None only while a rebuild is replacing the session; a rebuild that fails ends the capture before another frame is encoded.

buffers: Vec<GpuBuffer>

cursor: Option<CursorSprite>

cursor_drawn: Option<Rectangle<i32, Physical>>

Where the last grab drew the cursor, in the frame’s coordinates.

overlay: OverlayState

The watermark image and where it sits, and the pixmap the server composites it from. Held rather than blended into host pixels, which is what keeps this path zero-copy.

watermark: Option<Sprite>

x: XScreen

gbm: Device<File>

_egl: Option<EGLDisplay>

egl_display: *const c_void

next: usize

settings: CaptureSettings

The live session: its geometry is what is captured and encoded, and its rate and quality fields follow the cross-thread controls.

request: CaptureSettings

The geometry that was asked for, which a region change updates and every region is resolved from, kept apart from settings so a capture following the root keeps following.

cap_x: i16

cap_y: i16

root_w: u16

root_h: u16

blit_semaphore: Option<u32>

The server’s id for the encoder’s blit semaphore, which it signals after each blit for the encode to wait on; None waits for each blit with a GetImage.

Implementations

impl GpuCapture

fn alloc_bo(&mut self, w: u16, h: u16) -> Result<BufferObject<()>, String>

One buffer of the pool: a single-plane allocation the server and the encoder both describe with one fd, stride, and offset. A modifier that spreads the buffer over auxiliary planes (a compressed layout) is dropped from the server’s list and the allocation retried, down to the driver’s own choice.

fn alloc_buffers(&mut self, w: u16, h: u16) -> Result<(), String>

Allocate the buffer pool at w x h and hand each buffer to the server as a pixmap.

fn free_buffers(&mut self)

fn reshape(&mut self, w: u16, h: u16) -> Result<(), String>

Bring the pool and the encoder to a new capture size. NVENC follows in place; a session that cannot is rebuilt through the same ladder that chose it.

fn enc(&mut self) -> &mut FrameEncoder

fn backend(&self) -> &'static str

The encoder’s name for the logs.

fn rebuild_encoder(&mut self) -> Result<(), String>

Replace the encoder with the startup construction, releasing the old session first so the two never hold device memory at once.

fn attach_semaphore(&mut self)

Give the server the encoder’s blit semaphore, where it offers SELKIES-SEMAPHORE and the encoder can wait on one; otherwise each blit is waited for with a GetImage.

fn detach_semaphore(&mut self)

fn pointer(&self) -> Option<(i16, i16)>

Where the pointer is on the root, or None where the server does not answer.

fn grab(&mut self, with_cursor: bool) -> Result<(usize, bool), String>

Blit the capture region into the next pool buffer, composite the cursor if asked, and either have the server signal the blit semaphore after it or wait for it to land. Returns the buffer to encode and whether its encode has to wait on the semaphore.

fn composite_watermark(&mut self, idx: usize) -> Result<(), String>

Draw the watermark over the freshly blitted frame, on the GPU. The image is uploaded on its first frame and composited by the server after that, so the CPU never sees the pixels it is drawn on; an animated location only moves where it is composited.

fn composite_cursor(&mut self, idx: usize) -> Result<(), String>

Draw the XFixes cursor over the freshly blitted frame, uploading its image only when the cursor changed. The server paints it through Render, on the GPU.

Trait Implementations

impl Drop for GpuCapture

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.