Struct PacketHeader 

pub struct PacketHeader {
    pub buffer_lifetime_ordinal: Option<u64>,
    pub packet_index: Option<u32>,
    /* private fields */
}

PacketHeader

When referring to a free packet, we use PacketHeader alone instead of Packet, since while a packet is free it doesn’t really have meaningful offset or length etc.

A populated Packet also has a PacketHeader.

Fields

buffer_lifetime_ordinal: Option<u64>

This is which buffer configuration lifetime this header is referring to.

See [fuchsia.mediacodec/StreamBufferPartialSettings.buffer_lifetime_ordinal].

For QueueInputPacket(), a server receiving a buffer_lifetime_ordinal that isn’t the current input buffer_lifetime_ordinal will close the channel.

For output packets, this can be an old buffer_lifetime_ordinal only if EnableOldOutputBuffers was sent by the client. See also RemoveBuffer to determine when it’s safe to stop tracking old output buffers (only relevant to some video bitstream formats such as VP9, and only relevant to decoders). Streams that want to emit old output buffers are rare outside of bitstream format test streams.

packet_index: Option<u32>

When using SetInputBufferPartialSettings or SetOutputBufferPartialSettings to allocate buffers, the valid range of packet_index is from 0..buffer_count-1, where buffer_count is the length of [fuchsia.sysmem2/BufferCollectionInfo.buffers], considering input and output separately.

When using ParticipateInBufferAllocation and AddBuffer to allocate and add buffers, the valid range of packet_index is unconstrained (any uint32 value). The client and server must still ensure that packet_index values aren’t re-used until the other end has indicated the packet_index value is again available and can be re-used.

The number of concurrently in-flight packet_index values is limited per port (input vs. output) and buffer_lifetime_ordinal. If a client never puts the same input buffer in flight using more than one input packet concurrently, this inherently ensures the client will conform to this limit. Most clients can safely ignore this limit for output from the server. The limit is as follows:

• When sending a packet, the sender must ensure that the number of concurrently in-flight packet_index values under the port (input or output) and buffer_lifetime_ordinal does not exceed the high-water-mark number of buffers that have concurrently existed from the server’s point of view under the buffer_lifetime_ordinal so far. When using SetInputBufferPartialSettings, this is buffer_count as defined above.
• When using AddBuffer, the high-water-mark value is determined slightly differently for input vs. output.
  • For input, this high-water-mark value is the maximum value so far under the buffer_lifetime_ordinal of the total number of AddBuffer messages regarding the buffer_lifetime_ordinal minus the total number of RemoveBuffer messages regarding the buffer_lifetime_ordinal.
    • If a client never puts an input buffer in flight more than once concurrently using multiple different input packet_index values, then the client will inherently stay under this limit for input.
  • For output, this high-water-mark value is the maximum so far under the buffer_lifetime_ordinal of the total number of AddBuffer messages regarding the buffer_lifetime_ordinal minus the total number of completed buffer removals under the buffer_lifetime_ordinal. This is without regard to which buffer removals had a corresponding RemoveBuffer completion.
    • If a client wishes to (optionally) validate this server behavior, the client can rely on the server to not complete a RemoveBuffer until after completion of buffer removal server-side (else the server is failing to conform to RemoveBuffer semantics or failing to conform to this limit).

For input, the client chooses an available packet_index value arbitrarily when sending an input packet with QueueInputPacket, and the client doesn’t re-use the value until the server has sent OnFreeInputPacket with that packet_index value.

For output, the server chooses an available packet_index value arbitrarily (among all uint32 values) when sending an output packet with OnOutputPacket, and doesn’t re-use the value until the client has sent RecycleOutputPacket with that packet_index value.

Available packet_index values can be queued in arbitrary order.

Both the client and server should validate the packet_index against the known bound (if any; see above) and disconnect if it’s out of bounds.

The packet_index values don’t imply anything about order of use of packets. The client should not expect the ordering to remain the same over time - the stream processor is free to hold on to an input or output packet for a while during which some other packet_index values may be re-used multiple times.

For a given properly-functioning StreamProcessor instance, output packet_index values will be unique among concurrently-outstanding packets.

Servers should validate that a client isn’t double-using a packet and clients may similarly validate packet_index values from the server.

Trait Implementations

impl Clone for PacketHeader

fn clone(&self) -> PacketHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PacketHeader

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

Formats the value using the given formatter.

impl<D> Decode<PacketHeader, D> for PacketHeader

where D: ResourceDialect,

fn new_empty() -> PacketHeader

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 PacketHeader

fn default() -> PacketHeader

Returns the “default value” for a type.

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

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 PacketHeader

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

type Owned = PacketHeader

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 PacketHeader

type Borrowed<'a> = &'a PacketHeader

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

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

impl Persistable for PacketHeader

impl StructuralPartialEq for PacketHeader