Struct NvfbcSession 

struct NvfbcSession {
    _lib: Library,
    funcs: NVFBC_API_FUNCTION_LIST,
    handle: u64,
    capture_open: bool,
    region: NVFBC_BOX,
    size: NVFBC_SIZE,
    with_cursor: bool,
}

A live NvFBC capture: the loaded library, the driver’s function table, the client handle, and the capture session bound to it.

The handle owns an OpenGL and a CUDA context that the driver binds to the thread that created it, and the captured device pointer belongs to whichever CUDA context was current at setup — which is why the whole object is built, used, and dropped on one thread, with NVENC’s own primary context pushed current. Sharing that context is what makes the capture zero-copy: the pointer the driver hands back is one NVENC can register directly.

Fields

_lib: Library

funcs: NVFBC_API_FUNCTION_LIST

handle: u64

capture_open: bool

region: NVFBC_BOX

The region of the framebuffer being captured, and the frame size it is delivered at.

size: NVFBC_SIZE

with_cursor: bool

Implementations

impl NvfbcSession

fn load() -> Result<(Library, NVFBC_API_FUNCTION_LIST), String>

Load libnvidia-fbc.so.1 and fill the driver’s function table, erroring when the library is absent (no NVIDIA driver, or a container without the video capability) or too old to answer for this API version.

fn last_error(&self) -> String

The driver’s message for the last failure on this handle, for a log line that says what went wrong rather than only that something did.

fn fail(&self, what: &str, status: u32) -> NvfbcError

Turn a driver status into an error carrying both the code and the driver’s own message.

fn open() -> Result<Self, String>

Open a client handle on the X server named by the environment, letting NvFBC create and manage the OpenGL context it captures through.

The server is asked for NVIDIA_GLX first, over a connection of our own: it is what the library looks up here too, and where it is missing the library’s own lookup is the call that never returns.

The handle is bound to the calling thread, and every later call has to come from it.

fn status(&self) -> Result<NVFBC_GET_STATUS_PARAMS, NvfbcError>

Ask the driver whether capture is possible here and how large the framebuffer is.

fn start( &mut self, region: NVFBC_BOX, size: NVFBC_SIZE, with_cursor: bool, ) -> Result<(), NvfbcError>

Start capturing region of the framebuffer into video memory, delivered at size.

The session is programmed for latency rather than for throughput smoothing: push model, so the driver generates a frame when an application damages the screen instead of polling on a timer; direct capture allowed, so a fullscreen unoccluded application presents into the capture buffer without going through the X server (which the driver takes up only when the cursor is not composited); and the native BGRA format, which needs no conversion pass and so no extra copy. Modeset recovery is left to the driver, which rebuilds the session and resumes on its own.

fn stop(&mut self)

End the capture session, leaving the handle open for another start.

fn grab(&mut self, timeout: Duration) -> Result<GrabbedFrame, NvfbcError>

Take the next frame, waiting at most timeout for the driver to produce one.

A frame the client has not seen yet is returned without waiting at all; otherwise the call blocks until one is rendered or the timeout expires, and then returns the frame already in the buffer with is_new false. Nothing is copied either way: the device pointer addresses the driver’s own capture buffer, which stays valid until the next grab.

fn grab_with( &mut self, flags: u32, timeout: Duration, ) -> Result<GrabbedFrame, NvfbcError>

The grab above, with the driver’s wait behavior named explicitly.

Trait Implementations

impl Drop for NvfbcSession

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.