Struct BufferCollectionConstraints

pub struct BufferCollectionConstraints {
    pub usage: BufferUsage,
    pub min_buffer_count_for_camping: u32,
    pub min_buffer_count_for_dedicated_slack: u32,
    pub min_buffer_count_for_shared_slack: u32,
    pub min_buffer_count: u32,
    pub max_buffer_count: u32,
    pub has_buffer_memory_constraints: bool,
    pub buffer_memory_constraints: BufferMemoryConstraints,
    pub image_format_constraints_count: u32,
    pub image_format_constraints: [ImageFormatConstraints; 32],
}

Constraints on BufferCollection parameters. These constraints can be specified per-participant. The sysmem service implements aggregation of constraints from multiple participants.

This type is deprecated for new code, but is still used by some camera code.

Fields

usage: BufferUsage

The usage is only meant as a hint to help sysmem choose a more optimal PixelFormat or similar when multiple compatible options exist.

When aggregating BufferCollectionConstraints, these values bitwise-OR.

At least one usage bit must be specified unless the whole BufferCollectionConstraints is logically null due to !has_constraints.

min_buffer_count_for_camping: u32

Per-participant number of buffers that the participant may concurrently hold for its exclusive use for a non-transient period of time (camp on).

For example, a video decoder would specify (at least) the maximum number of reference frames + 1 frame currently being decoded into.

A participant must not camp on more buffers than specified here (except very transiently) else processing may get stuck.

When aggregating BufferCollectionConstraints, these values add.

In testing scenarios, camping on more buffers than this for any significant duration may (ideally will) be flagged as a failure. In testing scenarios, the participant may not be provided with more buffers than this concurrently.

min_buffer_count_for_dedicated_slack: u32

Per-participant minimum number of buffers that are needed for slack reasons, for better overlap of processing / better performance.

When aggregating BufferCollectionConstraints, these values add.

A participant should typically specify 0 or 1 here - typically 0 is appropriate if min_buffer_count_for_camping is already enough to keep the participant busy 100% of the time when the participant is slightly behind, while 1 can be appropriate if 1 more buffer than strictly needed for min-camping reasons gives enough slack to stay busy 100% of the time (when slightly behind, vs. lower % without the extra buffer).

In testing scenarios, this field may be forced to 0, and all participants are expected to continue to work without getting stuck. If a buffer is needed for forward progress reasons, that buffer should be accounted for in min_buffer_count_for_camping.

min_buffer_count_for_shared_slack: u32

Similar to min_buffer_count_for_dedicated_slack, except when aggregating these values max (instead of add). The value here is not shared with any participant’s min_buffer_count_for_dedicated_slack.

A participant can specify > 0 here if a participant would like to ensure there’s some slack overall, but doesn’t need that slack to be dedicated.

The choice whether to use min_buffer_count_for_dedicated_slack or min_buffer_count_for_shared_slack (or both) will typically be about the degree to which the extra slack improves performance.

In testing scenarios, this field may be forced to 0, and all participants are expected to continue to work without getting stuck. If a buffer is needed for forward progress reasons, that buffer should be accounted for in min_buffer_count_for_camping.

min_buffer_count: u32

A particularly-picky participant may unfortunately need to demand a tight range of buffer_count, or even a specific buffer_count. This field should remain 0 unless a participant really must set this field to constrain the overall BufferCollectionInfo_2.buffer_count. Any such participant should still fill out the min_buffer_count_for_* fields above.

max_buffer_count: u32

0 is treated as 0xFFFFFFFF.

has_buffer_memory_constraints: bool

Constraints on BufferCollectionSettings.buffer_settings.

A participant that intends to specify image_format_constraints_count > 1 will typically specify the minimum buffer size implicitly via image_format_constraints, and possibly specify only the max buffer size via buffer_memory_constraints.

buffer_memory_constraints: BufferMemoryConstraints

image_format_constraints_count: u32

Optional constraints on the image format parameters of an image stored in a buffer of the BufferCollection. This includes pixel format and image layout. These constraints are per-pixel-format, so more than one is permitted. Entries in the list must have unique pixel_formats.

When aggregating, only pixel formats that are specified by all participants with non-zero image_format_constraints_count (and non-Null) BufferCollectionConstraints) are retained.

image_format_constraints: [ImageFormatConstraints; 32]

Trait Implementations

impl Clone for BufferCollectionConstraints

fn clone(&self) -> BufferCollectionConstraints

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BufferCollectionConstraints

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

Formats the value using the given formatter.

impl<D: ResourceDialect> Decode<BufferCollectionConstraints, D> for BufferCollectionConstraints

fn new_empty() -> Self

Creates a valid instance of Self. The specific value does not matter, since it will be overwritten by decode.

unsafe fn decode( &mut self, decoder: &mut Decoder<'_, D>, offset: usize, _depth: Depth, ) -> Result<()>

Decodes an object of type T from the decoder’s buffers into self.

impl<D: ResourceDialect> Encode<BufferCollectionConstraints, D> for &BufferCollectionConstraints

unsafe fn encode( self, encoder: &mut Encoder<'_, D>, offset: usize, _depth: Depth, ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl<D: ResourceDialect, T0: Encode<BufferUsage, D>, T1: Encode<u32, D>, T2: Encode<u32, D>, T3: Encode<u32, D>, T4: Encode<u32, D>, T5: Encode<u32, D>, T6: Encode<bool, D>, T7: Encode<BufferMemoryConstraints, D>, T8: Encode<u32, D>, T9: Encode<Array<ImageFormatConstraints, 32>, D>> Encode<BufferCollectionConstraints, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

unsafe fn encode( self, encoder: &mut Encoder<'_, D>, offset: usize, depth: Depth, ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl Hash for BufferCollectionConstraints

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for BufferCollectionConstraints

fn cmp(&self, other: &BufferCollectionConstraints) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for BufferCollectionConstraints

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for BufferCollectionConstraints

fn partial_cmp(&self, other: &BufferCollectionConstraints) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TypeMarker for BufferCollectionConstraints

type Owned = BufferCollectionConstraints

The owned Rust type which this FIDL type decodes into.

fn inline_align(_context: Context) -> usize

Returns the minimum required alignment of the inline portion of the encoded object. It must be a (nonzero) power of two.

fn inline_size(_context: Context) -> usize

Returns the size of the inline portion of the encoded object, including padding for alignment. Must be a multiple of inline_align.

fn encode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and encoding requires no validation. When true, we can optimize encoding arrays and vectors of Self::Owned to a single memcpy.

fn decode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and decoding requires no validation. When true, we can optimize decoding arrays and vectors of Self::Owned to a single memcpy.

impl ValueTypeMarker for BufferCollectionConstraints

type Borrowed<'a> = &'a BufferCollectionConstraints

The Rust type to use for encoding. This is a particular Encode<Self> type cheaply obtainable from &Self::Owned. There are three cases:

fn borrow(value: &<Self as TypeMarker>::Owned) -> Self::Borrowed<'_>

Cheaply converts from &Self::Owned to Self::Borrowed.

impl Copy for BufferCollectionConstraints

impl Eq for BufferCollectionConstraints

impl Persistable for BufferCollectionConstraints

impl StructuralPartialEq for BufferCollectionConstraints