Struct VaapiEncoder 

pub struct VaapiEncoder { /* private fields */ }

One VA-API encoder session, hardware, for one capture.

Implementations

impl VaapiEncoder

pub fn new( settings: &RustCaptureSettings, codec: Codec, input: Input, ) -> Result<Self, String>

Stand up a session for codec on the render node the settings select, fed through input, with the libva of this process.

impl VaapiEncoder

pub fn codec(&self) -> Codec

pub fn is_fullcolor(&self) -> bool

Whether this session negotiated 4:4:4 chroma.

pub fn bit_depth(&self) -> u32

The bits per sample the session opened at.

pub fn surface_format_name(&self) -> String

The name of the surface format frames reach the codec in, for the session log.

pub fn is_full_range(&self) -> bool

A hardware session converts at limited range.

pub fn vendor(&self) -> &str

The driver behind the session, as libva names it.

pub fn low_power(&self) -> bool

Whether the codec runs on the low-power entry point.

pub fn last_reference(&self) -> Reference

The frame the last encoded frame predicted from.

pub fn take_report(&mut self, report: ReferenceReport) -> bool

Apply what the consumers say of a frame: a loss as invalidate_reference, a frame every one of them holds or was sent (ReferenceWindow::acknowledge, ReferenceSlots::acknowledge).

pub fn invalidate_reference(&mut self, frame_id: u16) -> bool

Leave frame frame_id and every frame after it out of the predictions. False where the session tracks none, and the caller codes a key frame instead.

pub fn reconfigure_rate( &mut self, settings: &RustCaptureSettings, ) -> Result<(), String>

Take a rate or frame-rate change: the next frame opens a sequence with the new rate control, as a key frame.

pub fn is_cbr(&self) -> bool

Whether the session runs a constant rate.

pub fn last_size(&self) -> Option<usize>

The bytes of the last frame coded, the driver’s padding aside: what tells a constant-rate cleanup the rate control has nothing left to refine.

pub fn last_quality(&self) -> Option<u32>

The quality index the rate control last coded a frame at: for H.264 and HEVC where the driver reports a picture’s average quantizer with its coded buffer (iHD does), for AV1 and VP9 the base_q_idx it wrote into the frame header. A picture that is mostly skipped blocks reports near the quantizer its slices open at, so the figure is trusted for having reached a quality, never for the lack of it.

pub fn measures(&self) -> bool

Whether measure yields a measurement: until a surface turns out unreadable, as the reconstruction of iHD’s packed 4:4:4 does, kept at another geometry than its source.

pub fn measure(&mut self)

Measure the next frame’s reconstruction against its source (last_psnr).

pub fn last_psnr(&self) -> Option<f32>

The luma PSNR, in dB, of the last frame measured: its reconstruction against the converted picture it was coded from, both read back on every PSNR_ROW_STEPth row. What tells a constant-rate cleanup whether the driver’s rate control is still refining a still screen, whatever the driver says of its quantizer; None where a surface cannot be read as the picture’s rows.

pub fn hold_quantizer(&mut self, crf: u32)

Encode the next frame at the quantizer the quality index crf selects, and leave the session’s own quantizer for the frame after: the cleanup of a still screen, at a constant quantizer. A constant-rate session codes the frame under its rate control: radeonsi drops per-frame quantizer bounds (a key frame held by them came out starved in the session’s small buffer, 26 dB), and a key frame given a budget of its own through a restarted rate control came out coarser than the picture the driver’s rate control refines a still screen to by itself (51 against 61 dB at 8 Mbit/s), so FrameEncoder::holds_quantizer says no there.

pub fn encode_host( &mut self, pixels: &[u8], stride: usize, rgba: bool, frame_number: u64, crf: u32, force_idr: bool, ) -> Result<Vec<u8>, String>

Encode one packed host frame (stride bytes per row, in the byte order the session was built for) at the quality index crf: uploaded straight from the caller’s rows onto the host surface and converted on the GPU.

pub fn encode_dmabuf( &mut self, dmabuf: &Dmabuf, frame_number: u64, crf: u32, force_idr: bool, ) -> Result<Vec<u8>, String>

Encode one Wayland DRM-PRIME dmabuf: imported as a VA surface in place for the frame and converted on the GPU.

Trait Implementations

impl Drop for VaapiEncoder

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.

impl Send for VaapiEncoder