Struct HardwareEncodeCapability 

pub struct HardwareEncodeCapability {

    pub backend: HardwareEncodeBackend,
    pub encoder: &'static str,
    pub codec: NativeVideoCodec,
    pub gpu_input_only: bool,
    pub input_layout: EncoderInputLayout,
    pub handoff: EncoderInputHandoff,
    pub shares_renderer_device: bool,
    pub minimum: (u32, u32),
    pub maximum: (u32, u32),
    pub granularity: (u32, u32),
    pub max_p_picture_l0_references: Option<u32>,
    pub max_b_picture_l0_references: Option<u32>,
    pub max_l1_references: Option<u32>,
    pub rate_control_modes: Vec<&'static str>,
    pub plane_ring_slots: usize,
    pub handoff_retained_surfaces: usize,
    pub codec_retained_surfaces: usize,
}

What one hardware encoder accepts on this device, read from the device.

Fields

backend: HardwareEncodeBackend

The native API the session drives.

encoder: &'static str

The FFmpeg encoder a session opens.

codec: NativeVideoCodec

The codec it encodes.

gpu_input_only: bool

Whether the encoder takes GPU frames only. Pinning such an encoder is asking for this path; an encoder the readback path can also feed (h264_videotoolbox) can be pinned on either.

input_layout: EncoderInputLayout

The surface layout it takes.

handoff: EncoderInputHandoff

How a packed frame reaches its surface.

shares_renderer_device: bool

Whether the encoder runs on the renderer’s own device. A backend that would need a copy between devices is not offered as GPU-resident.

minimum: (u32, u32)

Smallest accepted coded width and height.

maximum: (u32, u32)

Largest accepted coded width and height.

granularity: (u32, u32)

Granularity the output size is aligned up to before the limits apply.

max_p_picture_l0_references: Option<u32>

References a P picture may use, when the device reports it.

max_b_picture_l0_references: Option<u32>

Forward references a B picture may use; zero together with max_l1_references means no B pictures. None when the device does not report it.

max_l1_references: Option<u32>

Backward references a B picture may use, when the device reports it.

rate_control_modes: Vec<&'static str>

The rate-control modes the device reports: cbr, vbr, disabled (a constant quantizer), and on D3D12 qvbr.

plane_ring_slots: usize

Plane-texture pairs the renderer packs into, allocated for the whole session whatever the pipeline depth. Zero when it packs into the surfaces themselves.

handoff_retained_surfaces: usize

Surfaces the handoff may still hold after the host has let go of them: a copying backend keeps each surface it copied into until its slot comes round again. They are allocated on top of the frames the host holds, so a budget has to count them.

codec_retained_surfaces: usize

Surfaces the encoder itself still holds after it has accepted them, until it has consumed them. Also allocated on top of the host’s.

Implementations

impl HardwareEncodeCapability

pub const fn retained_surfaces(&self) -> usize

Every surface the pool may hold beyond those the host has leased.

impl HardwareEncodeCapability

pub const fn coded(&self, width: u32, height: u32) -> (u32, u32)

The coded extent an output of this size is encoded at.

pub fn accepts(&self, width: u32, height: u32) -> Result<(), String>

Whether an output of this size can be encoded, and if not, why.

Errors

Names the limit the size misses.

Trait Implementations

impl Clone for HardwareEncodeCapability

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HardwareEncodeCapability

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for HardwareEncodeCapability

impl PartialEq for HardwareEncodeCapability

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for HardwareEncodeCapability