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,
    pub default_channel_depth: 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 selects this path; one 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. Backends needing a cross-device copy are 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 with max_l1_references zero means no B pictures. None when not reported.

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 (constant quantizer), and on D3D12 qvbr.

plane_ring_slots: usize

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

handoff_retained_surfaces: usize

Surfaces the handoff may still hold after the host released them (a copying backend keeps each until its slot comes round). Allocated on top of the host’s, so budgets count them.

codec_retained_surfaces: usize

Surfaces the encoder holds after accepting them, until consumed. Also on top of the host’s.

default_channel_depth: usize

The default encode channel depth (ALPHA2_ENCODE_QUEUE_DEPTH overrides): the smallest depth within 3 % of the best measured per-frame time on this backend.

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