Struct SupportedEncodings 

pub struct SupportedEncodings {
    pub decoded_channel_sets: Option<Vec<ChannelSet>>,
    pub decoded_frame_rates: Option<Vec<u32>>,
    pub min_encoding_bitrate: Option<u32>,
    pub max_encoding_bitrate: Option<u32>,
    pub encoding_types: Option<Vec<EncodingType>>,
    /* private fields */
}

Supported formats for encoded audio.

This table defines a valid set of configurations. All fields are independent, which implies a cross-product: any listed channel_set is supported at any listed frame_rate for any listed encoded_type.

If a device supports multiple encoders with different rate/channel constraints (e.g. AAC supports 48kHz but SBC only supports 44.1kHz), the device must report them as separate entries in the SupportedFormats vector.

Fields

decoded_channel_sets: Option<Vec<ChannelSet>>

Vector of possible ChannelSets supported. A ChannelSet specifies a channel configuration (including a channel-count), plus a number of optional attributes.

Each entry in this vector must describe a unique channel count. For example, this vector cannot contain two different ChannelSet entries that both apply to a 2-channel configuration.

Required.

decoded_frame_rates: Option<Vec<u32>>

Vector of possible frame rates supported. If present, must contain at least one value. Values must be listed in ascending order.

Optional.

min_encoding_bitrate: Option<u32>

The minimum encoding bitrate of the stream in bits per second. Cannot exceed ‘max_encoding_bitrate’, if both are present.

Optional.

max_encoding_bitrate: Option<u32>

The maximum encoding bitrate of the stream in bits per second. Cannot be less than ‘min_encoding_bitrate’, if both are present.

Optional.

encoding_types: Option<Vec<EncodingType>>

The encoder types that support the configurations listed above. Must contain at least one value. Values in this vector must be unique.

Required.

Trait Implementations

impl Clone for SupportedEncodings

fn clone(&self) -> SupportedEncodings

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SupportedEncodings

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

Formats the value using the given formatter.

impl<D> Decode<SupportedEncodings, D> for SupportedEncodings

where D: ResourceDialect,

fn new_empty() -> SupportedEncodings

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<(), Error>

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

impl Default for SupportedEncodings

fn default() -> SupportedEncodings

Returns the “default value” for a type.

impl<D> Encode<SupportedEncodings, D> for &SupportedEncodings

where D: ResourceDialect,

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

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

impl PartialEq for SupportedEncodings

fn eq(&self, other: &SupportedEncodings) -> 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 TypeMarker for SupportedEncodings

type Owned = SupportedEncodings

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 SupportedEncodings

type Borrowed<'a> = &'a SupportedEncodings

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: &<SupportedEncodings as TypeMarker>::Owned, ) -> <SupportedEncodings as ValueTypeMarker>::Borrowed<'_>

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

impl Persistable for SupportedEncodings

impl StructuralPartialEq for SupportedEncodings