Struct WlFramePool 

pub struct WlFramePool<B = Vec<u8>> {
    pub(crate) inner: Mutex<WlPoolInner<B>>,
    pub(crate) cv: Condvar,
    pub(crate) stop: AtomicBool,
}

Render->encode handoff for the Wayland readback paths, mirroring the X11 FramePool’s single-slot non-dropping design with one deliberate difference: the calloop thread is also the compositor + input dispatcher, so it must NEVER block on the pool. try_begin hands out a buffer only while the publish slot is empty, so publish cannot block, and a saturated encoder throttles capture by SKIPPING ticks (compositor damage accumulates via buffer age, so nothing is lost). Every published frame is encoded, in order: the H.264 reference chain stays contiguous exactly as on X11.

The zero-copy session runs the same split on GPU buffers: the calloop composites into one of the pool’s render targets and publishes it, and the encode thread encodes it in place, so the compositor thread is free again as soon as the composite is.

Fields

inner: Mutex<WlPoolInner<B>>

cv: Condvar

stop: AtomicBool

Implementations

impl WlFramePool<Vec<u8>>

pub(crate) fn new(n: usize, buf_len: usize) -> Self

Pre-allocate all n capture buffers up front (each buf_len bytes, all initially free) so the steady-state render/encode loop hands buffers around without ever allocating on the hot path.

impl<B> WlFramePool<B>

pub(crate) fn of(buffers: Vec<B>) -> Self

A pool of the buffers given, all initially free, numbered in order.

pub(crate) fn try_begin(&self) -> Option<(usize, B)>

Calloop: reserve a buffer for the next render/readback, NON-blocking. None means the encoder is still behind (slot full or every buffer in flight) – skip this tick. Because the calloop is the only producer, a successful reservation guarantees the following publish finds the slot empty (the consumer only ever drains it).

pub(crate) fn publish(&self, frame: WlFrame<B>)

Calloop: hand the filled buffer to the encode thread. Never blocks (see try_begin).

pub(crate) fn cancel(&self, id: usize, buf: B)

Calloop: return an unused reservation (render failed, readback skipped).

pub(crate) fn take(&self) -> Option<WlFrame<B>>

Encode: block until a frame is published (Some) or the pool shuts down (None). The wait is bounded, re-checking stop as defense-in-depth against a lost wakeup.

pub(crate) fn recycle(&self, id: usize, buf: B)

Encode: return an encoded frame’s buffer so the calloop can capture into it again. No notify: the only waiter (take) waits on the slot, and try_begin never blocks.

pub(crate) fn shutdown(&self)

Store stop under the lock so take() can’t check stop==false and then park after the notify already fired (lost wakeup); notify after unlocking.